Créer une Interface Graphique en Python avec Tkinter : Guide Détaillé

Les interfaces graphiques (GUI) jouent un rôle crucial dans de nombreux programmes, offrant une manière conviviale et intuitive pour les utilisateurs d’interagir avec des logiciels. Python, avec sa bibliothèque standard Tkinter, offre un moyen simple et efficace de créer des interfaces graphiques. Dans cet article, nous allons explorer en détail comment créer une interface graphique en utilisant Tkinter.

Introduction à Tkinter

Tkinter est une bibliothèque GUI (Graphical User Interface) incluse dans la distribution standard de Python. Elle fournit des outils pour créer facilement des fenêtres, des boutons, des champs de texte, des cases à cocher et bien plus encore.

Installation de Tkinter

Pour utiliser Tkinter, vous n’avez besoin d’aucune installation supplémentaire, car il est inclus dans la distribution standard de Python. Cependant, assurez-vous d’avoir une version de Python installée sur votre système.

Création d’une Fenêtre

Commençons par créer une fenêtre simple en Tkinter :

import tkinter as tk

# Création de la fenêtre principale
fenetre = tk.Tk()
fenetre.title("Ma Première Interface Graphique")

# Boucle principale d'exécution
fenetre.mainloop()

Dans ce code :

• Nous importons le module tkinter sous le nom de tk.
• Ensuite, nous créons une instance de la classe Tk() pour représenter notre fenêtre principale.
• Nous attribuons un titre à la fenêtre à l’aide de la méthode title().
• Enfin, nous démarrons la boucle principale d’exécution de l’interface graphique avec mainloop().

Ajout d’un Bouton

Maintenant, ajoutons un bouton à notre fenêtre :

import tkinter as tk

# Fonction appelée lorsqu'on clique sur le bouton
def clic_bouton():
    print("Bouton cliqué !")

# Création de la fenêtre principale
fenetre = tk.Tk()
fenetre.title("Ma Première Interface Graphique")

# Création du bouton
bouton = tk.Button(fenetre, text="Cliquez ici", command=clic_bouton)
bouton.pack()

# Boucle principale d'exécution
fenetre.mainloop()

Dans ce code :

• Nous avons défini une fonction clic_bouton() qui sera appelée lorsque le bouton est cliqué.
• Ensuite, nous avons créé un bouton à l’aide de la classe Button de Tkinter, en spécifiant le texte à afficher et la fonction à appeler lors du clic.
• Nous utilisons la méthode pack() pour placer le bouton dans la fenêtre.

Ajout d’un Champ de Texte

Ajoutons maintenant un champ de texte où l’utilisateur peut saisir du texte :

import tkinter as tk

# Fonction appelée lorsqu'on clique sur le bouton
def clic_bouton():
    texte_entre = champ_texte.get()
    print("Texte saisi :", texte_entre)

# Création de la fenêtre principale
fenetre = tk.Tk()
fenetre.title("Ma Première Interface Graphique")

# Création du champ de texte
champ_texte = tk.Entry(fenetre)
champ_texte.pack()

# Création du bouton
bouton = tk.Button(fenetre, text="Afficher texte", command=clic_bouton)
bouton.pack()

# Boucle principale d'exécution
fenetre.mainloop()

Dans ce code :

• Nous avons utilisé la classe Entry pour créer un champ de texte.
• Lorsque le bouton est cliqué, la fonction clic_bouton() récupère le texte saisi à l’aide de la méthode get() du champ de texte.

Voici quelques exemples concrets de cas d’utilisation avec du code pour créer des interfaces graphiques en Python avec Tkinter :

Exemple 1: Calculatrice Simple

import tkinter as tk

# Fonction pour effectuer les calculs
def calculer():
    try:
        resultat.set(eval(expression.get()))
    except:
        resultat.set("Erreur")

# Création de la fenêtre principale
fenetre = tk.Tk()
fenetre.title("Calculatrice")

# Variables Tkinter pour le champ de texte et le résultat
expression = tk.StringVar()
resultat = tk.StringVar()

# Champ de texte pour l'expression à évaluer
champ_expression = tk.Entry(fenetre, textvariable=expression)
champ_expression.grid(row=0, column=0, columnspan=4)

# Boutons pour les chiffres et opérateurs
boutons = [
    '7', '8', '9', '/',
    '4', '5', '6', '*',
    '1', '2', '3', '-',
    '0', '.', '=', '+'
]

row = 1
col = 0
for bouton in boutons:
    tk.Button(fenetre, text=bouton, command=lambda b=bouton: expression.set(expression.get() + b)).grid(row=row, column=col)
    col += 1
    if col > 3:
        col = 0
        row += 1

# Bouton pour calculer le résultat
tk.Button(fenetre, text="Calculer", command=calculer).grid(row=6, column=0, columnspan=4)

