Suppression de boutons tkinter

Willdu286300 -  
Diablo76 Messages postés 247 Date d'inscription   Statut Membre Dernière intervention   -

Bonjour,

Je suis novice en programmation python avec tkinter, je cherche à faire disparaître le bouton "button_game" à la fin de mon script dans game() pouvez vous m'aider 

import tkinter as tk
root=tk.Tk()
text_lancer_game="☆\n★\n☆"
#variable game
x=250
y=1500
movement_step=10
movement_interval=7
movement_direction=None
#vatiable menu
game_level=1
niveau_joueur=1
niveau_arme=0
piece=0
gemme=0
def start_movement(direction):
    global movement_direction
    movement_direction = direction
    move()
    
def stop_movement(event):
    global movement_direction
    movement_direction = None
def bordure():
	global x,y
	if x<=0:
		x+=movement_step
	elif x+(19*23)>=1080:
		x-=movement_step
def move():
    global x, y, movement_direction
    if movement_direction == 'up':
        canvas.delete("all")
        x += movement_step
        bordure()
        game()
    elif movement_direction == 'down':
        canvas.delete("all")
        x -= movement_step
        bordure()
        game()
    if movement_direction:
        root.after(movement_interval, move)

def move_up(event):
    start_movement('up')

def move_down(event):
    start_movement('down')
def boutons(xu,yu,xd,yd):
	button_up = tk.Button(root, 			text="→", bg="#BEF2FF", 					fg="black", font=("Arial", 12, "bold"))
	button_up.bind("<ButtonPress>", 	move_up)
	button_up.										bind("<ButtonRelease>", 	stop_movement)
	button_up.place(x=xu, y=yu)

	button_down = tk.Button(root, 	text="←", bg="#BEF2FF", fg="black", 	font=("Arial", 12, "bold"))
	button_down.	bind("<ButtonPress>", move_down)
	button_down.	bind("<ButtonRelease>", 	stop_movement)
	button_down.place(x=xd, y=yd)

def rectangle(x1, y1, l, h, c):
    canvas.create_rectangle(x1, y1, l, h, fill=c, width=0)
canvas=tk.Canvas(root,width=1080,height=2340)
canvas.pack()
mongolfiere=[
[0,0,0,0,0,0,1,2,2,2,2,0,0,0,0,0,0],
[0,0,0,0,0,3,4,1,2,2,4,3,0,0,0,0,0],
[0,0,0,0,4,3,4,3,1,3,4,3,4,0,0,0,0],
[0,0,0,3,4,3,4,3,1,3,4,3,4,3,0,0,0],
[0,0,4,3,4,3,4,1,2,2,4,3,4,3,4,0,0],
[0,0,1,1,1,1,1,2,2,2,2,2,2,2,2,0,0],
[0,0,1,1,1,1,1,2,2,2,2,2,2,2,2,0,0],
[0,0,1,1,1,1,1,2,2,2,2,2,2,2,2,0,0],
[0,0,4,3,4,3,4,1,2,2,4,3,4,3,4,0,0],
[0,0,0,3,4,3,4,3,1,3,4,3,4,3,0,0,0],
[0,0,0,0,4,3,4,3,1,3,4,3,4,0,0,0,0],
[0,0,0,0,0,3,4,1,2,2,4,3,0,0,0,0,0],
[0,0,0,0,0,0,1,2,2,2,2,0,0,0,0,0,0],
[0,0,0,0,0,0,5,0,7,0,5,0,0,0,0,0,0],
[0,0,0,0,0,0,6,7,8,7,5,0,0,0,0,0,0],
[0,0,0,0,0,0,5,8,9,8,6,0,0,0,0,0,0],
[0,0,5,5,6,6,6,5,5,6,5,6,6,5,6,0,0],
[5,6,6,5,1,2,2,2,2,2,2,2,2,6,5,5,6],
[0,0,5,6,6,6,5,5,6,6,6,6,5,6,6,0,0]]
def fond():
	rectangle(0,0,1080,2340,"#BEF2FF")
