[python3+tkinter]demande d'aide sur un programme.

Version imprimable

bonjour à tous et à toutes.
voila je cherche à faire un programme me permettant de "switcher" d'un élément vers un autre et vice versa.
voila mon code:

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
from tkinter import *
 
##fonctions
def drwcircle1(event):
    ""
    can.create_oval(event.x-10,event.y-10,event.x+10,event.y+10,outline="dark red",width=2)
 
def drwcircle2(event):
    ""
    can.create_oval(event.x-20,event.y-20,event.x+20,event.y+20,outline="green",width=2)
 
def swtccirc():
    global a
    if a == drwcircle1:
        a = drwcircle2
    elif a == drwcircle2:
        a = drwcircle1
 
 
#program
a = drwcircle2
 
#interface
fen = Tk()
can = Canvas(fen,width=200, height=200, bg="white")
can.bind("<Button-1>",a)
can.pack()
Button(fen,text="change circle",command=swtccirc).pack()
 
fen.mainloop()

bien entendu celui ci ne fonctionne pas (ca serait tellement plus simple). alors j'ai tenté de faire un autre code (à peu près sur le même principe)
le voici:

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
from tkinter import *
 
#fonctions
def drwcircle():
    #canv.create_oval(50,50,150,150,outline="red")
    canv.create_oval(50,50,150,150,outline=coul)
 
def chngcoul():
    global coul
    if coul == "red":
        coul = "green"
    elif coul == "green":
        coul = "red"
 
#programme
coul="red"
 
#grahpique
fen = Tk()
canv = Canvas(fen,width=200,height=200,bg="white")
canv.pack()
Button(fen,text="change color",command=chngcoul).pack(side=BOTTOM)
Button(fen,text="drwcircle",command=drwcircle).pack()
 
fen.mainloop()

donc dans celui-ci la couleur change bien. dans le 1er je désire que le cercle change.

merci pour vos explications et votre aide.

cdt

Bonjour,

Pour ce qui est du premier code le Button fait que la variable 'a' contient une des deux fonctions.
A partir de là il est nécessaire pour qu'il 'se passe quelque chose' à un moment donné d’exécuter la fonction.
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 from tkinter import * ##fonctions def drwcircle1(event): "" can.create_oval(event.x-10,event.y-10,event.x+10,event.y+10,outline="dark red",width=2) def drwcircle2(event): "" can.create_oval(event.x-20,event.y-20,event.x+20,event.y+20,outline="green",width=2) def swtccirc(): global a if a == drwcircle1: a = drwcircle2 elif a == drwcircle2: a = drwcircle1 #program a = drwcircle2 #interface fen = Tk() can = Canvas(fen,width=200, height=200, bg="white") # can.bind("<Button-1>",a) Voir plus bas can.pack() Button(fen,text="change circle",command=swtccirc).pack() can.bind("<1>", lambda event: a(event)) fen.mainloop()
Vous remarquerez le lambda event: a(event) permettant de récupérer l'objet event envoyé par le binding. Donc a voir : bind et lambda.

Si j'ai bien compris.

@+

10/02/2013, 18h16
ivigu

bonjour
effectivement la modification effectue bien ce que je veux.
je vais étudier ta solution merci.

Bonne lecture dans ce cas.

Notez que drwcircle1 et drwcircle2 sont les mêmes fonctions dont seulement deux valeurs changes (10/20, couleur).

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
from tkinter import *
 
 
SIZE = 10
COLOR = 'green'
 
 
def drwcircle(event):
    ""
    can.create_oval(event.x-SIZE,
                    event.y-SIZE,
                    event.x+SIZE,
                    event.y+SIZE,
                    outline=COLOR,
                    width=2)
 
 
def swtccirc():
    global COLOR, SIZE
    if COLOR == 'green':
        COLOR = 'dark red'
        SIZE = 20
    else:
        COLOR = 'green'
        SIZE = 10
 
 
fen = Tk()
can = Canvas(fen,width=200, height=200, bg="white")
can.pack()
Button(fen, text="change circle", command=swtccirc).pack()
can.bind("<1>", drwcircle)
fen.mainloop()

"yapuqua" ;)

@+

Juste au passage :

Pourquoi dans votre premier code cela ne fonctionne pas ?

Si nous prenons
Code:

1 2 3 a = drwcircle2 ... can.bind("<Button-1>", a)
Lors de la lecture du code le binding est effectué sur a, soit dans le code drwcircle2, et c'est cette fonction qui est stockée comme callback.

