Discussion :

[Shozma]

Salut,

Je me doute que le titre n'est pas clair, il est à l'image de mon problème.

J'ai dans mon programme (simplifié plus bas), une liste de boutons accolés à des OptionMenu. Tous ces boutons vont appeler la même fonction (l'affichage d'un formulaire).
Je souhaite lors de l'appelle de cette fonction l'export des 'text' des boutons, ainsi que les choix fait dans les OptionMenu correspondant.
J'ai encapsulé les couples bouton-OptionMenu dans des frames en me disant que ça pouvait être utile pour résoudre mon problème.
La frame1 n'est pas vraiment utile j'imagine mais je la laisse car les parties de mon programme principale sont découpée en frame.

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
class Appli:
    def __init__(self):
        self.root = Tk()
        Label(self.root, text ='Choix:').grid(row =0, column =1, padx =20)
        self.frame1 = Frame(self.root, borderwidth=4, relief=GROOVE)
        self.frame1.grid(row =1, column =0)
        for i in range(4):
            fra = Frame(self.frame1, borderwidth=2, relief=RAISED)
            fra.grid()
            Button(fra, text ='Bouton'+str(i), command =self.affich).grid(row =i,column =0)
            choix = StringVar()
            OptionMenu(fra, choix, *['ab','cd','ef']).grid(row =i,column =1)
        self.root.mainloop()
 
    def affich(self):
        Label(self.root, text ='ici le texte du bouton cliquer et celui de l OptionMenu correnspondant').grid(row =1, column =1)
 
from Tkinter import *
f=Appli()

Existe-il un moyen de différencier les actions déclencheur d'une fonction? De détecter si c'est le bouton 1 ou 2 qui l'appelle?

[wiztricks]

Salut,

Pour les buttons, je vous suggère de lire explications et exemples de la FAQ.

- W

[Shozma]

Merci wiztricks,

Voici donc ma solution fonctionnelle, avec l'utilisation de fermetures:

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
class Appli:
    def __init__(self):
        self.root = Tk()
        Label(self.root, text ='Choix:').grid(row =0, column =1, padx =20)
        self.frame1 = Frame(self.root, borderwidth=4, relief=GROOVE)
        self.frame1.grid(row =1, column =0)
        self.nom_bouton, self.choix = [], []
        for i in range(4):
            self.nom_bouton.append('Bouton'+str(i))
            Button(self.frame1, text =self.nom_bouton[i], command =self.affich(i))\
            .grid(row =i,column =0)
            self.choix.append(StringVar())
            OptionMenu(self.frame1, self.choix[i], *['ab','cd','ef'])\
            .grid(row =i,column =1)
        self.root.mainloop()
 
    def affich(self, i):
        def manipulation():
            Label(self.root, text ='Nom du bouton cliquer : '+self.nom_bouton[i]\
            +'\nOption correpondante : ' +self.choix[i].get()).grid(row =1, column =1)
        return manipulation
 
from Tkinter import *
f=Appli()

Bien cordialement.

[Shozma]

Bonjour,

Je ré-ouvre ce post car je souhaite maintenant appeler la fonction disposant d'un fermeture simplement en ligne.
J'ai créé un autre bouton lié à la fonction self.declenche, qui devrait, selon moi, simplement appeler la fonction self.affich comme le font les autres boutons.

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
class Appli:
    def __init__(self):
        self.root = Tk()
        Label(self.root, text ='Choix:').grid(row =0, column =1, padx =20)
        self.frame1 = Frame(self.root, borderwidth=4, relief=GROOVE)
        self.frame1.grid(row =1, column =0)
        self.nom_bouton, self.choix = [], []
        for i in range(4):
            self.nom_bouton.append('Bouton'+str(i))
            Button(self.frame1, text =self.nom_bouton[i], command =self.affich(i))\
            .grid(row =i,column =0)
            self.choix.append(StringVar())
            OptionMenu(self.frame1, self.choix[i], *['ab','cd','ef'])\
            .grid(row =i,column =1)
        Button(self.root, text ='Declenche', command =self.declenche)\
        .grid(row =2, column =0)
        self.root.mainloop()
 
    def affich(self, i):
        def manipulation():
            Label(self.root, text ='Nom du bouton cliquer : '+self.nom_bouton[i]\
            +'\nOption correpondante : ' +self.choix[i].get()).grid(row =1, column =1)
        return manipulation
 
    def declenche(self):
        for i in range(4):
            self.affich(i)
 