def mongolfiere_rouge(x,y,t):
	for j in range(17):
		for i in range(19):
			if mongolfiere[i][j]==1:
				rectangle(x+(i*t),y+(j*t),x+(i*t)+t,y+(j*t)+t,"#C89E12")
			elif mongolfiere[i][j]==2:
				rectangle(x+(i*t),y+(j*t),x+(i*t)+t,y+(j*t)+t,"#D7A910")
			elif mongolfiere[i][j]==3:
				rectangle(x+(i*t),y+(j*t),x+(i*t)+t,y+(j*t)+t,"#913C00")
			elif mongolfiere[i][j]==4:
				rectangle(x+(i*t),y+(j*t),x+(i*t)+t,y+(j*t)+t,"#AB4F09")
			elif mongolfiere[i][j]==5:
				rectangle(x+(i*t),y+(j*t),x+(i*t)+t,y+(j*t)+t,"#7C6344")
			elif mongolfiere[i][j]==6:
				rectangle(x+(i*t),y+(j*t),x+(i*t)+t,y+(j*t)+t,"#91734C")
			elif mongolfiere[i][j]==7:
				rectangle(x+(i*t),y+(j*t),x+(i*t)+t,y+(j*t)+t,"#913C00")
			elif mongolfiere[i][j]==8:
				rectangle(x+(i*t),y+(j*t),x+(i*t)+t,y+(j*t)+t,"#AB4F09")
			elif mongolfiere[i][j]==9:
				rectangle(x+(i*t),y+(j*t),x+(i*t)+t,y+(j*t)+t,"#C96519")
def mongolfiere_bleu(x,y,t):
	for j in range(17):
		for i in range(19):
			if mongolfiere[i][j]==1:
				rectangle(x+(i*t),y+(j*t),x+(i*t)+t,y+(j*t)+t,"#C89E12")
			elif mongolfiere[i][j]==2:
				rectangle(x+(i*t),y+(j*t),x+(i*t)+t,y+(j*t)+t,"#D7A910")
			elif mongolfiere[i][j]==3:
				rectangle(x+(i*t),y+(j*t),x+(i*t)+t,y+(j*t)+t,"#226B72")
			elif mongolfiere[i][j]==4:
				rectangle(x+(i*t),y+(j*t),x+(i*t)+t,y+(j*t)+t,"#398087")
			elif mongolfiere[i][j]==5:
				rectangle(x+(i*t),y+(j*t),x+(i*t)+t,y+(j*t)+t,"#7C6344")
			elif mongolfiere[i][j]==6:
				rectangle(x+(i*t),y+(j*t),x+(i*t)+t,y+(j*t)+t,"#91734C")
			elif mongolfiere[i][j]==7:
				rectangle(x+(i*t),y+(j*t),x+(i*t)+t,y+(j*t)+t,"#913C00")
			elif mongolfiere[i][j]==8:
				rectangle(x+(i*t),y+(j*t),x+(i*t)+t,y+(j*t)+t,"#AB4F09")
			elif mongolfiere[i][j]==9:
				rectangle(x+(i*t),y+(j*t),x+(i*t)+t,y+(j*t)+t,"#C96519")
def delete_all():
	button_game.destroy()
def game():
	
	canvas.pack()
	fond()
	mongolfiere_bleu(x,y,23)
	mongolfiere_rouge(250,500,23)
	boutons(900,1700,750,1700)
	delete_all()
def menu():
	button_game=tk.Button(root,text=text_lancer_game,command=game).place(x=950,y=0)
root.after(1000,menu())
root.mainloop()

Pardon, le script est long
Android / Chrome 124.0.0.0

2 réponses

houso
 

Bonsoir, si tu as bien compris le concept de la « portée des variables » en programmation, tu dois bien saisir que ce qui est déclaré dans telle fonction est inconnu dans une autre fonction si cela n'est pas déclaré en global.

En conséquence :

def menu():
    global button_game
    button_game = tk.Button(root,text=text_lancer_game,command=game)
    button_game.place(x=950,y=0)

Si tu as vu les dictionnaires, ce serait mieux de les utiliser pour définir tes valeurs, par exemple :

position = dict(
    x=250,
    y=1500,
)

movements = dict(
    step=10,
    interval=7,
    direction=None,
)

Ainsi plus besoin d'utiliser de global dans tes fonctions.

root.after(1000,menu())

