Tkinter et les Buttons mystère !

Version imprimable

Bonjour,

j'étais en train de coder un petit dialog tout ce qu'il y a de plus simple en Tkinter quand je suis tombé sur un comportement des plus mystérieux !

Voici la bête (tout est dans les commentaires) :

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
#coding:cp1252
 
# affiche une boîte de dialogue simple : 
#  - une listbox contenant un texte de quelques lignes 
#  - des boutons qui lancent des actions sur ce texte
def main_menu ( lines,buttons ):
    import Tkinter
    root = Tkinter.Tk()
    # la listbox
    listbox = Tkinter.Listbox( root )
    for f in lines : listbox.insert( Tkinter.END,f )
    listbox.pack()
    # les boutons = paires ( libélé , fonction )
    for name,func in buttons :
        print name,func # quelques traces pour vérifier
        butt = Tkinter.Button( root,text = name,command = lambda : func( lines ))
        butt.pack()
    # et c'est parti !
    root.mainloop()
 
def message ( *t ) : # ch'tite fonction qui ne fait pas grand chose... 
    print t
 
# 10 lignes de texte sans intèret
lines = ['-- %d '%i+'-'*i for i in xrange( 10 )]
 
# liste de paires ( libellé du bouton , fonction associée )]
buttons  = [('button %d'%i , lambda l : message( 'Button %d'%i,l[i:i+2] )) for i in xrange( 5 )]
 
# appel du dialog
main_menu( lines,buttons ) #---> tous les boutons lancent la même fonction (la dernière)
 
# peut-être qu'il n'aime pas un tableau de lambdas construites à la volée ?
# Ok, je définis mes fonctions une par une :  
def s1 ( l ) : message( 's1',l[0] )
def s2 ( l ) : message( 's2',l[0:2] )
def s3 ( l ) : message( 's3',l[1:5] )
buttons2 = [('s1',s1),('s2',s2),('s3',s3)]
main_menu( lines,buttons2 ) #---> idem !!!

Je lance mon machin et clique sur chaque bouton : voici les traces que j'obtiens sur la console :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
button 0 <function <lambda> at 0x02AC4470>
button 1 <function <lambda> at 0x02AC43F0>
button 2 <function <lambda> at 0x02AC4630>
button 3 <function <lambda> at 0x02AC4670>
button 4 <function <lambda> at 0x02AC46B0>
('Button 4', ['-- 4 ----', '-- 5 -----'])
('Button 4', ['-- 4 ----', '-- 5 -----'])
('Button 4', ['-- 4 ----', '-- 5 -----'])
('Button 4', ['-- 4 ----', '-- 5 -----'])
('Button 4', ['-- 4 ----', '-- 5 -----'])
s1 <function s1 at 0x02AC4AF0>
s2 <function s2 at 0x02AC46F0>
s3 <function s3 at 0x02AC4530>
('s3', ['-- 1 -', '-- 2 --', '-- 3 ---', '-- 4 ----'])
('s3', ['-- 1 -', '-- 2 --', '-- 3 ---', '-- 4 ----'])
('s3', ['-- 1 -', '-- 2 --', '-- 3 ---', '-- 4 ----'])

Comme on le voit, les fonctions passées à Button sont bien différentes mais seule la dernière semble appelée...

Quelqu'un y comprend-il quelque chose ?

Merci d'avance !

12/11/2013, 18h23
wiztricks
Salut,
La question est de savoir a quoi seront instanciées les "variables" avec lesquelles sont déclarées/construites les lambda lorsqu'elles seront appelées.
Exemple, en écrivant:

Code:

buttons = [('button %d'%i , lambda l: message( 'Button %d'%i,l[i:i+2] )) for i in xrange( 5 )]

que vaudra "i" a l'appel du lambda: 5.
Ecrivons cela autrement:
Code:

1 2 def mylambda(l): message('Button %d'%i,l[i:i+2] ))
Ce foutu "i" est a priori une sorte de variable "globale" (dans un scope externe).
Pour s'en sortir, il faut coller le "i" dans les paramètres de la fonction:

Code:

buttons = [('button %d'%i , lambda l, i=i: message( 'Button %d'%i,l[i:i+2] )) for i in xrange( 5 )]

De même, dans la boucle for name, func...

Code:

Tkinter.Button( root,text = name,command = lambda func=func: func( lines ))

- W
13/11/2013, 10h16
Captain'Flam
En effet, ça fonctionne !

J'ai trouvé un exemple beaucoup plus condensé :
Code:

1 2 >>> [lambda : i for i in ( 3,4,5 )] [<function <lambda> at 0x027F3EB0>, <function <lambda> at 0x027F3E30>, <function <lambda> at 0x027F3E70>]
On voit bien qu'on a des fonctions différentes.
Code:

1 2 >>> [lambda : i for i in ( 3,4,5 )][0]() 5
Mais le "i" de chacun instance semble valoir 5.

