Discussion :

[amster313]

bonjour !
je travaille actuellement sur la programmation d'un sudoku, j'ai deja ma grille et mes nombres aleatoire qui s'affiche dans la grille (fonction:grille()/shuffle(x)/coordonnee()).
maintenant, j'essaye de definir une nouvelle fonction qui me permet de remplacer mes carréx par une case cliquable. j'ai essaye plusieurs technique mais je ne trouve aucune solution. je suis presque sûr que le widget entry me premettrais d'avoir cette case cliquable dans mon tkinter mais je n'arrive pas a definir la bonne fonction.
de plus j'essaye de creer une fonction (cache()/cachage()) pour que mon programme prenne aleatoirement dans mes carré (ici je n'est mis que ce de la sous grille haut/gauche) et en remplace certain par cette case cliquable

je m'excuse par avance pour la longueur du programme mais je pense qu'il faut voir toutes ces fonctions pour mieux comprendre. j'espere que vous pourrez m'aider !
cordialement

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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
 
from tkinter import *
import random
 
nb=9
nb1=3
x0,y0=60,60
c=60
c1=180
 
def grille():                                                                   #creation du tableau
    page.delete(ALL)
    for k in range(nb1+1):                                                      #tableau en 3x3
        page.create_line(x0+c1*k, y0,x0+c1*k,y0 + nb1*c1, width=2)
        page.create_line(x0, y0+c1*k,x0+nb1*c1 ,y0+c1*k, width=2)
    for i in range(nb+1):                                                       #tableau en 9x9
        page.create_line(x0+c*i, y0,x0+c*i,y0 + nb*c)
        page.create_line(x0, y0+c*i,x0+nb*c ,y0+c*i)
    cachage()
    coordonnee()
 
def shuffle(x): #liste de nombre aleatoire de 1 a 9
        x = list(x)
        random.shuffle(x)
        return x
 
 
def coordonnee():
    A1  = B4 = C7 = D6 = E9 = F3 = G5 = H8 = I2 = y[0] #1er terme de ma suite aléatoire
    A2  = B5 = C8 = D1 = E4 = F7 = G6 = H9 = I3 = y[1]
    A3  = B6 = C9 = D2 = E5 = F8 = G1 = H4 = I7 = y[2]
    A7  = B1 = C4 = D3 = E6 = F9 = G2 = H5 = I8 = y[3]
    A8  = B2 = C5 = D7 = E1 = F4 = G3 = H6 = I9 = y[4]
    A9  = B3 = C6 = D8 = E2 = F5 = G7 = H1 = I4 = y[5]
    A4  = B7 = C1 = D9 = E3 = F6 = G8 = H2 = I5 = y[6]
    A5  = B8 = C2 = D4 = E7 = F1 = G9 = H3 = I6 = y[7]
    A6  = B9 = C3 = D5 = E8 = F2 = G4 = H7 = I1 = y[8]
 
    carre1 = page.create_text(90, 90, text=A1) #carre haut gauche
    carre2 = page.create_text(150, 90, text=A2)
    carre3 = page.create_text(210, 90, text=A3)
    carre4 = page.create_text(90, 150, text=B1)
    carre5 = page.create_text(150, 150, text=B2)
    carre6 = page.create_text(210, 150, text=B3)
    carre7 = page.create_text(90, 210, text=C1)
    carre8 = page.create_text(150, 210, text=C2)
    carre9 = page.create_text(210, 210, text=C3)
 
if __name__ == '__main__':
 
    x = range(1,10)
    y = shuffle(x)
 
    print(y) #y[] place des nombres dans ma suite aleatoire
 
    shuffle(x)
 
def cache(x):
    k= list(x)
    random.shuffle(k)
    return k
 
x= range(1,82)
v= cache(x)
print (v)
 
def cachage():
    cache (x)
    coordonnee()
    for f in range (1,20):
        coordonnee.delete()
        X=v[f]
        carreX=Entry(width=60, height=60)
 
 
fen=Tk()
 
barredemenus=Menu(fen)
fen.config(menu=barredemenus)
 
menuFichier=Menu(barredemenus)
 
menuresolution=Menu(barredemenus)
barredemenus.add_cascade(label="Niveau", menu=menuresolution)
menuresolution.add_command(label="Grille", command=grille)
 
 
page=Canvas(fen,width=650,height=650,bg="white")
page.pack(side=LEFT)
 
fen.mainloop()

[Invité]

Bonjour,

Voici un exemple générique utilisant le widget Entry :

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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
 
import random
from tkinter import *
 
# -------------- zone de définition des fonctions ----------------------
 
