[PYTHON] Traitement de fichiers multiples avec Kivy + Matplotlib + Draw Graph sur GUI
En me référant à diverses informations sur le net, j'ai également étudié l'interface graphique et travaillé sur un programme d'interface graphique permettant d'afficher entrée / sortie + traitement + graphique.
Environnement d'exécution
Windows10 Python 3.7.7 Kivy 1.11.1 L'interface graphique semble être populaire ces dernières années, j'ai donc défié Kivy.
GUI fait
La ligne supérieure est un bouton pour l'entrée / sortie et le traitement des fichiers. Sous le bouton se trouve la zone d'affichage du graphique. Le graphique est sélectionné et affiché dans le menu déroulant sur la gauche.
Code créé
Voici les détails du code. Le code côté kivy décrit le contenu lié à l'interface graphique (mise en page, sélection de fichier, fonction à appeler lorsqu'un bouton est pressé, etc.), et le code côté Python décrit le traitement réel. Premier Python
main.py
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import openpyxl
import os
from kivy.uix.boxlayout import BoxLayout
from kivy.app import App
from kivy.uix.widget import Widget
from kivy.uix.floatlayout import FloatLayout
from kivy.properties import ObjectProperty
from kivy.uix.popup import Popup
from kivy.garden.matplotlib.backend_kivyagg import FigureCanvasKivyAgg
class LoadDialog(FloatLayout):
load = ObjectProperty(None)
cancel = ObjectProperty(None)
Analysis = ObjectProperty(None)
current_dir = os.path.dirname(os.path.abspath(__file__))
class SaveDialog(FloatLayout):
save = ObjectProperty(None)
text_input = ObjectProperty(None)
cancel = ObjectProperty(None)
current_dir = os.path.dirname(os.path.abspath(__file__))
class MainBoard(BoxLayout):
file_name = ObjectProperty(None)
info = ObjectProperty(None)
bar_graph = ObjectProperty(None)
lbl4spinner = ObjectProperty([])
def __init__(self, **kwargs):
super(MainBoard, self).__init__(**kwargs)
self.master_flg = 0
self.lbl=[]
self.Data=[]
def dismiss_popup(self):
self._popup.dismiss()
def show_load(self):
content = LoadDialog(load=self.load, cancel=self.dismiss_popup, Analysis=self.Analysis)
self._popup = Popup(title="Load file", content=content,size_hint=(0.9, 0.9))
self._popup.open()
def show_save(self):
if self.master_flg==0:
self.info.text = 'Load masterfile first, please'
else:
content = SaveDialog(save=self.save, cancel=self.dismiss_popup)
self._popup = Popup(title="Save file", content=content, size_hint=(0.9, 0.9))
self._popup.open()
def load(self, path, filename, chkflg):
try:
if chkflg==1:
self.file_name.text=str(filename.pop(0))
else:
self.file_name.text=str(filename[0])
except Exception as e:
self.info.text=str(type(e))+' : '+str(e)
Matrix=pd.DataFrame([])
for i in range(len(filename)):
NewData = pd.read_excel(filename[i])
tmp_Data=NewData.iloc[0:,1:]
tmp_Data.index=NewData.iloc[:,0]
Matrix=pd.concat([Matrix,tmp_Data])
self.lbl=list(Matrix.index)
self.Data = Matrix
self.dismiss_popup()
def save(self, path, dirname):
with pd.ExcelWriter(os.path.join(path, dirname)) as writer:
self.Data.to_excel(writer)
self.dismiss_popup()
def Analysis(self):
try:
self.Data=self.Data*2
self.lbl4spinner=map(str,self.lbl)#Liste à passer au spinner
self.master_flg=1
self.info.text = 'Analysis completed!'
except Exception as e:
self.info.text=str(type(e))+' : '+str(e)
def on_spinner_select(self,text):
row_no=self.lbl.index(text)
Forgraph=self.Data.iloc[row_no,:]
plt.clf()
bar_plt=plt.bar(Forgraph.index, Forgraph)
self.ids.bar_graph.clear_widgets()
self.ids.bar_graph.add_widget(FigureCanvasKivyAgg(plt.gcf()))
class MainApp(App):
title = 'une analyse'
def build(self):
return MainBoard()
if __name__ == '__main__':
MainApp().run()
Puis Kivy
main.kv
<MainBoard>:
info: info
file_name: file_name
bar_graph: bar_graph
BoxLayout:
orientation: 'vertical'
pos: root.pos
size: root.size
canvas.before:
Color:
rgba: 0.9, 0.9, 0.9, 1
Rectangle:
pos: self.pos
size: self.size
Label:
id : info
text: 'load file first, please'
size_hint_y: 0.1
canvas.before:
Color:
rgba: 0, 0, 0, 1
Rectangle:
pos: self.pos
size: self.size
BoxLayout:
orientation: 'horizontal'
size_hint_y: 0.1
TextInput:
id: file_name
font_size: 12
size_hint_x: 0.7
BoxLayout:
orientation: 'horizontal'
size_hint_y: 0.1
Button:
text: 'Load & Analysis'
size_hint_x: 0.2
on_press: root.show_load()
Button:
text: 'Save data'
size_hint_x: 0.2
on_press: root.show_save()
Button:
text: "Exit"
id: btnExit
size_hint_x: 0.2
on_press: app.root_window.close()
BoxLayout:
orientation: 'horizontal'
size_hint_y: 0.7
Spinner:
text: "No."
values: root.lbl4spinner
size_hint: 0.1, 0.1
pos_hint: {'center_x': .5, 'center_y': .5}
on_text: root.on_spinner_select(self.text)
BoxLayout:
id: bar_graph
<LoadDialog>:
BoxLayout:
size: root.size
pos: root.pos
orientation: "vertical"
FileChooser:
id: filechooser
path:root.current_dir
multiselect: True
filters: ['*.xlsx']
FileChooserIconLayout
BoxLayout:
size_hint_y: None
height: 30
Button:
text: "Load selected file(s)"
on_press: root.load(filechooser.path, filechooser.selection,0)
on_release: root.Analysis()
Button:
text: "Load all files"
on_press: root.load(filechooser.path,filechooser.files,1)
on_release: root.Analysis()
Button:
text: "Cancel"
on_release: root.cancel()
<SaveDialog>:
BoxLayout:
size: root.size
pos: root.pos
orientation: "vertical"
BoxLayout:
size_hint_y: 0.1
Button:
text: 'ListView'
on_release: filechooser.view_mode = 'list'
Button:
text: 'IconView'
on_release: filechooser.view_mode = 'icon'
FileChooser:
id: filechooser
path:root.current_dir
on_selection: dir_name.text = self.selection and self.selection[0] or ''
filters: ['*.xls','*.xlsx']
FileChooserListLayout
TextInput:
id: dir_name
size_hint_y: None
height: 30
multiline: False
BoxLayout:
size_hint_y: None
height: 30
Button:
text: "Save"
on_release: root.save(filechooser.path, dir_name.text)
Button:
text: "Cancel"
on_release: root.cancel()
Commentaire
Le programme de base utilise le Filechooser de Kivy. Filechooser lui-même a des documents officiels et des explications de nombreux ancêtres, il est donc omis. Je n'expliquerai que où j'ai trébuché.
En raison du flux, le programme ne coule pas du haut, mais il va et vient entre le code Kivy et le code Py, donc je vais expliquer le long du flux.
1 Sélection de fichiers
--Lorsque vous appuyez sur le bouton Load de l'interface graphique après avoir démarré le programme, la fonction Show Load sera appelée depuis le côté Kivy.
main.kv
Button:
text: 'Load & Analysis'
size_hint_x: 0.2
on_press: root.show_load()
- La fonction Afficher le chargement lance LoadDialog dans une fenêtre séparée. À ce moment, les fonctions spécifiées (fonction de chargement, fonction d'annulation, fonction d'Analisys cette fois) dans la classe MainBoard sont liées par contenu. (Au début, je me demandais pourquoi c'était une chose aussi gênante, mais LoadDialog est une classe différente, donc je ne peux pas appeler la fonction associée directement.)
main.py
def show_load(self):
content = LoadDialog(load=self.load, cancel=self.dismiss_popup, Analysis=self.Analysis)
self._popup = Popup(title="Load file", content=content,size_hint=(0.9, 0.9))
self._popup.open()
- Code LoadDialog de Kiev. Dans FileChooser, sélectionnez le fichier. Cette fois, on suppose que les données d'origine sont enregistrées au format xlsx. Il est filtré afin que les fichiers aux formats inutiles ne soient pas affichés. En outre, la sélection multiple est spécifiée sur True afin que plusieurs fichiers puissent être sélectionnés. L'identifiant est une variable appelée filechooser qui contient l'adresse du fichier sélectionné.
main.kv
FileChooser:
id: filechooser
path:root.current_dir
multiselect: True
filters: ['*.xlsx']
FileChooserIconLayout
--Placez 3 boutons en suivant le code ci-dessus. (1) Lors de la sélection et de la spécification d'un fichier lu en cliquant sur (filechooser.selection) (2) Lors de la lecture de tous les fichiers du répertoire courant (filechooser.files) (3) Bouton Annuler. Lorsque vous appuyez sur les boutons ① et ②, la fonction de chargement est appelée en premier. Le dernier numéro de l'argument de la fonction de chargement est le numéro d'identification (car il appelle la même fonction).
main.kv
BoxLayout:
size_hint_y: None
height: 30
Button:
text: "Load selected file(s)"
on_press: root.load(filechooser.path, filechooser.selection,0)
on_release: root.Analysis()
Button:
text: "Load all files"
on_press: root.load(filechooser.path,filechooser.files,1)
on_release: root.Analysis()
Button:
text: "Cancel"
on_release: root.cancel()
2 Lire le fichier
--Dans la fonction Load côté Python, utilisez l'adresse du fichier passé de Filechooser (passé au format List) pour extraire les données de xls. La partie suivante est le code pour afficher l'adresse sur l'interface graphique. --A ce moment, si vous lisez tous les fichiers du répertoire en même temps, soyez prudent car l'adresse du répertoire (les fichiers ne sont pas liés) se trouve au début de la liste. Pour cela, nous avons extrait la première section de la liste. --```excepté Ececpiion as e: La partie après `` `affiche le contenu lorsqu'une erreur se produit.
main.pv
def load(self, path, filename, chkflg):
try:
if chkflg==1:
self.file_name.text=str(filename.pop(0))
else:
self.file_name.text=str(filename[0])
except Exception as e:
self.info.text=str(type(e))+' : '+str(e)
- Ensuite, lisez les données. Dans ce xlsx, le nom du paramètre est entré dans la colonne A et le numéro de données est entré dans la première ligne.
- L'instruction for lit à plusieurs reprises les données de toutes les fonctions sélectionnées et les stocke enfin dans les variables (matrice)
et `` `` self.Data. --Enfin, lorsque vous fermez
main.pv
Matrix=pd.DataFrame([])
for i in range(len(filename)):
NewData = pd.read_excel(filename[i])
tmp_Data=NewData.iloc[0:,1:]
tmp_Data.index=NewData.iloc[:,0]
Matrix=pd.concat([Matrix,tmp_Data])
self.lbl=list(Matrix.index)
self.Data = Matrix
self.dismiss_popup()
3. 3. une analyse
--Dans LoadDialog du côté kivy, la fonction Analysis est appelée par ```on_release: root.Analysis () `` `après la fonction Load.
- Décrivez ici le traitement des données que vous souhaitez réellement effectuer. Cette fois, nous doublons simplement les données.
--La liste suivante `` self.lbl4spinner = map (str, self.lbl) '' est la liste à passer au menu déroulant de sélection de graphique sur l'interface graphique.
--
self.master_flgest un indicateur indiquant si les données ont été lues. Il est utilisé pour juger s'il faut ou non épargner.
main.pv
def Analysis(self):
try:
self.Data=self.Data*2
self.lbl4spinner=map(str,self.lbl)#Liste à passer au spinner
self.master_flg=1
self.info.text = 'Analysis completed!'
except Exception as e:
self.info.text=str(type(e))+' : '+str(e)
Quatre. affichage graphique
- Tout d'abord, l'explication du côté kivy. Utilisez Spinner pour afficher un menu déroulant.
--
text: "No." `` `` Spécifie le caractère à afficher avant de tirer vers le bas. --`` `` values: root.lbl4spinneraffichera la liste obtenue dans la section d'analyse lors du tirage vers le bas. --```on_text: root.on_spinner_select (self.text), appelez la fonction on_spinner_select côté python avec l'élément sélectionné dans le menu déroulant comme argument (self.text``).
main.kv
Spinner:
text: "No."
values: root.lbl4spinner
size_hint: 0.1, 0.1
pos_hint: {'center_x': .5, 'center_y': .5}
on_text: root.on_spinner_select(self.text)
BoxLayout:
id: bar_graph
- La fonction on_spinner_select appelée crée un graphique basé sur les informations d'argument.
--
self.lbl.index (texte) `` `` Renvoie l'ordre (nombre de lignes) qui correspond aux informations sélectionnées dans le menu déroulant. --Forgraph = self.Data.iloc [row_no,:] Lit le nombre de lignes spécifié par` --Créez un graphique avecbar_plt = plt.bar (Forgraph.index, Forgraph) ''. Cette fois, j'ai créé un graphique à barres. --``` self.ids.bar_graph.add_widget (FigureCanvasKivyAgg (plt.gcf ()))pour dessiner un graphique sur Kivy`` BoxLayout``` (ʻId: bar_graph) .. --plt.clf (),self.ids.bar_graph.clear_widgets () '' est pour effacer le graphique précédent lors de la commutation de la sélection déroulante et du réaffichage. est.
main.py
def on_spinner_select(self,text):
row_no=self.lbl.index(text)
Forgraph=self.Data.iloc[row_no,:]
plt.clf()
bar_plt=plt.bar(Forgraph.index, Forgraph)
self.ids.bar_graph.clear_widgets()
self.ids.bar_graph.add_widget(FigureCanvasKivyAgg(plt.gcf()))
5．Save --Save est omis car il est traité de la même manière que Load.
6. Autre
- En préparation, vous devez définir Object au début de la classe MainBoard afin de communiquer entre Kivy et Python. De plus, il est nécessaire d'associer Object et id côté Kivy.
main.py
class MainBoard(BoxLayout):
file_name = ObjectProperty(None)
info = ObjectProperty(None)
bar_graph = ObjectProperty(None)
lbl4spinner = ObjectProperty([])
main.kv
<MainBoard>:
info: info
file_name: file_name
bar_graph: bar_graph
- De plus, les variables utilisées entre les fonctions sont déclarées et résumées lors de la phase d'initialisation pour éviter la duplication.
main.py
def __init__(self, **kwargs):
super(MainBoard, self).__init__(**kwargs)
self.master_flg = 0
self.lbl=[]
self.Data=[]
Sites pris en charge
J'ai notamment évoqué les informations relatives à Kivy sur le site suivant. document officiel kivy: Filechooser Après tout, le premier est le document officiel. Désir de freelance Cela a été utile comme point de départ. La disposition de cette interface graphique est également mentionnée ici. blog narito Cela a été très utile pour comprendre la relation entre Kivy et Python. stackoverflow : Python - Kivy framework - Spinner values list Affichage de la liste sur Spinner, je pense que j'aurais été bloqué sans ce post.
Ce que je veux améliorer à l'avenir
J'utilise des identifiants pour le dessin graphique, mais je veux le décrire avec Object Propaty.
Recommended Posts