Python

Tkinter entry Python – Guide complet

Tkinter est une bibliothèque d’interface graphique pour Python, très utilisée pour créer des applications de bureau simples. Le widget Entry est un composant fondamental de Tkinter, utilisé pour saisir une ligne de texte par l’utilisateur. Il est idéal pour recevoir des inputs comme des noms d’utilisateur, des mots de passe, ou tout autre texte court.

Utilisation Basique de `Entry`

Pour utiliser le widget Entry, vous devez d’abord créer une instance de Tkinter, puis un cadre pour votre application, et enfin, l’Entry lui-même.

import tkinter as tk

# Création de la fenêtre principale
root = tk.Tk()

# Création d'un widget Entry
entry = tk.Entry(root)
entry.pack()

# Démarrage de la boucle principale de l'application
root.mainloop()

Options de Configuration

Le widget Entry offre plusieurs options pour personnaliser son apparence et son comportement :

width : Définit la largeur du widget en nombre de caractères.
font : Permet de changer la police de caractères et la taille du texte.
show : Utile pour masquer les caractères, par exemple en remplaçant chaque caractère par un astérisque (*) pour les mots de passe.
textvariable : Associe une variable Tkinter (StringVar) à l’Entry, permettant de récupérer ou de modifier le texte facilement.

Validation des Données

Vous pouvez contrôler ce que l’utilisateur entre dans l’Entry en utilisant l’option validate. Cette option permet de définir quand la validation doit être déclenchée (par exemple à chaque frappe, lors de la perte du focus, etc.).

def valider_entree(input):
    # Vérifie si l'entrée est numérique
    return input.isdigit()

# Création de la fenêtre et de l'Entry avec validation
root = tk.Tk()
sv = tk.StringVar()
entry = tk.Entry(root, textvariable=sv, validate="key", validatecommand=(root.register(valider_entree), '%P'))
entry.pack()
root.mainloop()

Exemples Pratiques

Exemple 1 : Formulaire de Connexion

Un formulaire simple avec un champ pour le nom d’utilisateur et un autre pour le mot de passe.

def submit():
    username = username_entry.get()
    password = password_entry.get()
    print(f"Nom d'utilisateur: {username}, Mot de passe: {password}")

root = tk.Tk()
root.title("Formulaire de Connexion")

# Nom d'utilisateur
tk.Label(root, text="Nom d'utilisateur:").pack()
username_entry = tk.Entry(root)
username_entry.pack()

# Mot de passe
tk.Label(root, text="Mot de passe:").pack()
password_entry = tk.Entry(root, show="*")
password_entry.pack()

# Bouton de soumission
submit_button = tk.Button(root, text="Soumettre", command=submit)
submit_button.pack()

root.mainloop()

Exemple 2 : Champ de Saisie Dynamique

Modifier le contenu d’un label en fonction de ce qui est saisi dans l’Entry.

def update_label(*args):
    label.config(text=f"Bonjour, {sv.get()}!")

root = tk.Tk()
sv = tk.StringVar()
sv.trace("w", update_label)

entry = tk.Entry(root, textvariable=sv)
entry.pack()

label = tk.Label(root, text="Bonjour, utilisateur!")
label.pack()

root.mainloop()

Voici quelques⭐ exemples pratiques⭐ supplémentaires pour illustrer l’utilisation du widget Entry de Tkinter dans différents contextes :

Exemple 3 : Convertisseur de Température

Un simple convertisseur de température de Celsius à Fahrenheit qui utilise un Entry pour la saisie de la température initiale et affiche le résultat après conversion.

def convertir_temperature():
    try:
        celsius = float(celsius_entry.get())
        fahrenheit = celsius * 9 / 5 + 32
        resultat_label.config(text=f"{fahrenheit:.2f} Fahrenheit")
    except ValueError:
        resultat_label.config(text="Entrée invalide!")

root = tk.Tk()
root.title("Convertisseur Celsius à Fahrenheit")

# Entrée pour Celsius
tk.Label(root, text="Température en Celsius:").pack()
celsius_entry = tk.Entry(root)
celsius_entry.pack()

# Bouton pour la conversion
convert_button = tk.Button(root, text="Convertir", command=convertir_temperature)
convert_button.pack()

# Label pour afficher le résultat
resultat_label = tk.Label(root, text="Entrez une température et cliquez sur Convertir")
resultat_label.pack()

root.mainloop()

Exemple 4 : Calculatrice Simple

Une calculatrice basique qui utilise des Entry pour les opérandes et affiche le résultat des opérations de base.

