[Python 3.X] Prblm de récup de données et de conversion str--> int d'Entry (Python/Tkinter/POO)

2 pièce(s) jointe(s)

Prblm de récup de données et de conversion str--> int d'Entry (Python/Tkinter/POO)

Bonjour à tous,

c'est la première fois pour moi que je demande qquchse sur ce forum, donc voilà, je viens de finir ma première année de BTS SIO(Services Informatique aux Organisations) ( pour vous situer mon niveau) je travaille sur un logiciel de calcul matriciel lié à la biochimie (Cahier des charges(plus ou moins) : https://www.dropbox.com/s/56q420clei...arges.pdf?dl=0 )

, depuis une semaine, on m'a demandé de le faire en python que je ne connais pas bien à part pour des tout petits programmes sur console (vraiment très petits, j'aurais voulu le faire en VB car je m'y connais plus surtout pour de la programmation objet), donc je découvre depuis peu python mais surtout Tkinter.

L'archive "premier test" en pièce jointe est le premier mini programme que j'ai fait pour m'entrainer avant de "m'attaquer" au gros(gros à mon gout :) ) et l'archive "control" est celle du programme que je dois faire et dont je vous ai copier/coller le code.Pièce jointe 180200 Pièce jointe 180201

Pour l'instant je suis sur la saisie d'une matrice j'ai créer une classe matrice avec (lignes, colonnes)( fichier : model.py) , et j'ai aussi créer une classe à part( fichier ctrl.py ) de contrôle d'édition de matrice et c'est dans cette classe que je suis perdue.

Sur la fenêtre il y a à gauche 2 entry pour la saisie du nombre de lignes et de colonnes de la matrice à droite qui est composé de boutons indicatifs qui donnent le nom de chaque lignes et colonnes (Ex: S1 --> Substrat 1, R1 --> Réaction 1) et à l'intérieur d'Entry pour chaque valeur de la matrice, j'ai besoin d'aide pour récuperer le nombre de lignes/colonnes et créer les boutons et les champs de la matrice en conséquence .

Merci beaucoup pour votre temps, si vous avez des remarques ou des conseils ditez moi ça m'aiderait beaucoup . :)

voici le code du fichier ctrl.py:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
# -*-coding:utf-8 -*
# ctrl
from tkinter import *
from model import *
#Cette classe hérite de tkinter.Frame (objet graphique)
class ctrlEditMatrice(Frame):
    "Controleur graphique pour l'édition d'une matrice" # pour la documentation
    def __init__(self, parent,matr):
        Frame.__init__(self,parent) #appel du constructeur de la classe parente
        self.parent = parent # on conserve en attribut la fenêtre parente qui contient le controleur
        self.matr = matr # on met en attribut la matrice à éditer
        self._initialize() # on appelle la méthode d'initialisation du widget
 
    def _initialize(self):
        "méthode privée appelée par le constructeur pour charger et remplir les éléments graphiques" # commentaire de documentation
 
        #crée et positionne les widget de la colonne 0 qui servent au choix du nombre de lignes/colonnes
        self.label_NbreLignes = Label(self, text="Nombre de lignes:")
        self.label_NbreLignes.grid(column=0, row=0, sticky='NSEW')
        self.label_NbreColonnes = Label(self, text="Nombre de colonnes:")
        self.label_NbreColonnes.grid(column=0, row=2, sticky='NSEW')
        self.entry_NbreLignes = Entry(self, textvariable="3")
        self.entry_NbreLignes.grid(column=0, row=1, sticky='NSEW') # positionne le champ dans la grille
        self.entry_NbreColonnes = Entry(self, textvariable="4")
        self.entry_NbreColonnes.grid(column=0, row=1, sticky='NSEW') # positionne le champ dans la grille
        self.btn_Val_L_C = Button(self, text= "Valider")#, command= self._updateMatrModelLC)
        self.btn_Val_L_C.grid(column=0,row=5, sticky='NSEW')
        #crée et positionne le bouton qui efface toutes les values des entry de la matrice
        self.btn_Erase_All = Button(self, text= "Effacer tout")#, command=)
        self.btn_Erase_All.grid(column=2,row=0)
 
 
        try:
            int_nb_l = int(self.entry_NbreLignes.get())
        except :
            raise ValueError("Vous n'avez pas entrer un int")
 
        try:
            int_nb_c = int(self.entry_NbreColonnes.get())
        except :
            raise ValueError("Vous n'avez pas entrer un int")
 
 
        #affiche le nom des lignes/colonnes de la matrice
        for i in range (int_nb_l):
            self.btn_S_M = Button(self, text=("S"+str(i+1)), width=10)
            self.btn_S_M.grid(column=2, row=(i+1+3), sticky='NSEW')
        for i in range (int_nb_c):
            self.btn_R_M = Button(self, text=("R"+str(i+1)), width=10)
            self.btn_R_M.grid(column=(i+1+2), row=0, sticky='NSEW')
 
        #reation des entre de saisie de values de la matrice
        rows = []
        for i in range(int_nb_l+4):
            cols = []
            for j in range(int_nb_c+3):
                self.entry_Matrice = Entry(self, justify='CENTER', cursor='pencil')
                #self.entry_Matrice.insert(END '(%d , %d)' % ((i-4), (j-3)))
                cols.append(self.entry_Matrice)
                self.entry_Matrice.grid(column=j, row=i)
            rows.append(cols)
 
    # methode de mise à jour du nom dans le modèle après modif sur l'interface
    def _updateMatrModelLC(self):
        self.matr.lignes= int_nb_l
        self.matr.colonnes= int_nb_c
 
