La méthode join en Python est un outil puissant pour...
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.
EntryPour 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()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.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()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()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 :
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()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()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.
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()EntryDeux 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()Entry avec Auto-complétionUn 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.
Entry de TkinterPour 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 :
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.
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.
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.
Ce guide explore les nombreux usages des verbes pronominaux passifs, offrant une classification claire et…
Dans le monde dynamique et compétitif des affaires, le suivi des achats joue un rôle…
Cet article détaillé explore la formule de Wilson, son fonctionnement, ses avantages et ses limites.…
L'intérêt composé est un concept fondamental en finance, qui permet de calculer les intérêts en…
Le commentaire composé est un exercice littéraire qui consiste à analyser un texte en respectant…
Les adjectifs liés en français sont les adjectifs qui s’accordent en genre (masculin/féminin) et en…
This website uses cookies.