def main ():
    """
        procédure principale - point de départ du programme
    """
    global fenetre
 
    # création fenêtre principale
    fenetre = Tk()
 
    # titre fenêtre
    fenetre.title("Jeu de Sudoku")
 
    # fenêtre non redimensionnable
    fenetre.resizable(width=False, height=False)
 
    # initialisation du menu principal
    init_menus(fenetre)
 
    # initialisation des données du jeu
    init_jeu(fenetre)
 
    # gestionnaire événements de tkinter (boucle principale)
    fenetre.mainloop()
 
# end def
 
 
def init_menus (fenetre):
    "initialisation du menu principal de l'application"
 
    # menu principal de l'application
    topmenu = Menu(fenetre)
 
    # assignation du menu principal
    # à la fenêtre principale
    fenetre.configure(menu=topmenu)
 
    # init sous-menu Fichier
    menu_fichier = Menu(topmenu, tearoff=0)
    topmenu.add_cascade(label="Fichier", menu=menu_fichier)
    menu_fichier.add_command(label="Quitter", command=fenetre.destroy)
 
    # init sous-menu Niveau
    #~ menu_niveau = Menu(topmenu, tearoff=0)
    #~ topmenu.add_cascade(label="Niveau", menu=menu_niveau)
    #~ menu_niveau.add_command(label="Grille", command=None)
 
# end def
 
 
def init_jeu (fenetre):
    """
        initialisation données du jeu
    """
    global lignes, colonnes, matrice
 
    # init lignes, colonnes
    lignes = colonnes = 9
 
    # init matrice contenant la solution
    # selon la structure
    # {(ligne, colonne): valeur, ...}
    # avec ligne et colonne commençant à 0 et non pas à 1
    matrice = dict()
 
    # création de la grille de jeu
    init_grille(fenetre, lignes, colonnes)
 
# end def
 
 
def init_grille (fenetre, lignes, colonnes):
    """
        initialisation de la grille de Sudoku
    """
    global grille_jeu
 
    # init grille du jeu
    # structure ressemblant à matrice
    # {(ligne, colonne): Entry(), ...}
    # avec ligne et colonne commençant à 0 et non pas à 1
    grille_jeu = dict()
 
    # un jeu de Sudoku ne nécessite pas de canevas graphique
    _grille = Frame(fenetre)
 
    # on parcourt les lignes
    for ligne in range(lignes):
 
        # on parcourt les colonnes
        for colonne in range(colonnes):
 
            # création case jouable
            case = Entry(
                _grille,
                background="white",
                foreground="blue",
                font="sans 16 bold",
                highlightbackground="black",
                highlightcolor="red",
                highlightthickness=2,
                justify=CENTER,
                relief=FLAT,
                takefocus=True,
                width=2,
            )
 
            # placement de la case dans la grille physique
            case.grid(row=ligne, column=colonne)
 
            # remplissage bidon
            # pour vérifier affichage
            # à supprimer après mise au point
            case.insert(0, colonne+1)
 
            # on enregistre la case dans le dictionnaire
            # des widgets pour pouvoir y accéder ultérieurement
            # avec grille_jeu[(ligne, colonne)]
            # sachant que ligne et colonne commencent à 0 et non à 1
            grille_jeu[(ligne, colonne)] = case
 
        # end for - colonne
 
    # end for - ligne
 
    # placement grille dans la fenêtre principale
    _grille.pack(padx=10, pady=10)
 
# end def
 
# à vous de jouer pour la suite :
 
"""
def grille():                                                                   #creation du tableau
    page.delete(ALL)
    for k in range(nb1+1):                                                      #tableau en 3x3
        page.create_line(x0+c1*k, y0,x0+c1*k,y0 + nb1*c1, width=2)
        page.create_line(x0, y0+c1*k,x0+nb1*c1 ,y0+c1*k, width=2)
    for i in range(nb+1):                                                       #tableau en 9x9
        page.create_line(x0+c*i, y0,x0+c*i,y0 + nb*c)
        page.create_line(x0, y0+c*i,x0+nb*c ,y0+c*i)
    cachage()
    coordonnee()
"""
 
 
def shuffle(x): #liste de nombre aleatoire de 1 a 9
        x = list(x)
        random.shuffle(x)
        return x
 
 
def coordonnee():
    A1  = B4 = C7 = D6 = E9 = F3 = G5 = H8 = I2 = y[0] #1er terme de ma suite aléatoire
    A2  = B5 = C8 = D1 = E4 = F7 = G6 = H9 = I3 = y[1]
    A3  = B6 = C9 = D2 = E5 = F8 = G1 = H4 = I7 = y[2]
    A7  = B1 = C4 = D3 = E6 = F9 = G2 = H5 = I8 = y[3]
    A8  = B2 = C5 = D7 = E1 = F4 = G3 = H6 = I9 = y[4]
    A9  = B3 = C6 = D8 = E2 = F5 = G7 = H1 = I4 = y[5]
    A4  = B7 = C1 = D9 = E3 = F6 = G8 = H2 = I5 = y[6]
    A5  = B8 = C2 = D4 = E7 = F1 = G9 = H3 = I6 = y[7]
    A6  = B9 = C3 = D5 = E8 = F2 = G4 = H7 = I1 = y[8]
 
    carre1 = page.create_text(90, 90, text=A1) #carre haut gauche
    carre2 = page.create_text(150, 90, text=A2)
    carre3 = page.create_text(210, 90, text=A3)
    carre4 = page.create_text(90, 150, text=B1)
    carre5 = page.create_text(150, 150, text=B2)
    carre6 = page.create_text(210, 150, text=B3)
    carre7 = page.create_text(90, 210, text=C1)
    carre8 = page.create_text(150, 210, text=C2)
    carre9 = page.create_text(210, 210, text=C3)
 
 
