Discussion :

[gpepy]

Bouteille à la mer :
Débutant en Python, utilisant Spyder, pour un logiciel scientifique j'ai besoin d'entrer des valeurs de paramètres, certaines sont liées entre elles. J'ai donc créé une liste de Entry où je peux mettre des valeurs. Je voudrais pour chaque Entry récupérer son rang quand je tape <Entrée> afin de calculer des valeurs dérivées. Voici un logiciel élémentaire qui ne fonctionne pas car je ne maîtrise pas encore l'utilisation des fonctions lambda !

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
# -*- coding: utf-8 -*-
"""
Created on Sat Jan 26 16:31:01 2022
 
@author: Utilisateur
"""
import PIL
import tkinter as tk
 
fen = tk.Tk()
 
values = []
Evalues = []
row2 = 0
mpici = 0
 
 
def evalprint(num1):
    print("In evalprint  num1=", num1)
 
for i in range(3) :
    row2 = row2 + 1
    values.append(tk.StringVar(fen, value=0.))
    Evalues.append(tk.Entry(fen, text=values[mpici], width=20))  # makes another Entry box appear      
    Evalues[mpici].grid(column=0, row=row2)
 
    Evalues[mpici].bind('<Return>', lambda num1=mpici : evalprint(num1))
    mpici = mpici+1
 
fen.mainloop()

[wiztricks]

Salut,

Ca marcherait mieux avec:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

    Evalues[mpici].bind('<Return>', lambda e, num1=mpici : evalprint(num1))

Ce qui ne veut pas dire que ce soit un code "génial"... et pour les explications, il y a des tutos.

- W

[Beginner.]

Je voudrais pour chaque Entry récupérer son rang quand je tape <Entrée> afin de calculer des valeurs dérivées.

Je pense qu'il y a plusieurs solutions...

Tu pourrais donner un nom à chaque Entry (si tu ne donnes pas un nom explicite de ton choix alors un nom sera donné par défaut, "!entry" pour le premier, "!entry1" pour le second et "!entry2" pour le troisième)

Ensuite dans ta fonction evalprint tu récupères le nom à l'aide de la fonction : widget.winfo_name et le contenu avec la fonction : get

Exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import tkinter as tk
 
fen = tk.Tk()
 
def evalprint(evt):
    nom = evt.widget.winfo_name()
    valeur = evt.widget.get()
    print(f"Le nom de l'Entry est: {nom} et son contenu est: {valeur}")
 
 
Evalues = []
for i in range(3):
    Evalues.append(tk.Entry(fen, width=20))
    Evalues[i].insert(0, '0.0')
    Evalues[i].grid(column=0, row=i)
    Evalues[i].bind('<Return>', evalprint)
 
fen.mainloop()

J'ai supprimé certaines variables de ton code car on pouvait s'en passer...

J'ai laissé les noms donnés par défaut mais si tu veux donné tes propres noms (ce qui serait préférable pour la lisibilité du code) c'est facile à faire...

[wiztricks]

Je pense qu'il y a plusieurs solutions...

Tu pourrais donner un nom à chaque Entry (si tu ne donnes pas un nom explicite de ton choix alors un nom sera donné par défaut, "!entry" pour le premier, "!entry1" pour le second et "!entry2" pour le troisième)

La question du PO est claire: j'ai une liste d'entry, je veux passer l'index de l'entry au callback et je ne m'en sort pas côté lambda pour passer cette info. Après on peut changer de sujet... mais autant éviter de mélanger le TCL way avec la Python way (surtout quand çà n'apporte pas grand chose):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import tkinter as tk
 
root = tk.Tk()
def evalprint(event):
    w = event.widget  
    v = w.get()
    i = entries.index(w)
    print(f"entry {i = } contient: /{ v }/")
 
entries = []
for i in range(3):
    w = tk.Entry(root, width=20)
    w.insert(0, '0.0')
    # w.grid(column=0, row=i)
    entries.append(w)
 
root.bind('<Return>', evalprint)
 
tk.mainloop()

- W

[Invité]

Ou bien sans passer par une liste, ajouter un attribut "index" aux entrées...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import tkinter as tk
 
root = tk.Tk()
def evalprint(event):
    w = event.widget  
    v = w.get()
    i = w._index_
    print(f"entry {i = } contient: { v }")
 
for i in range(3):
    w = tk.Entry(root, width=20)
    w.insert(0, '0.0')
    w._index_ = i
    w.grid(column=0, row=i)
 
root.bind('<Return>', evalprint)
 
tk.mainloop()

[wiztricks]

Ou bien sans passer par une liste, ajouter un attribut "index" aux entrées...

L'ajout d'un attribut à la volée à l'instance d'une classe est possible avec Python mais montrer ça à des débutants comme exemple de ce qu'il faut faire n'est pas très sérieux. Et si on veut aider le PO à réaliser son idée de départ (qui n'est pas plus mauvaise qu'une autre), çà donnerait plutôt:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import tkinter as tk
 
def evalprint(i):
    w = entries[i]
    v = w.get()
    print(f"entry {i = } contient: { v }")
 
entries = [] 
 
for i in range(3):
    w = tk.Entry(width=20)
    w.insert(0, '0.0')
    w.grid(column=0, row=i)
    w.bind('<Return>', lambda e, i=i: evalprint(i))
    entries.append(w)
 
tk.mainloop()

note: et on réfléchit aux petites différences entre les codes.



- W

[Invité]

Aurais-tu l'amabilité de m'expliquer pourquoi ?
Il me semble que vous m'aviez déjà fait ce reproche avec Sve@r par le passé.
Le risque d'écraser un attribut/fonction existant.e ?

S'il y a une autre raison que je ne vois pas, autant utiliser un dictionnaire, non ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import tkinter as tk
 
root = tk.Tk()
def evalprint(event):
    w = event.widget  
    v = w.get()
    i = dico[w]
    print(f"entry {i = } contient: { v }")
 
dico = {} 
for i in range(3):
    w = tk.Entry(root, width=20)
    w.insert(0, '0.0')
    dico[w] = i
    w.grid(column=0, row=i)
 
root.bind('<Return>', evalprint)
 
tk.mainloop()

[fred1599]

Bon ben tu ne m'auras pas convaincu de ne pas squatter les instances de classe

C'est certe une question d'expérience comme le dit @wiztricks, mais aussi de bons sens...

Quand on sait ce qu'on fait il n'y a pas de problème à faire, mais comme tu ne connais pas forcément la classe Entry qui hérite de multiples autres classes, tu n'as sans doute pas été dans le code source pour vérifier que l'attribut index n'existe pas déjà et serait potentiellement utile au bon fonctionnement du widget. Parce-que lorsqu'on hérite à de multiples classes on hérite pas juste des méthodes mais aussi de ses attributs. Dans ton cas ça tombe pas bien, car tu écrase une méthode index déjà existante.

Alors c'est pas conseillé, car on fait rarement cela professionnellement, pourquoi on proposerait cela à un débutant ?

[Invité]

Effectivement !

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
>>> e = tk.Entry()
>>> hasattr(e, "index")
True
>>> hasattr(e, "_index_")
False

[wiztricks]

C'est certe une question d'expérience comme le dit @wiztricks, mais aussi de bons sens...

Le "bon sens" ne vient qu'avec l'expérience. On peut accélérer cette acquisition en travaillant en équipe avec des "anciens", en discutant à la cantine ou à la machine à café sur le pourquoi de...

Quand on bricole dans son coin, on découvre plein de techniques qui marchent mais sans règle permettant d'estimer leur pertinence, on peut faire du grand n'importe quoi sans même s'en rendre compte.

- W