Discussion :

[Aiacciu]

Bonsoir.

Troisième semaine dans Python...

Dans une fenêtre tkinter, j'ai positionné différents boutons de manière récursive.
A chacun de ces boutons, je souhaiterais faire apparaître différents choses dans la fenêtre.
Tout ceci se passe très bien pour les deux premiers (1ère ligne).
A partir de la deuxième ligne de boutons, me voici bien ennuyé... effectivement, la commande appelée est la même quelque soit le bouton... normal, ils s'appellent tous "E".
Alors, je me suis dit que je pourrais créer une fonction intermédiaire appelée par cette commande. Cette fonction appelleraient les coordonnées du bouton dans la fenêtre.
Selon ces coordonnées, je pourrais effectuer ce que je souhaite.

Mon souci est que les coordonnées affichées sont bien les bonnes (celles du bouton dans la fenêtre), mais dès que je passe au-dessus d'un bouton, elles deviennent celles du pointeur dans le bouton, et non plus dans la fenêtre.
Alors, je me suis dis : "récupère les positions définies dans la fenêtre"... mais quelque soit le bouton, je me retrouve avec la même position.

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
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
from tkinter import *
from math import*
 
 
elements=['H','He','Li','Be','B','C','N','O','F','Ne','Na','Mg','Al','Si','P','S','Cl','Ar','K','Ca','Sc','Ti','V','Cr','Mn','Fe','Co','Ni','Cu','Zn','Ga','Ge','As','Se','Br','Kr','Rb','Sr','Y','Zr','Nb','Mo','Tc','Ru','Rh','Pd','Ag','Cd','In','Sn','Sb','Te','I','Xe','Cs','Ba','La','Hf','Ta','W','Re','Os','Ir','Pt','Au','Hg','Tl','Pb','Bi','Po','At','Rn','Fr','Ra','Ac','Rf','Db','Sg','Bh','Hs','Mt','Ds','Rg','Cn','Nh']
 
def curseur(event):
    x,y=event.x,event.y
    position.configure(text = "position en X =" + str(event.x) +", Y =" + str(event.y))
 
test=Tk()
test.geometry('1000x800')
 
test.bind("<Motion>", curseur)
position=Label(test)
position.pack()
 
for i in range(len(elements)):
    if i in range(1):                                  #H
        posx=213+i*30+2
        posy=(500)
        E=Button(test,text=elements[i],font='ArialBlack 12 bold',command=lambda:print(str(posx)+','+str(posy)),width=2)
        E.place(x = posx,y = posy)
    if i in range(1,2):                               #He
        posx=725
        posy=(500)
        E=Button(test,text=elements[i],font='ArialBlack 12 bold',command=lambda:print(str(posx)+','+str(posy)),width=2)
        E.place(x = posx,y = posy)
    if i in range(2,4):                             #Li, Be
        posx=213+(i-2)*30+2
        posy=(500+35)
        E=Button(test,text=elements[i],font='ArialBlack 12 bold',command=lambda:print(str(posx)+','+str(posy)),width=2)
        E.place(x = posx,y = posy)
    if i in range(4,10):                            #B à Ne
        posx=213+(i-2)*30+2+300
        posy=(500+35)
        E=Button(test,text=elements[i],font='ArialBlack 12 bold',width=2)
        E.place(x = posx,y = posy)
    if i in range(10,12):                             #Na, Mg
        posx=213+(i-10)*30+2
        posy=(500+70)
        E=Button(test,text=elements[i],font='ArialBlack 12 bold',width=2)
        E.place(x = posx,y = posy)
    if i in range(12,18):                             #Al, Ar
        posx=213+(i-12)*30+2+360
        posy=(500+70)
        E=Button(test,text=elements[i],font='ArialBlack 12 bold',width=2)
        E.place(x = posx,y = posy)
    if i in range(18,36):                             #K à Kr
        posx=213+(i-18)*30+2
        posy=(500+105)
        E=Button(test,text=elements[i],font='ArialBlack 12 bold',width=2)
        E.place(x = posx,y = posy)
    if i in range(36,54):                             #Rb à Xe
        posx=213+(i-36)*30+2
        posy=(500+140)
        E=Button(test,text=elements[i],font='ArialBlack 12 bold',width=2)
        E.place(x = posx,y = posy)
    if i in range(54,72):                   #Cs à Rn
        posx=213+(i-54)*30+2
        posy=(500+175)
        E=Button(test,text=elements[i],font='ArialBlack 12 bold',width=2)
        E.place(x = posx,y = posy)
    if i in range(72,len(elements)):                   #Cs à Rn
        posx=213+(i-72)*30+2
        posy=(500+210)
        E=Button(test,text=elements[i],font='ArialBlack 12 bold',width=2)
        E.place(x = posx,y = posy)
 