def cache(x):
    k= list(x)
    random.shuffle(k)
    return k
 
 
def cachage():
    cache (x)
    coordonnee()
    for f in range (1,20):
        coordonnee.delete()
        X=v[f]
        carreX=Entry(width=60, height=60)
 
 
# se met toujours EN TOUT DERNIER dans un script
if __name__ == "__main__":
 
    # programme principal
    main()
 
# end if

Quelques conseils vite fait :

* regroupez vos tâches dans des fonctions ;
* évitez la multiplication des globales autant que possible ;
* ne mixez pas zone de définition de fonctions avec zone de script "global" ;
* coder est déjà suffisamment compliqué, n'ajoutez pas de la difficulté à la difficulté en utilisant des noms qui poussent à la devinette ;
* écrivez des noms de variables simples, explicites, factuels, qui disent ce qu'ils font et qui font ce qu'ils disent ;
* évitez les abréviations autant que possible : un code, ça se relit plus souvent que ça ne s'écrit ;
* essayez de toujours suivre des raisonnements simples (ou en apparence simples) ;
* inspirez-vous de l'adage : "quand c'est clair dans la tête, c'est clair dans le code" ;

Bon courage.

@+.

[VinsS]

salut,

Beaucoup de choses ne sont pas claires dans le code de départ mais celle-ci interpelle franchement:

Code :

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

1
2
3
4
5
6
 
def cachage():
    cache (x)
    coordonnee()
    for f in range (1,20):
        coordonnee.delete()

Sachant que coordonnee est une fonction du même code que peut bien être coordonnee.delete() ?

[Kurodiam]

@amster313 , ce qui est sure : tu n'as pas le niveau d'un débutant , comment tu te sert de l'importation du module random ?
En tout cas , çà se voit que tu n'es pas un débutant C'est pas déjà évident de saisir le principe d'un sudoku , en plus , toi , dans ton code , tu crées plusieurs carrés mais bon c'est le but : il faut bien déplacer les cases .... . Le y sert de liste , non ?

[wiztricks]

maintenant, j'essaye de definir une nouvelle fonction qui me permet de remplacer mes carréx par une case cliquable. j'ai essaye plusieurs technique mais je ne trouve aucune solution. je suis presque sûr que le widget entry me premettrais d'avoir cette case cliquable dans mon tkinter mais je n'arrive pas a definir la bonne fonction.

Un click pourra déclencher un événement à la position (x, y)
Si la grille est construite avec NxN carrés de côté "size", le (i, j) de la case sur laquelle on a cliqué donné par i = x // size, j = y // size.
Un exemple minimaliste de tout çà pourrait être:

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
import tkinter as tk
 
COLORS = 'blue', 'red', 'green'
WIDTH = 500
COUNT = 10
SIZE = WIDTH // COUNT
def on_mb1_click(event):
 
    canvas = event.widget
    # le (i, j) de la case
    i, j = event.x // SIZE, event.y // SIZE
    print ('click on case (%d, %d)' % (i, j))
 
    # sur quoi on a cliqué...
    items = canvas.find_withtag('current')
    assert len(items)
    # on fait avancer la couleur
    case = items[0]
    color = canvas.itemconfigure(case, 'fill')[4]
    ix = COLORS.index(color)
    ix = (ix + 1) % len(COLORS)
    canvas.itemconfigure(case, fill=COLORS[ix])
 
def create_grid(window):
 
    canvas = tk.Canvas(window, width=WIDTH, height=WIDTH)
 
    for i in range(COUNT):
        x = i * SIZE 
        for j in range(COUNT):
            y = j * SIZE 
            canvas.create_rectangle(x, y, x+SIZE, y+SIZE, fill=COLORS[0])
 
    canvas.bind('<1>', on_mb1_click)
    return canvas
 
if __name__ == "__main__":
 
    app = tk.Tk()
 
    grid = create_grid(app)
    grid.pack()
 
    tk.mainloop()

Si vous cherchez de la documentation sur les widgets Tk, vous pouvez regarder ce qui est proposé sur le wiki python.

- W