from Tkinter import *
f=Appli()

Mais voilà, ça ne fonctionne pas.
Comment déclencher cette fonction avec fermeture simplement avec une ligne de code? Est-ce possible ou faut-il obligatoirement la lier à un bouton?

Edit: Je me demande si il est possible pour moi de changer le titre de la discussion, pour un plus clair.

[wiztricks]

J'ai créé un autre bouton lié à la fonction self.declenche, qui devrait, selon moi, simplement appeler la fonction self.affich comme le font les autres boutons.

command=self.declenche() exécute la fonction et son retour serait à appeler lorsqu'on clique sur le bouton. Malheureusement, cette fonction ne retourne pas (comme affich) une fonction... De plus "comma" au lieu de "command" devrait raler.
Essayez de relire votre code et de comprendre s'il a des chances de faire ce que vous attendez.

- W

[Shozma]

Deux erreurs de relecture effectivement. J'ai édité mon message précédent.

Mais ça ne fonctionne toujours pas, j'essaye de comprendre la raison... en vain.
Je ne comprend pas pourquoi la fonction affich(self, i) appelé simplement avec:

Code :

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

1
2
for i in range(4):
    self.affich(i)

ne s’exécute pas comme lorsqu'elle est appelée par un bouton.

[wiztricks]

Mais ça ne fonctionne toujours pas, j'essaye de comprendre la raison... en vain.
Je ne comprend pas pourquoi la fonction affich(self, i) appelé simplement avec:

Code :

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

1
2
for i in range(4):
    self.affich(i)

ne s’exécute pas comme lorsqu'elle est appelée par un bouton.

Parce que vous ne comprenez toujours pas le code que vous avez écrit.
Réfléchissez encore: self.affich(i) retourne une fonction.
C'est cette fonction là qui est appelée lors du clic... mais elle n'est pas appelée dans "declenche"... donc elle ne s'exécute pas.

- W

[Shozma]

J'essaye de comprendre, j'expérimente.

Code :

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

1
2
3
4
5
6
def fonction1():
    return fonction2()
def fonction2():
    return fonction3()
def fonction3():
    return 'voila'

>>> fonction1() me renvoi 'voila'
Donc il faudrait que "declenche" appelle "affich" qui appellerait "manipulation".

Code :

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

1
2
    def declenche(self):
        return self.affich(0)

par exemple si on veut l'action du premier bouton (moi, avec "declenche", je voudrai appuyer sur tous les boutons en même temps).
Vous savez sûrement déjà que ça ne fonctionne pas...

Alors peut-être qu'il faut appeler "manipulation" directement !
Mais vu qu'elle n'est déclaré que dans "affich", je la sors, tel quel:

Code :

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

1
2
3
4
5
6
7
8
9
    def affich(self, i):
        return self.manipulation(i)
 
    def manipulation(self, i):
        Label(self.root, text ='Nom du bouton cliquer : '+self.nom_bouton[i])\
        .grid(row =1, column =1)
 
    def declenche(self):
        return self.affich(0)

Le bouton Declenche fonctionne, mais c'est les autres qui ne fonctionnent plus.

Vous avez raison je ne comprend pas mon code... help

[wiztricks]

Salut,

Il faudrait savoir si vous voulez une fermeture ou pas et réfléchir à la différence entre retourner une fonction qui sera appelée plus tard avec appeler la fonction directement. Essayez voir:
Une fonction bête:

Code :

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

1
2
3
4
>>> def g():
...    return "je suis G"
...
>>>

Quand on l'appelle:

Code :

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

1
2
3
>>> g()
'je suis G'
>>>

Une fonction qui retourne une fonction:

Code :

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

1
2
3
4
>>> def f():
...    return g
...
>>>

Si on l'appelle çà retourne "g" sans l'appeler:

Code :

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

1
2
>>> f()
>>>

Maintenant, si on appelle la fonction qui a été retournée:

Code :

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

1
2
3
>>> _()
'je suis G'
>>>

Et dans tout ce bazar, la différence n'est que placement ou omission de "()" qui fera qu'on appelle ou pas et qui promeut la simple fonction en fermeture/closure.