def effectuer_operation():
    try:
        num1 = float(operande1_entry.get())
        num2 = float(operande2_entry.get())
        if operation.get() == "+":
            resultat = num1 + num2
        elif operation.get() == "-":
            resultat = num1 - num2
        elif operation.get() == "*":
            resultat = num1 * num2
        elif operation.get() == "/":
            if num2 != 0:
                resultat = num1 / num2
            else:
                resultat_label.config(text="Erreur : Division par zéro!")
                return
        resultat_label.config(text=f"Résultat : {resultat}")
    except ValueError:
        resultat_label.config(text="Erreur : Entrée numérique invalide!")

root = tk.Tk()
root.title("Calculatrice Simple")

# Opérande 1
tk.Label(root, text="Opérande 1:").pack()
operande1_entry = tk.Entry(root)
operande1_entry.pack()

# Opérande 2
tk.Label(root, text="Opérande 2:").pack()
operande2_entry = tk.Entry(root)
operande2_entry.pack()

# Sélection de l'opération
operation = tk.StringVar()
operation.set("+")
tk.OptionMenu(root, operation, "+", "-", "*", "/").pack()

# Bouton pour effectuer le calcul
calcul_button = tk.Button(root, text="Calculer", command=effectuer_operation)
calcul_button.pack()

# Label pour le résultat
resultat_label = tk.Label(root, text="Résultat apparaîtra ici")
resultat_label.pack()

root.mainloop()

Exemple 5 : Recherche dans une Liste

Un champ de recherche qui filtre dynamiquement une liste d’éléments affichés dans un Listbox selon ce qui est tapé dans l’Entry.

def filtrer_elements():
    terme_de_recherche = recherche_entry.get().lower()
    listbox.delete(0, tk.END)
    for element in elements:
        if terme_de_recherche in element.lower():
            listbox.insert(tk.END, element)

root = tk.Tk()
root.title("Recherche dans une Liste")

elements = ["Pomme", "Banane", "Cerise", "Datte", "Figue", "Grenade", "Kiwi"]

# Champ de recherche
tk.Label(root, text="Rechercher:").pack()
recherche_entry = tk.Entry(root)
recherche_entry.pack()
recherche_entry.bind("<KeyRelease>", lambda event: filtrer_elements())

# Listbox pour afficher les éléments filtrés
listbox = tk.Listbox(root)
listbox.pack(pady=10)
for element in elements:
    listbox.insert(tk.END, element)

root.mainloop()

Ces exemples montrent comment le widget Entry peut être utilisé dans diverses applications, allant de la saisie de données à la création d’interfaces interactives.

Voici quelques ⭐ cas particuliers ⭐ illustrant l’utilisation du widget Entry de Tkinter, chacun accompagné de son code. Ces exemples démontrent des utilisations avancées ou spécifiques pour répondre à des besoins diversifiés.

Exemple 6 : Saisie avec Masque de Format

Un champ Entry où l’utilisateur doit entrer une date dans un format spécifique (par exemple, JJ-MM-AAAA), en utilisant le widget Entry avec un masquage dynamique.

def on_write(*args):
    text = date_var.get()
    if len(text) > 10:  # Limite la longueur à celle de JJ-MM-AAAA
        date_var.set(text[:10])
    if len(text) in [2, 5]:  # Ajoute un tiret après le jour et le mois
        date_var.set(text + '-')

root = tk.Tk()
root.title("Saisie avec Masque de Format")

date_var = tk.StringVar()
date_var.trace("w", on_write)

date_entry = tk.Entry(root, textvariable=date_var)
date_entry.pack()

root.mainloop()

Exemple 7 : Synchronisation entre Deux `Entry`

Deux champs Entry dont les valeurs sont liées : la modification de l’un met à jour l’autre. Par exemple, une conversion de monnaie ou une unité de mesure.

def synchroniser(*args):
    if metre_var.get():
        try:
            metres = float(metre_var.get())
            pieds = metres * 3.28084
            pied_var.set(f"{pieds:.2f}")
        except ValueError:
            pied_var.set("Erreur")

root = tk.Tk()
root.title("Synchronisation entre Deux Entry")

# Entrée pour les mètres
tk.Label(root, text="Mètres:").pack()
metre_var = tk.StringVar()
metre_var.trace("w", synchroniser)
metre_entry = tk.Entry(root, textvariable=metre_var)
metre_entry.pack()

# Entrée pour les pieds, en lecture seule
tk.Label(root, text="Pieds:").pack()
pied_var = tk.StringVar()
pied_entry = tk.Entry(root, textvariable=pied_var, state='readonly')
pied_entry.pack()

root.mainloop()

Exemple 8 : `Entry` avec Auto-complétion

Un champ Entry qui propose une auto-complétion à partir d’une liste de mots prédéfinie, facilitant la saisie pour l’utilisateur.

from tkinter import Toplevel, Listbox