# Champ de texte pour afficher le résultat
champ_resultat = tk.Entry(fenetre, textvariable=resultat, state='readonly')
champ_resultat.grid(row=7, column=0, columnspan=4)

# Boucle principale d'exécution
fenetre.mainloop()

Cet exemple crée une calculatrice simple qui évalue des expressions mathématiques.

Exemple 2: Carnet d’Adresses

import tkinter as tk

# Fonction pour enregistrer un nouveau contact
def enregistrer_contact():
    nom = champ_nom.get()
    email = champ_email.get()
    carnet.append((nom, email))
    afficher_contacts()

# Fonction pour afficher les contacts dans la listebox
def afficher_contacts():
    liste_contacts.delete(0, tk.END)
    for contact in carnet:
        liste_contacts.insert(tk.END, f"{contact[0]} - {contact[1]}")

# Création de la fenêtre principale
fenetre = tk.Tk()
fenetre.title("Carnet d'adresses")

# Variables Tkinter pour les champs de saisie
nom = tk.StringVar()
email = tk.StringVar()

# Champs de saisie pour le nom et l'email
tk.Label(fenetre, text="Nom :").grid(row=0, column=0)
champ_nom = tk.Entry(fenetre, textvariable=nom)
champ_nom.grid(row=0, column=1)

tk.Label(fenetre, text="Email :").grid(row=1, column=0)
champ_email = tk.Entry(fenetre, textvariable=email)
champ_email.grid(row=1, column=1)

# Bouton pour enregistrer un nouveau contact
tk.Button(fenetre, text="Enregistrer", command=enregistrer_contact).grid(row=2, column=0, columnspan=2)

# Listebox pour afficher les contacts
liste_contacts = tk.Listbox(fenetre)
liste_contacts.grid(row=3, column=0, columnspan=2)

# Liste de contacts (initialisation vide)
carnet = []

# Afficher les contacts initiaux (vides)
afficher_contacts()

# Boucle principale d'exécution
fenetre.mainloop()

Cet exemple crée un carnet d’adresses où l’utilisateur peut ajouter des contacts avec leur nom et leur email, et les afficher dans une liste.

Voici comment vous pourriez intégrer ces solutions potentielles dans votre code :

1. Gestion des Tailles et Positionnement des Widgets

Utilisation de la méthode grid() pour un positionnement précis des widgets :

# Exemple de positionnement précis des widgets avec grid()
label1 = tk.Label(fenetre, text="Label 1")
label1.grid(row=0, column=0)

label2 = tk.Label(fenetre, text="Label 2")
label2.grid(row=0, column=1)

bouton = tk.Button(fenetre, text="Bouton")
bouton.grid(row=1, column=0, columnspan=2)

2. Gestion des Événements et des Actions Utilisateur

Utilisation de bind() pour gérer les événements utilisateur :

# Exemple d'utilisation de bind() pour gérer les événements
def clic_bouton(event):
    print("Bouton cliqué !")

bouton = tk.Button(fenetre, text="Bouton")
bouton.bind("<Button-1>", clic_bouton)

3. Gestion des Données Saisies par l’Utilisateur

Récupération des données saisies par l’utilisateur avec get() :

# Exemple de récupération des données saisies par l'utilisateur
nom_utilisateur = entry_nom.get()
mot_de_passe = entry_mot_de_passe.get()

4. Gestion des Styles et de l’Apparence

Utilisation des méthodes de configuration des widgets pour personnaliser l’apparence :

# Exemple de configuration de l'apparence d'un widget
bouton = tk.Button(fenetre, text="Bouton")
bouton.config(bg="blue", fg="white", font=("Arial", 12))

5. Gestion des Versions de Python et de Tkinter

Ajout de vérifications de compatibilité pour assurer un fonctionnement cohérent :

# Exemple de vérification de la version de Python
import sys

if sys.version_info < (3, 6):
    print("Ce programme nécessite Python 3.6 ou une version ultérieure.")
    sys.exit(1)

# Exemple de vérification de la version de Tkinter
import tkinter as tk

if tk.TkVersion < 8.6:
    print("Cette version de Tkinter n'est pas prise en charge.")
    sys.exit(1)

En intégrant ces solutions dans votre code, vous pouvez améliorer la robustesse et la convivialité de votre interface graphique en Python avec Tkinter.

Conclusion

Tkinter offre une manière simple et efficace de créer des interfaces graphiques en Python. Dans cet article, nous avons couvert les bases de la création d’une interface graphique avec Tkinter, notamment la création d’une fenêtre, l’ajout de boutons et de champs de texte. Avec ces connaissances de base, vous pouvez commencer à créer des interfaces graphiques pour vos propres projets Python.