Python

Fonctionnement et applications du widget Checkbutton dans Tkinter

Tkinter, la bibliothèque d’interface graphique standard de Python, offre une variété de widgets pour la création d’interfaces utilisateur interactives. L’un de ces widgets est le Checkbutton, qui permet aux utilisateurs de sélectionner ou de désélectionner une option.

Table des matières Toggle

Qu’est-ce qu’un Checkbutton ?

Un Checkbutton est un élément d’interface graphique qui présente une case à cocher à l’utilisateur. Lorsque la case est cochée, l’option associée est activée ; lorsqu’elle est décochée, l’option est désactivée. Cela permet aux utilisateurs de sélectionner plusieurs options parmi un ensemble donné.

En Tkinter, un Checkbutton est créé à l’aide de la classe Checkbutton du module tkinter. Il peut être configuré avec différents paramètres, tels que le texte à afficher à côté de la case à cocher et la variable associée à l’état du Checkbutton.

Utilisation du Checkbutton dans Tkinter

Voici un exemple simple d’utilisation du Checkbutton dans Tkinter :

import tkinter as tk

def show_selection():
    print("Option 1:", var1.get())
    print("Option 2:", var2.get())

root = tk.Tk()

var1 = tk.BooleanVar()
var2 = tk.BooleanVar()

checkbutton1 = tk.Checkbutton(root, text="Option 1", variable=var1)
checkbutton2 = tk.Checkbutton(root, text="Option 2", variable=var2)

checkbutton1.pack()
checkbutton2.pack()

button = tk.Button(root, text="Afficher la sélection", command=show_selection)
button.pack()

root.mainloop()

Dans cet exemple, nous créons deux Checkbuttons associés à deux variables booléennes distinctes, var1 et var2. Lorsque l’utilisateur coche ou décoche l’une de ces cases, l’état de la variable correspondante est mis à jour. En cliquant sur le bouton “Afficher la sélection”, la fonction show_selection est appelée, affichant l’état actuel des variables.

Obtenir la valeur d’un Checkbutton

Pour obtenir la valeur d’un Checkbutton dans Tkinter, vous pouvez simplement utiliser la méthode get() sur la variable associée. Par exemple, var1.get() renverra True si le Checkbutton associé est cochée, et False sinon.

Applications du Checkbutton

Le widget Checkbutton est couramment utilisé dans de nombreuses applications pour permettre aux utilisateurs de sélectionner des options ou des paramètres. Voici quelques exemples d’applications où le Checkbutton est largement utilisé :

Préférences utilisateur : Les applications peuvent utiliser des Checkbuttons pour permettre aux utilisateurs de personnaliser leurs préférences, comme le mode sombre ou clair, les notifications push, etc.
Filtres de recherche : Sur les sites Web ou les applications qui affichent une liste d’éléments, les Checkbuttons peuvent être utilisés pour filtrer les résultats en fonction des critères sélectionnés par l’utilisateur.
Configuration de logiciel : Les logiciels avec de nombreuses fonctionnalités peuvent utiliser des Checkbuttons dans leurs paramètres pour activer ou désactiver certaines fonctionnalités ou modules.
Contrôle de l’affichage : Dans les applications de visualisation de données, les Checkbuttons peuvent être utilisés pour contrôler quels éléments sont affichés à l’écran, comme les légendes, les axes, etc.

Voici quelques ⭐ exemples pratiques ⭐ d’utilisation du widget Checkbutton avec du code :

Exemple 1 : Création d’une liste de courses interactives

import tkinter as tk

def add_to_shopping_list():
    item = entry.get()
    if item:
        shopping_list.insert(tk.END, item)
        entry.delete(0, tk.END)

def clear_shopping_list():
    shopping_list.delete(0, tk.END)

root = tk.Tk()
root.title("Liste de courses")

# Entrée pour ajouter des éléments à la liste
entry = tk.Entry(root, width=40)
entry.pack(pady=10)

# Bouton pour ajouter un élément à la liste
add_button = tk.Button(root, text="Ajouter à la liste", command=add_to_shopping_list)
add_button.pack()

# Liste pour afficher les éléments sélectionnés
shopping_list = tk.Listbox(root, width=50)
shopping_list.pack(pady=10)

# Bouton pour effacer la liste
clear_button = tk.Button(root, text="Effacer la liste", command=clear_shopping_list)
clear_button.pack()

root.mainloop()

Dans ce cas, nous utilisons un Entry pour permettre à l’utilisateur d’ajouter des éléments à une liste de courses. Chaque fois qu’un élément est ajouté, il est affiché dans une Listbox. Nous pourrions améliorer cette interface en ajoutant des Checkbuttons à côté de chaque élément de la liste pour permettre à l’utilisateur de cocher les éléments qu’il a déjà achetés.

