Pourquoi ne pas mettre de parenthèses dans command= pour un bouton Tkinter ?

Sans parenthèses, on passe la référence à la fonction — Tkinter l'appellera au clic. Avec les parenthèses (command=ma_fonction()), la fonction s'exécute immédiatement lors de la création du bouton, et command reçoit None comme valeur. Aucune erreur n'est levée, ce qui rend ce bug difficile à détecter.

Comment passer des arguments à une fonction appelée par un bouton Tkinter ?

Deux méthodes : lambda avec les arguments : command=lambda: ma_fonction(arg1, arg2). Ou functools.partial : from functools import partial; command=partial(ma_fonction, arg1, arg2). partial est préférable dans les boucles pour éviter le piège de la closure où tous les boutons capturent la même dernière valeur.

Quel est le piège de lambda dans une boucle avec des boutons Tkinter ?

Dans une boucle, lambda: ma_fonction(variable) capture la variable par référence, pas par valeur. À la fin de la boucle, tous les lambdas pointent vers la même valeur finale. La solution est d'utiliser functools.partial, ou de fixer la valeur dans la lambda : lambda v=variable: ma_fonction(v).

Comment créer un bouton toggle (bascule) dans Tkinter ?

On stocke l'état dans une BooleanVar ou une variable, et dans la fonction command on inverse l'état puis on met à jour le bouton avec config(). Exemple : actif.set(not actif.get()); btn.config(text='Pause' if actif.get() else 'Démarrer').

Comment changer le texte ou la couleur d'un bouton Tkinter après un clic ?

On utilise la méthode config() sur la référence du bouton : btn.config(text='nouveau texte', bg='#ff5722'). Pour cela, il faut stocker le bouton dans une variable au lieu de chaîner directement pack() : btn = tk.Button(...); btn.pack().

Quelle différence entre command et bind() pour gérer un clic sur un bouton Tkinter ?

command réagit uniquement au clic gauche standard sur un bouton activé. bind() permet de réagir à des événements spécifiques : clic droit ( ), double-clic ( ), survol ( ), etc. Pour un bouton ordinaire, command suffit. bind() est utile pour des comportements plus fins ou sur d'autres widgets.

Gérer le clic d'un bouton Tkinter — command et événements en Python

OUJOOD.COM

Le paramètre command du widget Button est la façon la plus directe de réagir à un clic. Mais selon la complexité de l'action à déclencher, plusieurs schémas s'offrent à vous — et certains pièges valent la peine d'être connus avant de les tomber dessus.

Rappel : command sans parenthèses

La règle fondamentale : on passe la référence à la fonction, sans l'appeler :

📋 Copier le code

import tkinter as tk

def action():
    label.config(text="Bouton cliqué !")

fenetre = tk.Tk()
fenetre.geometry("300x130")

# Correct : référence à la fonction
tk.Button(fenetre, text="Cliquer", command=action).pack(pady=20)

# Incorrect : appel immédiat au moment de la création
# tk.Button(fenetre, text="Cliquer", command=action()).pack()

label = tk.Label(fenetre, text="En attente...")
label.pack()

fenetre.mainloop()

L'erreur avec les parenthèses est particulièrement traîtresse parce qu'elle ne génère pas de message d'erreur — la fonction s'exécute simplement au mauvais moment, et command reçoit None (la valeur de retour de la fonction).

Passer des arguments au clic

Quand la fonction à appeler attend des paramètres, deux approches fonctionnent : lambda pour les cas simples, functools.partial pour les cas où lambda dans une boucle pose problème :

📋 Copier le code

import tkinter as tk
from functools import partial

def afficher_couleur(couleur, label_affichage):
    label_affichage.config(text=f"Couleur choisie : {couleur}", bg=couleur)

fenetre = tk.Tk()
fenetre.geometry("360x180")

label_result = tk.Label(fenetre, text="Choisissez une couleur", width=30, height=2)
label_result.pack(pady=15)

frame_btns = tk.Frame(fenetre)
frame_btns.pack()

couleurs = [("Rouge", "#ef9a9a"), ("Vert", "#a5d6a7"), ("Bleu", "#90caf9")]

for nom, hex_val in couleurs:
    # partial évite le piège de la closure dans une boucle
    cmd = partial(afficher_couleur, hex_val, label_result)
    tk.Button(frame_btns, text=nom, bg=hex_val, command=cmd).pack(side="left", padx=5)

fenetre.mainloop()

Le piège de lambda dans une boucle est classique : si on écrit command=lambda: afficher_couleur(hex_val, label_result), tous les boutons capturent la dernière valeur de hex_val après la fin de la boucle. partial ou lambda c=hex_val: afficher_couleur(c, label_result) fixent la valeur au moment de la création.

Bouton toggle — changer d'état au clic

Un bouton qui bascule entre deux états est un cas fréquent — pause/lecture, activer/désactiver :

📋 Copier le code

import tkinter as tk

fenetre = tk.Tk()
fenetre.geometry("300x150")

actif = tk.BooleanVar(value=False)

def basculer():
    actif.set(not actif.get())
    if actif.get():
        btn.config(text="⏸ Pause", bg="#ef5350", activebackground="#c62828")
        label_etat.config(text="État : en cours")
    else:
        btn.config(text="▶ Démarrer", bg="#66bb6a", activebackground="#388e3c")
        label_etat.config(text="État : arrêté")

btn = tk.Button(fenetre, text="▶ Démarrer", command=basculer,
                bg="#66bb6a", fg="white", font=("Arial", 12),
                activebackground="#388e3c", activeforeground="white",
                relief="flat", padx=20, pady=6)
btn.pack(pady=25)

label_etat = tk.Label(fenetre, text="État : arrêté", font=("Arial", 10), fg="#555")
label_etat.pack()

fenetre.mainloop()

On stocke l'état dans une BooleanVar plutôt qu'une variable globale — c'est plus propre et on peut observer les changements avec trace_add() si nécessaire.

Pour les événements plus fins — clic droit, double-clic, survol — la méthode bind() prend le relais. Et si vous avez plusieurs boutons qui partagent une logique commune, les fonctions callback structurées proprement évitent la duplication de code.

Par carabde | Mis à jour le 30 avril 2025

← Variables de contrôle (StringVar, IntVar...)

Sommaire

Les fonctions callback Tkinter →