Essayez de faire travailler vos neurones encore un peu...

- W

[Shozma]

Je veux la fermeture effectivement donc la fonction manipulation doit être encapsulée.

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
class Appli:
    def __init__(self):
        self.root = Tk()
        Label(self.root, text ='Choix:').grid(row =0, column =1, padx =20)
        self.frame1 = Frame(self.root, borderwidth=4, relief=GROOVE)
        self.frame1.grid(row =1, column =0)
        self.nom_bouton = []
        for i in range(4):
            self.nom_bouton.append('Bouton'+str(i))
            Button(self.frame1, text =self.nom_bouton[i], command =self.affich(i))\
            .grid(row =i,column =0)
        self.root.mainloop()
 
    def affich(self, i):
        def manipulation():
            Label(self.root, text ='Nom du bouton cliquer : '+self.nom_bouton[i]\
            +'\nOption correpondante : ' +self.choix[i].get()).grid(row =1, column =1)
        return manipulation

Et cela veut donc dire qu'il n'y a aucun moyen d'appuyer sur les quatre boutons "en même temps", comme je souhaite le faire avec la fonction declenche?

[wiztricks]

Et cela veut donc dire qu'il n'y a aucun moyen d'appuyer sur les quatre boutons "en même temps", comme je souhaite le faire avec la fonction declenche?

Il faut juste ne pas oublier de mettre les parenthèses:

Code :

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

1
2
     for i in range(4):
          self.affich(i)()

- W

[Shozma]

Merci

[wiztricks]

Salut,

Juste pour le fun: utilisation de lambda et de Button.invoke

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
import Tkinter as tk
 
def manipulation(nom, choix, label):
    label['text'] = 'bouton: %s, option: %s' % (nom, choix)
 
def declenche(btns):
    for b in btns:
        b.invoke()
 
 
root = tk.Tk()
 
tk.Label(root, text ='Choix:').grid(row =0, column =2, padx =20)
 
buttons = []
for i in range(1, 5):
    nom = 'B-'+str(i)
    choix = tk.StringVar(root)
    label = tk.Label(root, width=20)
 
    btn = tk.Button(root, text=nom,
           command=lambda nom=nom, choix=choix, label=label: manipulation(nom, choix.get(), label)
           )
    btn.grid(row =i,column =0)
    buttons.append(btn)
 
    tk.OptionMenu(root,
               choix, 'ab','cd','ef').grid(row =i,column =1)
 
    label.grid(row=i, column=2)
 
w = tk.Button(root, text ='Declenche', command =lambda: declenche(buttons))
w.grid(row=5, column=1, columnspan=3)
 
tk.mainloop()

Vous noterez que j'ai viré votre classe.
Si on veut s'amuser avec les classes, on part du principe qu'une classe va permet d'abord de fabriquer plusieurs objets aux propriétés semblables. Ici, l'objet qui se répète est la row composée des 3 widgets Button, OptionMenu et Label. Ce qui va permettre de fabriquer une commande qui soit méthode associée à chaque objet et donc ne plus avoir à passer par la fermeture.

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
import Tkinter as tk
 
class MyRow(tk.Button):
    def __init__(self, master, row):
        self.nom = 'B-'+str(i)
        tk.Button.__init__(self, root, text=self.nom,
           command=self.affiche)
 
        self.grid(row=row, column=0)
        self.choix = tk.StringVar(root)
 
        tk.OptionMenu(root, self.choix, 'ab','cd','ef'
               ).grid(row=row, column=1)
 
        self.label = tk.Label(root, width=20)
        self.label.grid(row=row, column=2)
 
    def affiche(self):
        self.label['text'] = 'bouton: %s, option: %s' % (self.nom, self.choix.get())
 
 
root = tk.Tk()
 
tk.Label(root, text ='Choix:').grid(row =0, column =2, padx =20)
label =  tk.Label(root, text ='')
buttons = []
for i in range(1, 5):
    btn = MyRow(root, i)
    buttons.append(btn)
 
def declenche():
    for b in buttons:
        b.invoke()
 
 
w = tk.Button(root, text ='Declenche', command = declenche)
w.grid(row=5, column=1, columnspan=3)
 
tk.mainloop()

- W