Si on ajoute un paramètre avec une valeur par défaut (ce qui permet de mimer une fonction sans paramètre), ça marche :
Code:

1 2 >>> [lambda j=i : j for i in ( 3,4,5 )][0]() 3
je suis bien content d'avoir compris ce truc, mais il faudrait dire à Guido (ou ses successeurs) que ce n'est pas joli joli (à moins qu'il y ait une excellente raison qui m'échappe encore)...

Un grand merci !
13/11/2013, 11h02
wiztricks
Citation:

Envoyé par Captain'Flam

je suis bien content d'avoir compris ce truc, mais il faudrait dire à Guido (ou ses successeurs) que ce n'est pas joli joli (à moins qu'il y ait une excellente raison qui m'échappe encore)..

Hmm... C'est pas facile a raconter. La façon la plus "rapide" est de se souvenir qu'en Python, il y a un monde d'objets et un code interprété qui y accède via ces chemins qu'on appelle "variables".
En écrivant:

Code:

L = [ lambda : i for i in ( 3,4,5 ) ]

On pense "valeur de i" alors qu'en fait ce sera l'objet référencé par la variable "i" lorsque la fonction sera évaluée.
Exemple:
Code:

1 2 3 4 5 6 7 8 >>> L = [ lambda : i for i in range(3) ] >>> i 2 >>> L[0]() 2 >>> i = 7 >>> L[0]() 7
En écrivant:

Code:

L = [ lambda i=i: i for i in range(3) ]

On crée, par effet de bord, un chemin "i" dans l'espace locals() de la fonction par l'assignation (une référence) a l'objet accessible par le chemin "i" globals() lors de sa construction.
La déclaration de paramètres avec des valeurs par défaut:
Code:

1 2 def foo(i=0): pass
ne fait rien d'autre.

Une partie de cette mécanique est liée a la nature "interprétée" du langage (et se retrouve en assembleur). Ce qui est spécifique Python est la séparation entre chemins et objets: que des références, pas de "valeur" .
- W

Arf... je comprends...

Cette explication révèle un autre truc assez pervers :
Les variables utilisées dans les listes en compréhension ne sont pas muettes.

Quand on écrit

Code:

L = [ i for i in ( 3,4,5 ) ]

en plus de L (qui vaudra [3,4,5], on créé aussi la variable globale i qui aura la valeur 5.

Et si i existait avant, elle sera écrasée...

On aurait pu imaginer que ce i soit une variable locale de compréhension.

Mais en faisant d'autres tests autour de cette question, je suis tombé sur un truc encore plus bizarre :
Code:

1 2 3 4 5 6 7 8 >>> LL = lambda : [ lambda : u for u in ( 3,4,5 ) ] >>> L = LL() >>> L[0]() 5 # retourne la valeur courante de la variable 'u' >>> u Traceback (most recent call last): File "<stdin>", line 1, in <module> NameError: name 'u' is not defined # toutefois 'u' ne semble pas définie !
Dans cet exemple, que retourne vraiment L[0]() ?
u existe-elle quelque part, dans un endroit inaccessible ?

14/11/2013, 15h31
wiztricks

Citation:

Envoyé par Captain'Flam

Quand on écrit

Code:

L = [ i for i in ( 3,4,5 ) ]

en plus de L (qui vaudra [3,4,5], on créé aussi la variable globale i qui aura la valeur 5.

Et si i existait avant, elle sera écrasée...

On aurait pu imaginer que ce i soit une variable locale de compréhension.

Heu? Essayez pour voir, vous serez encore plus perplexe.
- W
15/11/2013, 09h28
Captain'Flam

Citation:

Essayez pour voir, vous serez encore plus perplexe.

Je ne comprends pas... que fait-il que j'essaie ?
15/11/2013, 10h44
wiztricks

Citation:

Envoyé par Captain'Flam

Je ne comprends pas... que fait-il que j'essaie ?

Essayez de faire marcher votre code, vous verrez qu'il n'y a pas de "i" dans le globals().
- W

Heu... bé si ! i est bien dans globals() :

Code:

1
2
3
4
5
6
7
>>> L = [ i for i in ( 3,4,5 ) ]
>>> L
[3, 4, 5]
>>> i
5
>>> globals()
{'__builtins__': <module '__builtin__' (built-in)>, 'L': [3, 4, 5], '__package__': None, 'i': 5, '__name__': '__main__', '__doc__': None}

Ah oui, enfin, c'est dans globals() mais en 2.7.
Sous 3.3:

Code:

1
2
3
4
5
6
7
8
9
Python 3.3.2 (v3.3.2:d047928ae3f6, May 16 2013, 00:03:43) [MSC v.1600 32 bit (In
tel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> L = [ i for i in (3,4,5) ]
>>> i
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'i' is not defined
>>>

- W