Si par contre vous écrivez

Code:

can.bind("<Button-1>", lambda event: a(event))

La fonction stockée est la fonction lambda et lors de son exécution elle appelle la fonction 'a', qui correspond à drwcircle2 ou 1 au moment 't'.

Sans les fonctions lambda cela donne:
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 from tkinter import * ##fonctions def drwcircle1(event): "" can.create_oval(event.x-10,event.y-10,event.x+10,event.y+10,outline="dark red",width=2) def drwcircle2(event): "" can.create_oval(event.x-20,event.y-20,event.x+20,event.y+20,outline="green",width=2) def swtccirc(): global a if a == drwcircle1: a = drwcircle2 elif a == drwcircle2: a = drwcircle1 def lmbd(event): a(event) #program a = drwcircle2 #interface fen = Tk() can = Canvas(fen,width=200, height=200, bg="white") can.bind("<Button-1>", lmbd) can.pack() Button(fen,text="change circle",command=swtccirc).pack() fen.mainloop()

11/02/2013, 23h15
ivigu

ah merci beaucoup je me demandais aussi comment le faire sans passer par la fonction lambda.
merci
12/02/2013, 07h16
PauseKawa
Citation:

Envoyé par PauseKawa

Lors de la lecture du code le binding est effectué sur a

Une petite explication sur ceci qui pourrais être mal interprété.

Un petit rappel rapide:
Python ne gère pas le Windows Manager en natif, pour cela il utilise des GUI.
Tkinter est un (le) wrapper Python de Tcl/Tk. C'est une bibliothèque Python donnant accès a l'interpréteur Tcl et principalement à son toolkit graphique : Tk.
Nous avons donc
Python <-> Tkinter <-> Tcl/Tk
Tkinter permettant de créer l'interface Tk et l'interpréteur Tcl gérant le WM via Tk (événements etc...).
Pour ce qui est des 'événements' Tkinter dispose d'une palette de fonctions (bind, protocol, command...) permettant de remonter l'information ('réagir' via des fonctions) à l'interpréteur Python.

Le binding permet d'enregistrer une action (fonction) pour un événement du WM. Je passerais sur les détails des _register et autre mais cela demande à l'interpréteur Tcl d’effectuer une action lorsque le toolkit Tk remonte en événement donné (clic etc...) pour un élément donné.
A notre niveau cela se traduit par l’exécution d'une fonction lors d'un événement pour un objet graphique donné.

Au niveau du code nous avons donc:

Code:

can.bind("<Button-1>", a)

Qui se traduit par
Pour un clic ("<Button-1>") sur le Canvas can exécuter 'a'.
Mais comme a = drwcircle2 la fonction enregistrée au moment du binding pour l'action "<Button-1>" est drwcircle2.
Puisque la fonction n'est pas 'enregistrée au niveau' de Python qu'importe si par la suite 'a' est autre chose pour Python.
Lorsque nous avons can.bind("<Button-1>", lmbd) c'est la fonction lmbd qui est prise en compte et comme celle ci a pour code
Code:

1 2 def lmbd(event): a(event)
Elle exécuteras la fonction ayant pour nom 'a' telle qu'elle est à l'instant 't' pour Python.
Lambda n'est là que pour éviter de créer une fonction lmbd n'ayant pour but que de faire un a(event).

Voili : Grossier et a revoir sans doute mais cela dégrossi le sujet.
12/02/2013, 12h46
ivigu

bonjour
merci pour ce complément. j'ai compris mon erreur à la lumière de ces informations. merci pour ces explications!

A noter que l'explication est valable pour le trace_variable de la classe Variable, selection_handle, wm_protocol, le dump du Widget Text ou encore le validatecommand du Widget Entry : De quoi avoir un beau bug ;)
after n'est pas concerné car le _register est fait sur la fonction interne callit.

(Edit : Avec un exemple)
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 import Tkinter as tk def foo1(): print('in foo1') return True def foo2(): print('in foo2') return True def toprint(): a() def change(): print('change for foo2') global a a = foo2 app = tk.Tk() a = foo1 tk.Entry(app, validate='key', validatecommand=a).pack() tk.Button(app, text='change for foo2', command=change).pack() tk.Button(app, text='give me a', command=toprint).pack() tk.Button(app, text='call a', command=a).pack() app.mainloop()
@+