Python Tkinter – Guide Complet
Python est un langage de programmation populaire et polyvalent utilisé dans de nombreux domaines, y compris le développement d’applications de bureau. L’une des bibliothèques les plus couramment utilisées pour créer des interfaces graphiques (GUI) en Python est Tkinter. Dans cet article, nous explorerons en détail Tkinter, en fournissant un guide complet pour vous aider à démarrer avec la création d’applications GUI en Python.
Qu’est-ce que Tkinter ?
Tkinter est une bibliothèque standard de Python qui permet de créer des interfaces graphiques conviviales. Il est basé sur Tcl/Tk, un ensemble d’outils pour créer des interfaces graphiques qui sont largement utilisées dans l’industrie du logiciel depuis de nombreuses années. Tkinter est inclus avec la plupart des distributions de Python, ce qui en fait un choix naturel pour le développement d’applications GUI en Python.
Installation de Tkinter
Tkinter est généralement installé avec Python, ce qui signifie que vous n’avez pas besoin de faire d’installation supplémentaire pour l’utiliser. Cependant, si vous utilisez une version de Python antérieure à la version 3.1, vous devrez peut-être l’installer manuellement. Pour cela, vous pouvez utiliser le gestionnaire de paquets de votre système d’exploitation ou installer Tkinter à l’aide de pip :
pip install tkPremière application Tkinter
Pour créer votre première application Tkinter, vous devez d’abord importer le module Tkinter dans votre script Python. Ensuite, vous pouvez créer une instance de la classe Tk, qui représente la fenêtre principale de votre application. Voici un exemple simple :
import tkinter as tk
# Créer une instance de la classe Tk
root = tk.Tk()
# Ajouter du contenu à la fenêtre
label = tk.Label(root, text="Bonjour, Tkinter!")
label.pack()
# Lancer la boucle principale de l'application
root.mainloop()Dans cet exemple, nous avons créé une fenêtre Tkinter avec un simple étiquette affichant le texte “Bonjour, Tkinter!”. La méthode mainloop() est utilisée pour démarrer la boucle principale de l’application, ce qui permet à la fenêtre de rester visible et de réagir aux événements de l’utilisateur.
Widgets Tkinter
Tkinter fournit une variété de widgets que vous pouvez utiliser pour construire votre interface graphique. Voici quelques-uns des widgets les plus couramment utilisés :
- Label: Pour afficher du texte ou une image.
- Button: Pour créer des boutons cliquables.
- Entry: Pour permettre à l’utilisateur de saisir du texte.
- Canvas: Pour dessiner des formes et des graphiques.
- Frame: Pour organiser et regrouper d’autres widgets.
Vous pouvez configurer les propriétés de ces widgets, telles que leur texte, leur couleur et leur taille, en passant des paramètres au moment de leur création.
Gestion des événements
Tkinter vous permet de définir des gestionnaires d’événements pour répondre aux actions de l’utilisateur, telles que le clic sur un bouton ou la saisie de texte dans une zone de texte. Vous pouvez utiliser la méthode bind() pour lier un gestionnaire d’événements à un widget spécifique et spécifier quelle fonction doit être appelée lorsque l’événement se produit.
Mise en page avec Tkinter
Tkinter propose plusieurs méthodes pour organiser vos widgets à l’intérieur de la fenêtre, notamment les gestionnaires de géométrie pack(), grid() et place(). Vous pouvez utiliser ces méthodes pour contrôler la disposition des widgets dans votre interface graphique de manière flexible et efficace.
Synthèse
Dans cet article, nous avons exploré les bases de Tkinter, la bibliothèque standard de Python pour la création d’interfaces graphiques. Nous avons couvert l’installation de Tkinter, la création d’une première application Tkinter, l’utilisation de widgets Tkinter, la gestion des événements et la mise en page des widgets. Avec ces connaissances de base, vous êtes prêt à commencer à créer vos propres applications GUI en Python avec Tkinter.
Voici un ⭐ exemple pratique⭐ pour chaque aspect de Tkinter que vous avez mentionné :
Label: Pour afficher du texte ou une image
import tkinter as tk
root = tk.Tk()
# Créer un Label pour afficher du texte
label_texte = tk.Label(root, text="Ceci est un label de texte")
label_texte.pack()
# Créer un Label pour afficher une image
photo = tk.PhotoImage(file="exemple_image.png")
label_image = tk.Label(root, image=photo)
label_image.pack()
root.mainloop()Button: Pour créer des boutons cliquables
import tkinter as tk
root = tk.Tk()
# Définir une fonction à exécuter lorsque le bouton est cliqué
def clic_bouton():
print("Le bouton a été cliqué !")
# Créer un bouton avec du texte
bouton_texte = tk.Button(root, text="Cliquez ici", command=clic_bouton)
bouton_texte.pack()
root.mainloop()Entry: Pour permettre à l’utilisateur de saisir du texte
import tkinter as tk
root = tk.Tk()
# Créer un champ de saisie de texte
entry = tk.Entry(root)
entry.pack()
# Définir une fonction pour récupérer le texte saisi
def get_texte():
texte_saisi = entry.get()
print("Texte saisi :", texte_saisi)
# Créer un bouton pour récupérer le texte saisi
bouton_recuperer_texte = tk.Button(root, text="Récupérer le texte", command=get_texte)
bouton_recuperer_texte.pack()
root.mainloop()Canvas: Pour dessiner des formes et des graphiques
import tkinter as tk
root = tk.Tk()
# Créer un Canvas pour dessiner
canvas = tk.Canvas(root, width=200, height=200)
canvas.pack()
# Dessiner un rectangle
canvas.create_rectangle(50, 50, 150, 150, fill="blue")
# Dessiner un cercle
canvas.create_oval(100, 100, 180, 180, fill="red")
root.mainloop()Frame: Pour organiser et regrouper d’autres widgets
import tkinter as tk
root = tk.Tk()
# Créer un Frame pour organiser les widgets
frame = tk.Frame(root)
frame.pack()
# Ajouter des widgets à l'intérieur du Frame
label1 = tk.Label(frame, text="Widget 1")
label1.pack()
label2 = tk.Label(frame, text="Widget 2")
label2.pack()
bouton = tk.Button(frame, text="Bouton")
bouton.pack()
root.mainloop()Ces exemples devraient vous aider à comprendre comment utiliser chaque aspect de Tkinter dans la pratique pour créer des interfaces graphiques interactives en Python.
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 cet exemple, 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.
Autres articles