Attention, il ne faut pas mettre de parenthèses à menu, c'est tkinter qui appelera ta fonction.

0
Phil_1857
 

Bonjour Houso,

On peut aussi définir directement un dictionnaire:

positions = {'x':250.0, 'y':1500.0}
0
houso > Phil_1857
 

Salut Phil, c'est ce que j'ai indiqué non ?

C'est une autre façon de déclarer un dict, je préfère la syntaxe utilisant dict plutôt qu'avec les accolades qui oblige à utiliser des quotes.

C'est moins pénible d'écrire

dico = dict(
    key_1='valeur 1',
    # ...
    key_n='valeur n',
)

Plutôt que

dico = {
    'key_1': 'valeur 1',
    # ...
    'key_n': 'valeur n',
}

Surtout lorqu'il y a moult valeurs à enregistrer.
 

Les seules fois où j'utilise la syntaxe avec accolades, c'est quand les clefs sont numériques ou encore contenant des caractères spéciaux, bref, la règle est semblable à la syntaxe de la déclaration de variables.

0
Phil_1857 > houso
 

ah OK 

0
Diablo76 Messages postés 247 Date d'inscription   Statut Membre Dernière intervention   85 > houso
 

Salut,

Personnellement, je préfère la solution de Phil qui est la bonne, plutôt que de créer un tuple que l'on convertit ensuite en dict (ça peut être énergivore sûr de très gros tuple) ;-)

0
houso > Diablo76 Messages postés 247 Date d'inscription   Statut Membre Dernière intervention  
 

Bonjour, comment ça des tuples ? Je n'ai pas saisi où tu vois un tuple dans la construction x=truc, et trouver énergivore le fait de déclarer un dictionnaire de cette façon, euh, faut pas exagérér non plus XD

Je pense que ce à quoi tu fais allusion est de déclarer un dict comme ceci :

dict((('a', 1), ('b', 2)))

Ce qui n'est pas du tout la même forme.

Puis, je ne suis pas sûr que ce soit plus lent que de le déclarer avec les accolades, à mon avis la différence de temps d'exécution doit se jouer en microsecondes, même avec des tuples conséquents.
 

J'ai la flemme de tester...

0
houso
 

Re, voici quelques améliorations que tu pourrais apporter à ton code.
Il est inutile de vider le canvas et recréer chaque fois tes montgolfières, il est possible de définir des groupes d'items dans un canvas, avec le paramètre tags, c'est très pratique pour faire déplacer tout un tas d'items facilement.

Les buttons possèdent des propriétés permettant de répéter une action tant que le bouton est pressé, cela se fait avec repeatdelay et repeatinterval, ainsi plus besoin de bind sur les boutons =)

Les fonctions de créations de mongolfières étant identique, autant en faire une fonction générique recevant coordonnée, dimension et couleurs.

Le canvas possède une méthode bbox retournant les coordonnées d'un rectangle (x, y, x2, y2) englobant les items d'un canvas, ici ce sera bien pratique pour ne pas faire sortir tes montgolfières hors écran.

import tkinter as tk


TEXT_START_GAME = '☆\n★\n☆'
TAG_BALLOON = 'balloon_rect'
MOTION = 5
CANVAS_WIDTH = 1080
CANVAS_HEIGHT = 2340
BUTTON_REPEATDELAY = 10
BUTTON_REPEATINTERVAL = 10