Exemple 2 : Filtres de recherche dans une application de musique

import tkinter as tk

def apply_filters():
    selected_genres = [genre.get() for genre in genres]
    selected_rating = rating.get()
    # Appliquer les filtres à la liste de chansons

root = tk.Tk()
root.title("Filtres de recherche")

# Genres musicaux
genres = [
    "Rock",
    "Pop",
    "Jazz",
    "Hip Hop",
    "Classique"
]

# Créer des Checkbuttons pour chaque genre
genre_vars = [tk.BooleanVar() for _ in genres]
for i, genre in enumerate(genres):
    tk.Checkbutton(root, text=genre, variable=genre_vars[i]).pack()

# Note minimale
rating = tk.Scale(root, from_=0, to=5, orient=tk.HORIZONTAL, label="Note minimale")
rating.pack()

# Bouton pour appliquer les filtres
apply_button = tk.Button(root, text="Appliquer les filtres", command=apply_filters)
apply_button.pack()

root.mainloop()

Ici, nous utilisons des Checkbuttons pour permettre à l’utilisateur de sélectionner plusieurs genres musicaux. Nous utilisons également un Scale pour permettre à l’utilisateur de choisir une note minimale. Lorsque l’utilisateur clique sur le bouton “Appliquer les filtres”, nous récupérons les valeurs sélectionnées à l’aide des get() des variables.

Voici quelques ⭐exemples avancés ⭐ d’utilisation du widget Checkbutton dans Tkinter :

Exemple 1 : Gestionnaire de tâches avec options avancées

import tkinter as tk
from tkinter import messagebox

def add_task():
    task = task_entry.get()
    if task:
        task_list.insert(tk.END, task)
        task_entry.delete(0, tk.END)

def delete_selected():
    selected_tasks = task_list.curselection()
    for task_index in selected_tasks[::-1]:
        task_list.delete(task_index)

def show_completed():
    completed_tasks = [task for i, task in enumerate(tasks) if checkbox_vars[i].get()]
    messagebox.showinfo("Tâches complétées", "\n".join(completed_tasks))

root = tk.Tk()
root.title("Gestionnaire de tâches")

tasks = ["Tâche 1", "Tâche 2", "Tâche 3"]

task_list = tk.Listbox(root, selectmode=tk.MULTIPLE)
for task in tasks:
    task_list.insert(tk.END, task)
task_list.pack()

task_entry = tk.Entry(root)
task_entry.pack()

add_button = tk.Button(root, text="Ajouter une tâche", command=add_task)
add_button.pack()

delete_button = tk.Button(root, text="Supprimer les tâches sélectionnées", command=delete_selected)
delete_button.pack()

checkbox_vars = [tk.BooleanVar() for _ in tasks]
for i, task in enumerate(tasks):
    tk.Checkbutton(root, text=task, variable=checkbox_vars[i]).pack()

show_completed_button = tk.Button(root, text="Afficher les tâches complétées", command=show_completed)
show_completed_button.pack()

root.mainloop()

Dans cet exemple, nous avons un gestionnaire de tâches où chaque tâche est représentée par un Checkbutton. L’utilisateur peut cocher les tâches qu’il a complétées. Lorsqu’il clique sur le bouton “Afficher les tâches complétées”, une boîte de message s’affiche avec les tâches cochées.

Exemple 2 : Interface utilisateur pour la configuration d’un logiciel

import tkinter as tk

def save_configuration():
    selected_options = [option for i, option in enumerate(options) if checkbox_vars[i].get()]
    print("Options sélectionnées :", selected_options)
    # Enregistrer la configuration dans un fichier ou une base de données

root = tk.Tk()
root.title("Configuration du logiciel")

options = [
    "Option 1",
    "Option 2",
    "Option 3",
    "Option 4",
    "Option 5"
]

checkbox_vars = [tk.BooleanVar() for _ in options]
for i, option in enumerate(options):
    tk.Checkbutton(root, text=option, variable=checkbox_vars[i]).pack()

save_button = tk.Button(root, text="Enregistrer la configuration", command=save_configuration)
save_button.pack()

root.mainloop()

Dans ce cas, nous avons une interface utilisateur pour la configuration d’un logiciel. Chaque option est représentée par un Checkbutton. Lorsque l’utilisateur clique sur le bouton “Enregistrer la configuration”, les options sélectionnées sont affichées dans la console. Vous pouvez ensuite enregistrer ces options dans un fichier ou une base de données pour les utiliser ultérieurement.