Discussion :

[KINENVEU]

Bonjour,

je n'arrive pas a avoir le comportement que je veux avec un "callback" de bouton.

voici l'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
import Tkinter as tk
 
root = tk.Tk()
 
def callback(txt):
  print "--> callback: %s"%txt
 
aList = ["A", "B"]
for txt in aList:
  button = tk.Button(root, text=txt)
  button["command"] = lambda:callback(txt)
  button.config(width=30, height=10)
  button.pack()
 
root.mainloop()

lorsque j'appuie sur un bouton (A ou B), j'obtiens le meme resultat :

Code :

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

--> callback: b

or biensur, je voudrais que ce soit la lettre du bouton.

Comment faire pour que la fonction lambda ne soit pas liee a la variable temporaire "txt", mais a la valeur (a l'instance pour les cas plus complexes) de "txt" au moment de la creation de la fonction lambda ?

Quelqu'un pourrait-il m'eclairer ?

merci.

[PauseKawa]

Bonjour,

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
#!/usr/bin/env python
# encoding: utf-8
#
#
import Tkinter as tk
 
root = tk.Tk()
 
def callback(txt):
    print "--> callback: %s"%txt
 
aList = ["A", "B"]
for txt in aList:
    button = tk.Button(root, text=txt)
    button["command"] = lambda t=txt:callback(t)
    button.config(width=30, height=10)
    button.pack()
 
root.mainloop()

La fonction lambda est stocké à la création du Widget. Dans votre cas lorsque l'event appelle callback(txt) le for (utilisé à la création des Widgets) est fini et txt a pour valeur... La dernière.
Vous devez donc donner à lambda la valeur de txt au moment ou vous donnez votre fonction à command.

@+

[pfeuh]

Bonjour,

lambda est stocké à la création du Widget.

Ne serait-ce pas plutôt au moment de l'affection de la fonction lambda à l'attribut 'command'?

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
#!/usr/bin/env python
# encoding: utf-8
#
#
import Tkinter as tk
 
root = tk.Tk()
 
def callback(txt):
    print "--> callback: %s"%txt
 
aList = ["A", "B"]
buttons = []
for txt in aList:
    buttons.append(tk.Button(root, text=txt, command=lambda t=txt:callback(t), width=30, height=10))
    buttons[-1].grid()
for index, button in enumerate(buttons):  
    button["command"] = lambda text="new text %u"%(index + 1) :callback(text)
 
root.mainloop()

A+

Pfeuh

[KINENVEU]

Merci "PauseKawa",

c'est exactement la syntaxe que je cherchais.

[PauseKawa]

Bonsoir,

Bonjour,
Ne serait-ce pas plutôt au moment de l'affection de la fonction lambda à l'attribut 'command'?

Exact pfeuh, c'est bien au moment du

Code :

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

button["command"] = lambda t=txt:callback(t)

Par 'création du Widget' je voulais parler de

Code :

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

1
2
3
4
    button = tk.Button(root, text=txt)
    button["command"] = lambda t=txt:callback(t)
    button.config(width=30, height=10)
    button.pack()

Mais il est juste qu'il est nécessaire d’être précis dans les réponses.
Merci pour la rectification

@+

[wiztricks]

Salut,
Autre construction possible sans "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
#!/usr/bin/env python
# encoding: utf-8
#
#
import Tkinter as tk
 
root = tk.Tk()
#
#def callback(txt):
#    print "--> callback: %s"%txt
 
def callback(text):
    def inner():  #sans text=text parce que text est readonly.
        print "--> callback: %s" % text
    return inner
 
aList = ["A", "B"]
 
for txt in aList:
    button = tk.Button(root, text=txt)
#    button["command"] = lambda t=txt:callback(t)
    button["command"] = callback(txt)
    button.config(width=30, height=10)
    button.pack()
 
root.mainloop()

Il y a déjà une discussion sur ce sujet au post

lambda est parfois déroutant. C'est bien de connaître d'autres formes de fonctions "objets" - par abus de langage, celles dont on gèle d'une façon ou d'une autre les paramètres d'appel.
C'est un "objet" puisque la chose a un "état".

Plus verbeux, faire un objet "fonction"!

Code :

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

1
2
3
4
5
class callback(object):
    def __init__(self, text):
        self.text = text
    def __call__(self):
        print "--> callback: %s" % self.text

- W

[PauseKawa]

Bonjour,

Et nous en revenons aux sources:
command est là pour stocker une fonction.
lambda étant une fonction réduite à une simple expression, son utilité est incontournable pour le command du Widget Tkinter.Button.
Cela se complique lorsque la 'fonction' devient plus complexe.

Le tout est de maîtriser les expressions lambda.
Un exemple sans fonction:

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
#!/usr/bin/env python
# encoding: utf-8
#
#
try:
    import Tkinter as tk
except:
    import tkinter as tk
import sys
 
root = tk.Tk()
 
for txt in ["A", "B"]:
    button = tk.Button(root, text=txt)
    button["command"] = lambda t=txt: (sys.stdout.write("--> callback: %s"%t),
                                       sys.stdout.write("\n"),
                                       sys.stdout.flush())
    button.config(width=30, height=10)
    button.pack()
 
root.mainloop()

Testez lambda sans passer par Tkinter KINENVEU, c'est puissant

@+