BALLOON = (
    (0, 0, 0, 0, 0, 0, 1, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0),
    (0, 0, 0, 0, 0, 3, 4, 1, 2, 2, 4, 3, 0, 0, 0, 0, 0),
    (0, 0, 0, 0, 4, 3, 4, 3, 1, 3, 4, 3, 4, 0, 0, 0, 0),
    (0, 0, 0, 3, 4, 3, 4, 3, 1, 3, 4, 3, 4, 3, 0, 0, 0),
    (0, 0, 4, 3, 4, 3, 4, 1, 2, 2, 4, 3, 4, 3, 4, 0, 0),
    (0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0),
    (0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0),
    (0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0),
    (0, 0, 4, 3, 4, 3, 4, 1, 2, 2, 4, 3, 4, 3, 4, 0, 0),
    (0, 0, 0, 3, 4, 3, 4, 3, 1, 3, 4, 3, 4, 3, 0, 0, 0),
    (0, 0, 0, 0, 4, 3, 4, 3, 1, 3, 4, 3, 4, 0, 0, 0, 0),
    (0, 0, 0, 0, 0, 3, 4, 1, 2, 2, 4, 3, 0, 0, 0, 0, 0),
    (0, 0, 0, 0, 0, 0, 1, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0),
    (0, 0, 0, 0, 0, 0, 5, 0, 7, 0, 5, 0, 0, 0, 0, 0, 0),
    (0, 0, 0, 0, 0, 0, 6, 7, 8, 7, 5, 0, 0, 0, 0, 0, 0),
    (0, 0, 0, 0, 0, 0, 5, 8, 9, 8, 6, 0, 0, 0, 0, 0, 0),
    (0, 0, 5, 5, 6, 6, 6, 5, 5, 6, 5, 6, 6, 5, 6, 0, 0),
    (5, 6, 6, 5, 1, 2, 2, 2, 2, 2, 2, 2, 2, 6, 5, 5, 6),
    (0, 0, 5, 6, 6, 6, 5, 5, 6, 6, 6, 6, 5, 6, 6, 0, 0),
)

def move_up():
    box = canvas.bbox(TAG_BALLOON)
    if box[1] >= MOTION:
        canvas.move(TAG_BALLOON, 0, -MOTION)

def move_down():
    box = canvas.bbox(TAG_BALLOON)
    if box[3] <= CANVAS_HEIGHT - MOTION:
        canvas.move(TAG_BALLOON, 0, MOTION)

def dislay_buttons(up_x, up_y, down_x, down_y):
    button_up = tk.Button(
        window, text="→", bg="#BEF2FF", fg="black",
        font=("Arial", 12, "bold"),
        command=move_up, repeatdelay=BUTTON_REPEATDELAY,
        repeatinterval=BUTTON_REPEATINTERVAL,
    )
    button_up.place(x=up_x, y=up_y)
    button_down = tk.Button(
        window, text="←", bg="#BEF2FF", fg="black",
        font=("Arial", 12, "bold"),
        command=move_down, repeatdelay=BUTTON_REPEATDELAY,
        repeatinterval=BUTTON_REPEATINTERVAL,
    )
    button_down.place(x=down_x, y=down_y)

def create_balloon(x, y, size, colors):
    for j in range(len(BALLOON)):
        for i in range(len(BALLOON[0])):
            if BALLOON[j][i]:
                canvas.create_rectangle(
                    x + i * size, y + j * size,
                    x + i * size + size, y + j * size + size,
                    fill=colors[BALLOON[j][i] - 1], width=0,
                    tags=(TAG_BALLOON,)
                )

def create_red_balloon(x, y, size):
    colors = (
        '#C89E12',
        "#D7A910",
        "#913C00",
        "#AB4F09",
        "#7C6344",
        "#91734C",
        "#913C00",
        "#AB4F09",
        "#C96519",
    )
    create_balloon(x, y, size, colors)

def create_blue_balloon(x, y, size):
    colors = (
        '#C89E12',
        '#D7A910',
        '#226B72',
        '#398087',
        '#7C6344',
        '#91734C',
        '#913C00',
        '#AB4F09',
        '#C96519',
    )
    create_balloon(x, y, size, colors)

def start_game(start_button):
    start_button.destroy()
    canvas.configure(bg='#BEF2FF')
    create_blue_balloon(250, 1500, 23)
    create_red_balloon(250, 500, 23)
    dislay_buttons(900, 1700, 750, 1700)
    dislay_buttons(900, 50, 750, 50)

def display_menu(master):
    button = tk.Button(master, text=TEXT_START_GAME)
    button.configure(command=lambda: start_game(button))
    button.place(x=950, y=0)

window = tk.Tk()
canvas = tk.Canvas(window, width=CANVAS_WIDTH, height=CANVAS_HEIGHT)
canvas.pack()
window.after(1000, display_menu, window)
window.mainloop()

On pourrait encore améliorer certaines choses, mais si tu arrives à bien comprendre ce code, ce sera l'essentiel.

0