Discussion :

[Captain'Flam]

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 :

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
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 :

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
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 !

[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 :

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

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 :

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

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 :

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

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 :

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

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

- W

[Captain'Flam]

En effet, ça fonctionne !

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

Code :

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

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 :

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

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 :

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

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 !

[wiztricks]

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 :

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

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 :

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

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 :

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

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 :

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

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

[Captain'Flam]

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 :

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

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 :

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

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 ?

[wiztricks]

Quand on écrit

Code :

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

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