def autocompleter(event):
    texte = auto_entry.get()
    if texte == '':
        suggestion_box.place_forget()
    else:
        correspondances = [m for m in mots if m.startswith(texte)]
        if correspondances:
            suggestion_box.delete(0, tk.END)
            for mot in correspondances:
                suggestion_box.insert(tk.END, mot)
            suggestion_box.place(x=auto_entry.winfo_x(), y=auto_entry.winfo_y() + auto_entry.winfo_height())
        else:
            suggestion_box.place_forget()

def choisir_mot(event):
    mot = suggestion_box.get(suggestion_box.curselection())
    auto_entry.delete(0, tk.END)
    auto_entry.insert(0, mot)
    suggestion_box.place_forget()

root = tk.Tk()
root.title("Entry avec Auto-complétion")

mots = ["apple", "banana", "cherry", "date", "fig", "grape", "kiwi"]

auto_entry = tk.Entry(root)
auto_entry.pack()
auto_entry.bind("<KeyRelease>", autocompleter)

suggestion_box = Listbox(root)
suggestion_box.bind("<Double-1>", choisir_mot)

root.mainloop()

Ces exemples illustrent comment étendre les fonctionnalités de base de l’Entry pour répondre à des besoins spécifiques, en intégrant des comportements interactifs et dynamiques.

💡 Bonnes Pratiques et Erreurs à Éviter dans l’Utilisation du Widget `Entry` de Tkinter

Pour garantir une utilisation efficace et sûre du widget Entry dans Tkinter, il est important de connaître certaines pratiques à éviter et de les comparer avec des bonnes pratiques. Voici quelques erreurs courantes accompagnées de leur version corrigée :

Erreur 1 : Manipulation Incorrecte des Variables Tkinter

Mauvais code :

import tkinter as tk

root = tk.Tk()
entry = tk.Entry(root)
entry.pack()

# Mauvaise façon d'obtenir le contenu de l'Entry
print(entry.get())
root.mainloop()

Ce code tente d’accéder à la valeur de l’Entry avant que l’interface ne soit complètement chargée et que l’utilisateur ait eu la chance de saisir quoi que ce soit.

Bon code :

import tkinter as tk

def afficher_contenu():
    # Bonne façon d'obtenir le contenu de l'Entry
    print(entry.get())

root = tk.Tk()
entry = tk.Entry(root)
entry.pack()

# Utilisation d'un bouton pour obtenir le contenu après interaction utilisateur
button = tk.Button(root, text="Afficher", command=afficher_contenu)
button.pack()

root.mainloop()

Dans la version corrigée, la récupération de la valeur se fait via une interaction de l’utilisateur, ce qui garantit que l’Entry a été éventuellement rempli.

Erreur 2 : Ne pas Valider Correctement les Entrées Utilisateur

Mauvais code :

import tkinter as tk

root = tk.Tk()
entry = tk.Entry(root)
entry.pack()

def soumettre():
    # Assume que l'entrée est un nombre sans validation
    valeur = int(entry.get())
    print(valeur)

submit_button = tk.Button(root, text="Soumettre", command=soumettre)
submit_button.pack()
root.mainloop()

Ce code peut échouer si l’utilisateur entre des non-nombres, car il convertit directement le texte en entier sans validation préalable.

Bon code :

import tkinter as tk

root = tk.Tk()
entry = tk.Entry(root)
entry.pack()

def soumettre():
    try:
        # Tente de convertir l'entrée en entier avec gestion d'erreur
        valeur = int(entry.get())
        print(valeur)
    except ValueError:
        print("Veuillez entrer un nombre valide.")

submit_button = tk.Button(root, text="Soumettre", command=soumettre)
submit_button.pack()
root.mainloop()

Dans cette version, la conversion est encadrée par un bloc try-except qui gère les erreurs potentielles, offrant une meilleure robustesse.

Erreur 3 : Utilisation Incorrecte des Variables Liées

Mauvais code :

import tkinter as tk

root = tk.Tk()
var = tk.StringVar()
entry = tk.Entry(root, textvariable=var)
entry.pack()

# Modification incorrecte de la variable liée
var = "Nouveau Texte"
print(var)
root.mainloop()

Ce code échoue à mettre à jour le contenu de l’Entry car il remplace la variable Tkinter par une chaîne de caractères normale.

Bon code :

import tkinter as tk

root = tk.Tk()
var = tk.StringVar()
entry = tk.Entry(root, textvariable=var)
entry.pack()

# Modification correcte de la variable liée
var.set("Nouveau Texte")
print(var.get())
root.mainloop()

Ici, set et get sont utilisés pour interagir correctement avec la variable Tkinter, permettant une mise à jour et une lecture appropriées.

Ces exemples illustrent l’importance de comprendre et de suivre les bonnes pratiques pour éviter des erreurs fréquentes et potentiellement déroutantes dans l’utilisation de Tkinter et de son widget Entry.