"""# methode de mise à jour du nom dans le modèle après modif sur l'interface
    def _updateMatrModelAll(self):
        self.matr.lignes= self.entry_NbreLignes.get()
        self.matr.colonnes= self.entry_NbreColonnes.get()
        for i in range (self.lignes):
            for j in range (self.colonnes):
                self.tableau[i][j] = self..get()
 
"""
    # méthode permettant d'afficher le controleur
    def show(self):
        self.pack()

Le code du fichier model.py:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
# -*-coding:utf-8 -*
# object model classes
from numpy import *
from tkinter import *
class Matrice:
    "classe métier représentant une classe" # documentation
    def __init__(self, lig, col):
        #self.nom = nom
        self.lignes = lig
        self.colonnes = col
        self.tableau = [] #Initailise la representat° interne de la matrice
#comme un tableau
        for i in range(self.lignes):
            l =[]
            for j in range(self.colonnes):
                l.append(None)
            self.tableau.append(1)
 
# accesseurs
    def getLignes(self):
        return self.lignes
 
    def setLignes(self, value):
        self.lignes = value
 
    def getColonnes(self):
        return self.colonnes
 
    def setColonnes(self, value):
        self.colonnes = value
 
    def getTableau(self):
        return self.tableau
 
    def Ask_lig_col(self):
        self.lignes=int(input("Nombre de lignes:"))
        self.colonnes=int(input("Nombre de colonnes:"))
 
 
    def __call__(self,i,j):
        """permet d'obtenir l'entrée (i,j) de la matrice A en tapant A(i,j),
        autrement dit informatiquement, en considérant la matrice
        comme fonction de i,j
        on pourra voir l'entrée A(2,1) d'ut matrice A simplement
        avec la syntaxe: >>A(2,1)"""
        return self.tableau[i][j]
 
    def __add__(self, autre):
        """renvoie la somme de la matrice self et de la matrice
        autre"""
        if (isinstance (autre, Matrice)):
            if (self.lignes == autre.lignes and self.colonnes == autre.colonnes):
                m = Matrice (self.lignes, self.colonnes)
                m.remplir(lambda i,j: self(i,j) + autre(i,j))
                return m
            else:
                raise ValueError("Dimension des matrices incompatibles")
        else:
            raise ValueError("L'objet que vous voulez ajouter n'est pas une matrice")  
            """si A et B sont deux objets de notre classe matrice,
            elle sera appelee si on tape: A+B  """
 
    def __mul__(self, autre):
        """renvoie le produit de la matrice self avec la matrice autre"""
        if (isinstance (autre, Matrice)):
            if (colonnes.lignes == autre.lignes):
                m = Matrice (self.lignes, self.colonnes)
                for k in range (autre.lignes):
                    m.remplir(lambda i,j: self(i,j) * autre(k,j))
                    return m
            else:
                raise ValueError("Dimension des matrices incompatibles")
        else:
            raise ValueError("L'objet que vous voulez multiplier n'est pas une matrice")
 
    """def __iter__(self):
        ""Permet de faire des boucles for qui parcourent
        les entrées de la matrice"
        for ligne in self.tableau:
            for entree in ligne:
                yield (entree)""remplace le return
                fabrique un objet= générateur => ce qu'on peut utilisé dans une
                boucle for (ex: range(1,n) est aussi un générateur)""
                """
 
    def matrice_Identite(self):
        if (self.lignes == self.colonnes):
            matrice = eye(self.lignes)
            return matrice
        else:
            raise ValueError("La matrice n'est pas carrée")
    def inversion (self):
        if (self.lignes == self.colonnes):
            linalg.inv(self.tableau)
        else:
            raise ValueError("La matrice n'est pas carrée")
    def delete_values(self):
        for lignes in self.tableau:#utilise la methode __iter__ pour parcourir
            for entree in lignes:
                entree = None

Voici le code du fichier main.py:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# -*-coding:utf-8 -*
from model import * # importe toutes les classes du fichier model.py
from ctrl import *  # importe toutes les classes du fichier ctrl.py
 
from tkinter import * # importe toutes les classes du module tkinter
 