test.mainloop()

Mes questions :
- Est-ce la méthode "grid" que dois appliquer ?
- Pourquoi ces coordonnées définies dans mes lignes sont-elles bien celles des boutons dans la fenêtre, mais pas celles retournées ?
- suis-je obligé d'oublier cette création récursive et créer tous ces boutons de manière indépendante ?

Pourriez-vous m'orienter vers la bonne documentation... ou la bonne commande ?

D'avance merci.

[wiztricks]

Salut,

Le petit scarabée toujours pressé

- Est-ce la méthode "grid" que dois appliquer ?
- Pourquoi ces coordonnées définies dans mes lignes sont-elles bien celles des boutons dans la fenêtre, mais pas celles retournées ?

Quelque soit la méthode, çà serait bien de savoir sur quel Button l'utilisateur a cliqué.

event.x, event.y ne fontionnent pas directement puisqu'il retourne la position "dans" le widget: si vous aviez lu la documentation, vous n'auriez même pas perdu votre temps à essayer!

grid saurait le faire puisqu'il a la méthode grid_location mais elle n'est pas si simple à faire fonctionner.
Une autre piste serait de virer les Button pour utiliser des item "text" d'un Canvas (que vous connaissez) ou bien de placer vos Button en tant qu'items du Canvas via .create_window.

- suis-je obligé d'oublier cette création récursive et créer tous ces boutons de manière indépendante ?

Il n'y a pas de récursivité dans votre code.
Par contre, vous partez d'un tableau (le tableau périodique des éléments) que vous ratatinez en liste et votre code ne contient rien pour faire correspondre l'élément (i, j) au rectangle dans lequel l'utilisateur clique et réciproquement.

- W

[bistouille]

Salut.

Idem que wiztricks pour le canevas.

Ou sinon, en remplissant ton tableau avec des lignes de mêmes longueurs serait envisageable et surtout utiliser grid.

Exemple fait à l'arrache en complétant les espaces "vides" par des suites de None et ainsi gérer facilement les rows et columns.

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
import tkinter as tk
 
tableau = (
    ('H',) + (None,) * 16 + ('He',),
    ('Li', 'Be',) + (None,) * 10 + ('B','C','N','O','F','Ne',),
    ('Na', 'Mg',) + (None,) * 10 + ('Al', 'Si', 'P', 'S', 'Cl', 'Ar',),
    ('K', 'Ca', 'Sc', 'Ti', 'V', 'Cr', 'Mn', 'Fe', 'Co', 'Ni', 'Cu', 'Zn', 'Ga', 'Ge', 'As', 'Se', 'Br', 'Kr',),
    ('Rb', 'Sr', 'Y', 'Zr', 'Nb', 'Mo', 'Tc', 'Ru', 'Rh', 'Pd', 'Ag', 'Cd', 'In', 'Sn', 'Sb', 'Te', 'I', 'Xe',),
    ('Cs','Ba','La','Hf','Ta','W','Re','Os','Ir','Pt','Au','Hg','Tl','Pb','Bi','Po','At','Rn',),
    ('Fr','Ra','Ac','Rf','Db','Sg','Bh','Hs','Mt','Ds','Rg','Cn','Nh',) + (None,) * 5,
)
 
root = tk.Tk()
 
frame_elements = tk.Frame(root)
frame_elements.grid()
 
for row, ligne in enumerate(tableau) :
    for column, elt in enumerate(ligne) :
        if elt is None :
            continue
        bt = tk.Button(frame_elements, text=elt, width=2, command=lambda e=elt: print(e))
        bt.grid(row=row, column=column)
 
root.mainloop()

[Aiacciu]

Bonsoir.

Veuillez me pardonner cette absence de réponse pour aujourd'hui... j'ai mis en pause mon apprentissage pour ce dimanche.
Je m'y remets dès demain matin.
Merci pour vos réponses qui m'aideront sans aucun doute.

