Position des boutons

Version imprimable

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:

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.

16/02/2019, 20h52
wiztricks

Salut,

Le petit scarabée toujours pressé

Citation:

Envoyé par Aiacciu

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

Citation:

Envoyé par Aiacciu

- 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

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:

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()

17/02/2019, 19h21
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.
21/02/2019, 10h59
Aiacciu

Bonjour Wiztricks.

Citation:

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".

Citation:

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.

Citation:

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,

Citation:

Le petit scarabée toujours pressé

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

Cordialement.
21/02/2019, 11h00
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:

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:

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.

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:

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.

21/02/2019, 12h38
wiztricks

Salut,

Citation:

Envoyé par Aiacciu

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

C'est juste une liste de listes dont les éléments sont eux mêmes des listes (au lieu de simples chaînes de caractères). Le gros soucis que vous allez avoir sera de remplir votre tableau sans vous tromper: avec toutes ces données, il deviendra difficile à (re)lire.

Peut être faut il penser "association" i.e. garder le tableau à 2 dimensions pour placer les éléments dans la "grille" puis renseigner un dictionnaire où la clef serait le nom de l’élément et la valeur la fonction à appeler et son paramètre.

- W
21/02/2019, 13h43
Aiacciu
Alors deux tableaux...
Le premier tableau "tableau" avec les symboles.

Code:

E = Button(frame_elements, text=tableau[i][j],command=lambda e=tableau[i][j]: bidule(fenêtre,e), width=2)

la fonction "bidule" définirait la fonction à utiliser selon i et j.
Code:

1 2 3 4 5 6 def bidule(test,e): for i in range(7): for j in range(18): if e==text(tableau[i][j]): k=j element[k](test)
Le deuxième tableau "raies" avec les listes de raies (raies[i][j]) à utiliser appelées dans la fonction.

La quantification énergétique de la matière m'impose cette lourdeur... je réfléchis, je teste avec un petit tableau 2x2.

Merci.
21/02/2019, 14h51
wiztricks

Citation:

Envoyé par Aiacciu

La quantification énergétique de la matière m'impose cette lourdeur...

Vous aviez i, j au départ, plutôt que de les retrouver en balayant le tableau, autant les passer en paramètre à la construction de votre lambda.
Mais ils ne servent à rien puisque vous voulez récupérer des informations associée à la chaine de caractères (le nom de l'élément)... si vous n'avez jamais vu les dictionnaires, lisez les chapitres qui en parlent dans un tuto.: ils sont faits pour çà.

- W

Bonjour.

Voilà :
Code:

1 2 3 4 5 6 7 for i in range(7): for j in range(18): if tableau[i][j] is not None: E = Button(frame_elements, text=tableau[i][j],command=lambda ELEMENT=raies[i][j]:spectre(test,ELEMENT), width=2) E.grid(row=i, column=j) else: continue
Ma variable e (chaîne de caractères de l'élément) a été transformée en ELEMENT pour les listes de raies rangées dans un tableau.
La fonction "spectre" trace le spectre en fonction de cette variable.
Plutôt que de l'appeler par le nom de l'élément, je l'appelle par son spectre de raies. Les deux étant rangés dans des tableaux de mêmes dimensions, la manip était évidente... mais l'évidence m'éblouissait.
Tout n'était que question de... lumière.

Encore merci à vous.

22/02/2019, 13h20
fred1599
Les lignes 6 et 7 sont inutiles

Lorsqu'une lambda semble être illisible comme le cas que vous présentez, on préfère l'éviter.

Pour l'éviter, on crée le callback (doit retourner une fonction) sur une structure comme ci-dessous,
Code:

1 2 3 4 5 def add_button(*args): def callback(): # vos boutons return callback
Le principe est de retourner un objet function sans faire son appel, ce que fait add_button avec "return callback".
Les lambda sont très peu utilisées et à juste titre, c'est qu'on essaye toujours d'avoir le code le plus lisible possible. Celles-ci rendant les lignes de code souvent cryptique.

Bonne continuation...
22/02/2019, 16h01
Aiacciu

Merci beaucoup de toutes ces informations.

Beaucoup de travail m'attend encore avant de pouvoir gérer la programmation.
Je tenterai d'appliquer votre méthode et je me pencherai sur les dictionnaires.

Cordialement.