#main function to load main window only.
if __name__ == "__main__":
    #instanciation de la fenetre principale
    window = Tk() # génère la fenêtre vide.
    window.title("Mon application Tkinter") # applique un titre à la fenêtre
    window.grid() # Définit la façon dont les éléments vont être organisés dans la fenêtre.
    # La grille et le moyen le plus cool pour gérer la disposition des éléments
    window.resizable(True,True) # Définit si on peut redimentionner la fenetre selon les axes X et Y.
    window.geometry("800x600") # Définit la taille par defaut.
 
    #chargement des données
    matrice_test = Matrice(3, 4)
    #chargement du widget
    widget1 = ctrlEditMatrice(window, matrice_test)
 
    widget1.show() # permet de réaficher le controleur 1
 
    window.mainloop() # boucle d'écoute des événements de la fenetre.

Et puis j'ai un autre fichier startProg.bat:

Code:

1
2
3
@echo off
python main.py
pause

Salut,

Si je comprend bien, le bouton self.btn_Val_L_C est à utiliser après entrée du nombre de lignes et de colonnes.

Ce bouton n'a pas de commande, il n'est connecté à rien, bien que le commentaire semble dire que tu veuilles qu'il appele la méthode self._updateMatrModelLC ou peut-être as-tu changer ça. Il faut mettre cette commande, sinon le bouton ne sert à rien.

Tu as mis ceci dans l'initialisation:
Code:

1 2 3 4 5 6 7 8 9 10 try: int_nb_l = int(self.entry_NbreLignes.get()) except : raise ValueError("Vous n'avez pas entrer un int") try: int_nb_c = int(self.entry_NbreColonnes.get()) except : raise ValueError("Vous n'avez pas entrer un int")
Normalement tu auras une erreur ValueError: Vous n'avez pas entrer un int au lancement de l'appli puisqu'à ce stade l'utilisateur n'a encore rien fait. l'interface n'est même pas encore affichée.

Mets ces lignes dans ta méthode _updateMatrModelLC(self).

A ta place, je ne leverai pas une erreur sur une faute de frappe utilisateur. Ignore les mauvaises entrées, je suppose que les entry ont une méthode clear() ou un nom similaire pour effacer leur contenu, c'est toi qui connais.

Tu peux faire un truc dans le genre:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 def _updateMatrModelLC(self): int_nb_l = False int_nb_c = Fals try: int_nb_l = int(self.entry_NbreLignes.get()) except ValueError: # pas bon, on efface self.entry_NbreLignes.clear() try: int_nb_c = int(self.entry_NbreColonnes.get()) except ValueError: # pas bon, on efface self.entry_NbreColonnes.clear() if all((int_nb_l, int_nb_c)): # les deux entrees sont bonnes exécution des modifications .....
Vérifie comment on efface une entry.

Citation:
Envoyé par VinsS
Salut,

Si je comprend bien, le bouton self.btn_Val_L_C est à utiliser après entrée du nombre de lignes et de colonnes.

Ce bouton n'a pas de commande, il n'est connecté à rien, bien que le commentaire semble dire que tu veuilles qu'il appele la méthode self._updateMatrModelLC ou peut-être as-tu changer ça. Il faut mettre cette commande, sinon le bouton ne sert à rien.

Tu as mis ceci dans l'initialisation:
Code:

1 2 3 4 5 6 7 8 9 10 try: int_nb_l = int(self.entry_NbreLignes.get()) except : raise ValueError("Vous n'avez pas entrer un int") try: int_nb_c = int(self.entry_NbreColonnes.get()) except : raise ValueError("Vous n'avez pas entrer un int")
Normalement tu auras une erreur ValueError: Vous n'avez pas entrer un int au lancement de l'appli puisqu'à ce stade l'utilisateur n'a encore rien fait. l'interface n'est même pas encore affichée.

Mets ces lignes dans ta méthode _updateMatrModelLC(self).

A ta place, je ne leverai pas une erreur sur une faute de frappe utilisateur. Ignore les mauvaises entrées, je suppose que les entry ont une méthode clear() ou un nom similaire pour effacer leur contenu, c'est toi qui connais.

Tu peux faire un truc dans le genre:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 def _updateMatrModelLC(self): int_nb_l = False int_nb_c = Fals try: int_nb_l = int(self.entry_NbreLignes.get()) except ValueError: # pas bon, on efface self.entry_NbreLignes.clear() try: int_nb_c = int(self.entry_NbreColonnes.get()) except ValueError: # pas bon, on efface self.entry_NbreColonnes.clear() if all((int_nb_l, int_nb_c)): # les deux entrees sont bonnes exécution des modifications .....
Vérifie comment on efface une entry.
Bonjour merci pour votre réponse rapide,

oui le bouton self.btn_Val_L_C est à utiliser après entrée du nombre de lignes et de colonnes, je voulais le conecter à la méthode self._updateMatrModelLC mais je l'ai mis en commentaire le temps que ça marchait pas

Ah oui c'est vrai je suis nulle ><" ^^ j'ai rajouter le ValueError après pour voir si c'est pour cette raison que ça ne marchait pas,

oui c'est une bonne idée, merci pour ce bout de code je vais tester ça !