A dumane.

[Aiacciu]

Bonjour Wiztricks.

event.x, event.y ne fontionnent pas directement puisqu'il retourne la position "dans" le widget: si vous aviez lu la documentation, vous n'auriez même pas perdu votre temps à essayer!

grid saurait le faire puisqu'il a la méthode grid_location mais elle n'est pas si simple à faire fonctionner.
Une autre piste serait de virer les Button pour utiliser des item "text" d'un Canvas (que vous connaissez) ou bien de placer vos Button en tant qu'items du Canvas via .create_window.

Effectivement, le event.x event.y ne sert à rien, mais son insertion m'a bien permis de le comprendre... ça n'a pas pris trop de temps, je n'ai pas "perdu" de temps, j'ai appris...
Le grid fonctionne très bien, et il est très facile à utiliser sans pour autant appeler le grid_location.
Les boutons sont restés sans avoir recours à ce ".create_window".

Il n'y a pas de récursivité dans votre code.

Effectivement le terme récursive n'était pas approprié, le terme "récurrente" aurait été plus adéquat. Cette récurrence, a été conservée.

Par contre, vous partez d'un tableau (le tableau périodique des éléments) que vous ratatinez en liste et votre code ne contient rien pour faire correspondre l'élément (i, j) au rectangle dans lequel l'utilisateur clique et réciproquement.

Le "ratatinage", ou "ratatinement"... peut-être "ratatination" a été conservé(e) dans une partie du programme. En regardant une "simple" liste,

Le petit scarabée toujours pressé

n'y voit pas qu'une seule dimension...

Cordialement.

[Aiacciu]

Salut, Bistouille.
Un grand merci à toi. Ton orientation a été très constructive. Mon problème a ensuite été de parvenir à appeler la bonne fonction dans la ligne de création du bouton E. Elle s'est transformée ainsi :

Code :

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

E = Button(frame_elements, text=tableau[i][j],command=lambda e=tableau[i][j]:dessinspectre(test,e), width=2)

où la fonction "dessinspectre" a été définie ainsi :

Code :

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

1
2
3
4
5
6
def dessinspectre(test,e):
    for j in range(len(elements)):
        if e==str(elements[j]):
            break
    k=j
    dessinelement[k](test)

Et de "dessinelement", une liste de fonctions... qui se transformera sûrement en un tableau de fonctions.
Le petit débutant que je suis n'osait pas créer de tableau... et puis il s'est jeté avec un "tableau de listes"...
Encore MERCI.

[Aiacciu]

Re-bonjour.
S'il vous plaît, serait-il envisageable de créer un tableau dans lequel chaque élément (case) de ce tableau contiendrait à la fois, le nom de la case, la fonction à appeler et une liste utilisée dans la fonction... genre :

Code :

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

1
2
3
4
5
6
7
8
tableau = (
    ('H',H,[409.5,433.8,485.8,655.7],)+(None,) * 16  + ('He',),
    ('Li', 'Be',) + (None,) * 10 + ('B','C','N','O','F','Ne',),
    ('Na', 'Mg',) + (None,) * 10 + ('Al', 'Si', 'P', 'S', 'Cl', 'Ar',),
    ('K', 'Ca', 'Sc', 'Ti', 'V', 'Cr', 'Mn', 'Fe', 'Co', 'Ni', 'Cu', 'Zn', 'Ga', 'Ge', 'As', 'Se', 'Br', 'Kr',),
    ('Rb', 'Sr', 'Y', 'Zr', 'Nb', 'Mo', 'Tc', 'Ru', 'Rh', 'Pd', 'Ag', 'Cd', 'In', 'Sn', 'Sb', 'Te', 'I', 'Xe',),
    ('Cs','Ba','La','Hf','Ta','W','Re','Os','Ir','Pt','Au','Hg','Tl','Pb','Bi','Po','At','Rn',),
    ('Fr','Ra','Ac','Rf','Db','Sg','Bh','Hs','Mt','Ds','Rg','Cn','Nh',) + (None,) * 5,)

(j'ai rempli pour le premier élément seulement)

De sorte que dans le bouton il s'affiche le texte H, j'appelle la fonction H qui fait appel aux éléments de la liste.
J'essaye.

Merci.