Python est un langage de programmation permettant de créer facilement des applications GUI, et parmi ses éléments d’interface utilisateur, la combobox est extrêmement pratique. Cet article explique en détail l’utilisation des combobox en Python, depuis les bases jusqu’aux applications avancées. Des exemples de code concrets et des explications étape par étape sont fournis pour aider même les débutants à comprendre.
Qu’est-ce qu’une combobox ?
Une combobox, également appelée liste déroulante, est un élément d’interface graphique qui permet à l’utilisateur de sélectionner une option parmi une liste de choix. Elle combine un champ de saisie de texte et une liste de sélection, permettant à l’utilisateur soit de choisir une option, soit de saisir du texte directement. Cela simplifie l’entrée des utilisateurs et permet de réduire les erreurs de saisie en limitant les options. En Python, la bibliothèque tkinter est principalement utilisée pour implémenter les combobox.
Comment créer une combobox en Python
Pour créer une combobox en Python, nous utilisons principalement la bibliothèque tkinter. tkinter est un toolkit GUI intégré à Python, permettant de créer facilement des fenêtres et des widgets.
Importation de tkinter et création de la fenêtre
Tout d’abord, nous importons la bibliothèque tkinter et créons une fenêtre.
import tkinter as tk
from tkinter import ttk
# Création de la fenêtre principale
root = tk.Tk()
root.title("Exemple de combobox")
root.geometry("300x200")Création et placement de la combobox
Ensuite, nous utilisons le widget Combobox du module ttk pour créer la combobox et la placer dans la fenêtre.
# Création de la combobox
combo = ttk.Combobox(root, values=["Option 1", "Option 2", "Option 3"])
combo.set("Veuillez sélectionner") # Définir la valeur par défaut
combo.pack(pady=20) # Placement dans la fenêtreDémarrage de la boucle principale
Enfin, nous démarrons la boucle principale pour afficher la fenêtre.
# Démarrage de la boucle principale
root.mainloop()Avec ces étapes, nous avons créé une combobox basique en utilisant tkinter en Python. Passons maintenant à des exemples plus avancés.
Exemple d’implémentation d’une combobox avec tkinter
Voici un exemple spécifique d’implémentation d’une combobox avec tkinter. Dans cet exemple, nous allons créer une application simple où l’utilisateur peut choisir une option parmi une liste de langages de programmation.
Préparation de l’implémentation
Tout d’abord, nous importons les bibliothèques nécessaires et configurons la fenêtre de base.
import tkinter as tk
from tkinter import ttk
# Création de la fenêtre principale
root = tk.Tk()
root.title("Exemple d'implémentation de combobox")
root.geometry("400x300")Création de la combobox
Ensuite, nous créons la combobox et la plaçons dans la fenêtre. Cet exemple propose une liste de langages de programmation.
# Création de la combobox
languages = ["Python", "Java", "C++", "JavaScript", "Ruby"]
combo = ttk.Combobox(root, values=languages)
combo.set("Sélectionnez un langage de programmation")
combo.pack(pady=20)Récupération de l’élément sélectionné
Nous allons maintenant ajouter une fonctionnalité qui récupère et affiche l’option sélectionnée chaque fois que l’utilisateur change de choix dans la combobox.
# Fonction appelée lorsque l'option est modifiée
def on_select(event):
selected_language = combo.get()
label.config(text=f"Langage sélectionné : {selected_language}")
# Lier l'événement de sélection à la fonction
combo.bind("<>", on_select)
# Label pour afficher le résultat
label = tk.Label(root, text="Langage sélectionné : Aucun")
label.pack(pady=10)Exécution de l’application
Nous démarrons enfin la boucle principale pour exécuter l’application.
# Démarrer la boucle principale
root.mainloop()Code complet
Voici le code complet de l’exemple :
import tkinter as tk
from tkinter import ttk
# Création de la fenêtre principale
root = tk.Tk()
root.title("Exemple d'implémentation de combobox")
root.geometry("400x300")
# Création de la combobox
languages = ["Python", "Java", "C++", "JavaScript", "Ruby"]
combo = ttk.Combobox(root, values=languages)
combo.set("Sélectionnez un langage de programmation")
combo.pack(pady=20)
# Fonction appelée lorsque l'option est modifiée
def on_select(event):
selected_language = combo.get()
label.config(text=f"Langage sélectionné : {selected_language}")
# Lier l'événement de sélection à la fonction
combo.bind("<>", on_select)
# Label pour afficher le résultat
label = tk.Label(root, text="Langage sélectionné : Aucun")
label.pack(pady=10)
# Démarrer la boucle principale
root.mainloop()Lorsque vous exécutez ce code, une combobox permettant de sélectionner un langage de programmation s’affichera, et le langage sélectionné sera affiché dans un label.
Traitement des événements dans la combobox
Pour exécuter un traitement spécifique lorsque la sélection de la combobox change, nous devons implémenter un gestionnaire d’événements. tkinter permet de capturer et de traiter ces événements.
Bases du lien d’événements
Pour traiter l’événement de changement de sélection dans la combobox, nous devons lier l’événement « <
import tkinter as tk
from tkinter import ttk
# Création de la fenêtre principale
root = tk.Tk()
root.title("Traitement des événements de combobox")
root.geometry("400x300")
# Création de la combobox
languages = ["Python", "Java", "C++", "JavaScript", "Ruby"]
combo = ttk.Combobox(root, values=languages)
combo.set("Sélectionnez un langage de programmation")
combo.pack(pady=20)
# Fonction appelée lorsque l'option est modifiée
def on_select(event):
selected_language = combo.get()
label.config(text=f"Langage sélectionné : {selected_language}")
# Lier l'événement de sélection à la fonction
combo.bind("<>", on_select)
# Label pour afficher le résultat
label = tk.Label(root, text="Langage sélectionné : Aucun")
label.pack(pady=10)
# Démarrer la boucle principale
root.mainloop()Détails du traitement des événements
Dans le gestionnaire d’événements on_select, nous utilisons combo.get() pour obtenir l’élément sélectionné et afficher le résultat dans un label. Cette méthode permet de modifier dynamiquement le traitement en fonction de la sélection de l’utilisateur.
Autres exemples de traitement
Par exemple, nous pouvons afficher un message différent en fonction du langage sélectionné.
def on_select(event):
selected_language = combo.get()
if selected_language == "Python":
message = "Python est un langage de programmation polyvalent."
elif selected_language == "Java":
message = "Java est un langage utilisé par de nombreuses entreprises."
else:
message = f"Langage sélectionné : {selected_language}"
label.config(text=message)Appeler une fonction lors du changement de sélection
Il est également possible d’exécuter des fonctions complexes en fonction du choix de l’utilisateur.
# Exemple : récupérer et afficher des informations depuis une base de données
def fetch_data(selected_language):
data = {
"Python": "Python est un langage de programmation open-source.",
"Java": "Java est un langage indépendant de la plateforme.",
"C++": "C++ est adapté aux applications performantes.",
"JavaScript": "JavaScript est essentiel pour le développement web.",
"Ruby": "Ruby permet d'écrire un code concis et lisible."
}
return data.get(selected_language, "Aucune information disponible.")
def on_select(event):
selected_language = combo.get()
message = fetch_data(selected_language)
label.config(text=message)Grâce au traitement des événements de la combobox, nous pouvons créer des applications dynamiques qui changent en fonction des choix de l’utilisateur. Passons maintenant à la manière de modifier dynamiquement les éléments de la combobox en réponse aux actions de l’utilisateur.
Ajout et suppression dynamiques d’éléments
Nous pouvons créer des interfaces flexibles en ajoutant ou en supprimant dynamiquement des éléments dans la combobox. Voici comment procéder.
Ajout d’éléments
Voici un exemple où nous ajoutons un nouvel élément à la combobox en fonction de l’entrée de l’utilisateur.
import tkinter as tk
from tkinter import ttk
# Création de la fenêtre principale
root = tk.Tk()
root.title("Ajout et suppression dynamiques d'éléments dans une combobox")
root.geometry("400x300")
# Création de la combobox
languages = ["Python", "Java", "C++", "JavaScript", "Ruby"]
combo = ttk.Combobox(root, values=languages)
combo.set("Sélectionnez un langage de programmation")
combo.pack(pady=20)
# Fonction pour ajouter un nouvel élément
def add_item():
new_item = entry.get()
if new_item and new_item not in combo['values']:
combo['values'] = (*combo['values'], new_item)
entry.delete(0, tk.END)
# Champ de saisie et bouton pour ajouter un élément
entry = tk.Entry(root)
entry.pack(pady=5)
add_button = tk.Button(root, text="Ajouter", command=add_item)
add_button.pack(pady=5)
# Démarrer la boucle principale
root.mainloop()Dans cet exemple, nous récupérons la valeur saisie dans le champ de texte et l’ajoutons à la combobox lorsqu’on clique sur le bouton « Ajouter ».
Suppression d’éléments
Ensuite, nous voyons comment supprimer l’élément sélectionné de la combobox.
# Fonction pour supprimer l'élément sélectionné
def delete_item():
selected_item = combo.get()
current_values = list(combo['values'])
if selected_item in current_values:
current_values.remove(selected_item)
combo['values'] = current_values
combo.set("Sélectionnez un langage de programmation")
# Bouton pour supprimer un élément
delete_button = tk.Button(root, text="Supprimer", command=delete_item)
delete_button.pack(pady=5)Lorsque vous cliquez sur le bouton « Supprimer », l’élément sélectionné est supprimé de la liste de la combobox.
Code complet
Voici le code complet pour l’ajout et la suppression dynamiques d’éléments :
import tkinter as tk
from tkinter import ttk
# Création de la fenêtre principale
root = tk.Tk()
root.title("Ajout et suppression dynamiques d'éléments dans une combobox")
root.geometry("400x300")
# Création de la combobox
languages = ["Python", "Java", "C++", "JavaScript", "Ruby"]
combo = ttk.Combobox(root, values=languages)
combo.set("Sélectionnez un langage de programmation")
combo.pack(pady=20)
# Fonction pour ajouter un nouvel élément
def add_item():
new_item = entry.get()
if new_item and new_item not in combo['values']:
combo['values'] = (*combo['values'], new_item)
entry.delete(0, tk.END)
# Fonction pour supprimer l'élément sélectionné
def delete_item():
selected_item = combo.get()
current_values = list(combo['values'])
if selected_item in current_values:
current_values.remove(selected_item)
combo['values'] = current_values
combo.set("Sélectionnez un langage de programmation")
# Champ de saisie et boutons pour ajouter et supprimer un élément
entry = tk.Entry(root)
entry.pack(pady=5)
add_button = tk.Button(root, text="Ajouter", command=add_item)
add_button.pack(pady=5)
delete_button = tk.Button(root, text="Supprimer", command=delete_item)
delete_button.pack(pady=5)
# Démarrer la boucle principale
root.mainloop()Cette application permet à l’utilisateur d’ajouter de nouveaux éléments ou de supprimer des éléments existants dans la combobox.
Personnalisation et style de la combobox
La personnalisation de l’apparence et du style de la combobox permet d’améliorer l’esthétique de l’application. Nous allons voir comment personnaliser le style de la combobox avec tkinter.
Utilisation des styles ttk
Le module ttk de tkinter propose des classes de style permettant de personnaliser l’apparence des widgets. Voici comment modifier l’apparence d’une combobox.
import tkinter as tk
from tkinter import ttk
# Création de la fenêtre principale
root = tk.Tk()
root.title("Personnalisation de la combobox")
root.geometry("400x300")
# Création du style
style = ttk.Style()
# Configuration de l'apparence de la combobox
style.configure("TCombobox",
background="white",
foreground="black",
fieldbackground="lightblue",
font=("Arial", 12),
bordercolor="blue")
# Création de la combobox avec le style personnalisé
languages = ["Python", "Java", "C++", "JavaScript", "Ruby"]
combo = ttk.Combobox(root, values=languages, style="TCombobox")
combo.set("Sélectionnez un langage de programmation")
combo.pack(pady=20)
# Démarrer la boucle principale
root.mainloop()Dans ce code, nous utilisons ttk.Style pour personnaliser le style de la combobox, en ajustant les couleurs de fond, les polices et la bordure.
Personnalisation à l’aide des options des widgets
Nous pouvons également modifier directement les propriétés des widgets pour personnaliser leur apparence. Voici un exemple où nous ajustons la police et les marges de la combobox.
# Création de la combobox et configuration de sa police et des marges
combo = ttk.Combobox(root, values=languages)
combo.set("Sélectionnez un langage de programmation")
combo.pack(pady=20)
# Configuration de la police
combo.config(font=("Helvetica", 14))
# Configuration des marges
combo.pack(padx=10, pady=10)Modification de la largeur et de la hauteur de la combobox
Nous pouvons également ajuster la largeur et la hauteur de la liste déroulante de la combobox.
# Configuration de la largeur et de la hauteur de la liste déroulante
combo.config(width=30, height=10)Définition de l’état de la combobox
Il est possible de rendre la combobox en lecture seule, permettant à l’utilisateur de sélectionner une option mais pas de saisir du texte.
combo.config(state="readonly")Code complet de la personnalisation
Voici le code complet qui montre la personnalisation de la combobox :
import tkinter as tk
from tkinter import ttk
# Création de la fenêtre principale
root = tk.Tk()
root.title("Personnalisation de la combobox")
root.geometry("400x300")
# Création du style
style = ttk.Style()
style.configure("TCombobox",
background="white",
foreground="black",
fieldbackground="lightblue",
font=("Arial", 12),
bordercolor="blue")
# Création de la combobox avec le style personnalisé
languages = ["Python", "Java", "C++", "JavaScript", "Ruby"]
combo = ttk.Combobox(root, values=languages, style="TCombobox")
combo.set("Sélectionnez un langage de programmation")
combo.pack(pady=20)
# Configuration de la police, des marges, de la largeur, et de l'état
combo.config(font=("Helvetica", 14), width=30, state="readonly")
# Démarrer la boucle principale
root.mainloop()Ce code montre comment personnaliser le style d’une combobox pour la rendre plus agréable et plus facile à utiliser.
Exemple d’application : Utilisation de la combobox dans un formulaire
Les combobox sont très utiles dans les formulaires, car elles permettent aux utilisateurs de choisir facilement parmi plusieurs options. Voici un exemple d’utilisation d’une combobox dans un formulaire d’inscription utilisateur.
Création d’un formulaire d’inscription simple
Dans cet exemple, nous ajoutons une combobox pour que l’utilisateur puisse choisir son sexe et son pays.
import tkinter as tk
from tkinter import ttk
# Création de la fenêtre principale
root = tk.Tk()
root.title("Formulaire d'inscription utilisateur")
root.geometry("400x400")
# Création des champs de texte
tk.Label(root, text="Nom :").pack(pady=5)
name_entry = tk.Entry(root)
name_entry.pack(pady=5)
tk.Label(root, text="Email :").pack(pady=5)
email_entry = tk.Entry(root)
email_entry.pack(pady=5)
# Combobox pour choisir le sexe
tk.Label(root, text="Sexe :").pack(pady=5)
gender_combo = ttk.Combobox(root, values=["Homme", "Femme", "Autre"])
gender_combo.set("
Sélectionner")
gender_combo.pack(pady=5)
# Combobox pour choisir le pays
tk.Label(root, text="Pays :").pack(pady=5)
country_combo = ttk.Combobox(root, values=["Japon", "États-Unis", "Royaume-Uni", "Canada", "Australie"])
country_combo.set("Sélectionner")
country_combo.pack(pady=5)
# Fonction d'enregistrement
def register():
name = name_entry.get()
email = email_entry.get()
gender = gender_combo.get()
country = country_combo.get()
print(f"Nom : {name}\nEmail : {email}\nSexe : {gender}\nPays : {country}")
tk.Button(root, text="S'inscrire", command=register).pack(pady=20)
# Démarrer la boucle principale
root.mainloop()Traitement et affichage des informations de l’utilisateur
Ce code crée un formulaire dans lequel l’utilisateur peut saisir son nom, son email, choisir son sexe et son pays. La fonction register permet de récupérer les informations et de les afficher.
Exemple d’application : Modification dynamique des options de la combobox
Dans cet exemple, les options de la combobox changent en fonction du pays sélectionné, par exemple en affichant différentes villes selon le pays choisi.
# Combobox pour choisir la ville
tk.Label(root, text="Ville :").pack(pady=5)
city_combo = ttk.Combobox(root)
city_combo.set("Sélectionner")
city_combo.pack(pady=5)
# Fonction pour mettre à jour les villes en fonction du pays
def update_cities(event):
country = country_combo.get()
if country == "Japon":
city_combo['values'] = ["Tokyo", "Osaka", "Nagoya"]
elif country == "États-Unis":
city_combo['values'] = ["New York", "Los Angeles", "Chicago"]
elif country == "Royaume-Uni":
city_combo['values'] = ["Londres", "Manchester", "Birmingham"]
elif country == "Canada":
city_combo['values'] = ["Toronto", "Vancouver", "Montréal"]
elif country == "Australie":
city_combo['values'] = ["Sydney", "Melbourne", "Brisbane"]
else:
city_combo['values'] = []
# Lier l'événement de sélection du pays à la fonction
country_combo.bind("<>", update_cities)Lorsque l’utilisateur choisit un pays, la liste des villes proposées dans la combobox change en fonction du pays sélectionné.
Code complet
Voici le code complet de l’exemple d’application avec modification dynamique des éléments de la combobox :
import tkinter as tk
from tkinter import ttk
# Création de la fenêtre principale
root = tk.Tk()
root.title("Formulaire d'inscription utilisateur")
root.geometry("400x400")
# Création des champs de texte
tk.Label(root, text="Nom :").pack(pady=5)
name_entry = tk.Entry(root)
name_entry.pack(pady=5)
tk.Label(root, text="Email :").pack(pady=5)
email_entry = tk.Entry(root)
email_entry.pack(pady=5)
# Combobox pour choisir le sexe
tk.Label(root, text="Sexe :").pack(pady=5)
gender_combo = ttk.Combobox(root, values=["Homme", "Femme", "Autre"])
gender_combo.set("Sélectionner")
gender_combo.pack(pady=5)
# Combobox pour choisir le pays
tk.Label(root, text="Pays :").pack(pady=5)
country_combo = ttk.Combobox(root, values=["Japon", "États-Unis", "Royaume-Uni", "Canada", "Australie"])
country_combo.set("Sélectionner")
country_combo.pack(pady=5)
# Combobox pour choisir la ville
tk.Label(root, text="Ville :").pack(pady=5)
city_combo = ttk.Combobox(root)
city_combo.set("Sélectionner")
city_combo.pack(pady=5)
# Fonction pour mettre à jour les villes en fonction du pays
def update_cities(event):
country = country_combo.get()
if country == "Japon":
city_combo['values'] = ["Tokyo", "Osaka", "Nagoya"]
elif country == "États-Unis":
city_combo['values'] = ["New York", "Los Angeles", "Chicago"]
elif country == "Royaume-Uni":
city_combo['values'] = ["Londres", "Manchester", "Birmingham"]
elif country == "Canada":
city_combo['values'] = ["Toronto", "Vancouver", "Montréal"]
elif country == "Australie":
city_combo['values'] = ["Sydney", "Melbourne", "Brisbane"]
else:
city_combo['values'] = []
# Lier l'événement de sélection du pays à la fonction
country_combo.bind("<>", update_cities)
# Fonction d'enregistrement
def register():
name = name_entry.get()
email = email_entry.get()
gender = gender_combo.get()
country = country_combo.get()
city = city_combo.get()
print(f"Nom : {name}\nEmail : {email}\nSexe : {gender}\nPays : {country}\nVille : {city}")
tk.Button(root, text="S'inscrire", command=register).pack(pady=20)
# Démarrer la boucle principale
root.mainloop()Ce code affiche un formulaire d’inscription dans lequel les utilisateurs peuvent sélectionner un pays et voir une liste de villes qui change dynamiquement en fonction du pays choisi.
Gestion des erreurs et débogage
Lorsque vous travaillez avec des combobox, il est important de gérer les erreurs possibles et de déboguer votre code. Voici comment traiter les erreurs courantes et déboguer votre programme.
Erreurs courantes et solutions
Les erreurs courantes lors de l’utilisation de la combobox incluent la sélection invalide, les erreurs lors de la récupération des valeurs, et les erreurs de liaison des événements. Voici des solutions pour chaque cas.
Erreur de sélection invalide
Une erreur peut se produire lorsque l’utilisateur sélectionne une valeur invalide. Pour éviter cela, vérifiez si la sélection est présente dans la liste des options disponibles.
def validate_selection():
selected_value = combo.get()
if selected_value not in combo['values']:
error_label.config(text="Sélection invalide. Veuillez choisir une option correcte.")
else:
error_label.config(text="")Affichage d’un message d’erreur
error_label = tk.Label(root, text="", fg="red")
error_label.pack(pady=5)Ajout de la validation au bouton d’inscription
def register():
validate_selection()
if error_label.cget("text") == "":
name = name_entry.get()
email = email_entry.get()
gender = gender_combo.get()
country = country_combo.get()
city = city_combo.get()
print(f"Nom : {name}\nEmail : {email}\nSexe : {gender}\nPays : {country}\nVille : {city}")
tk.Button(root, text="S'inscrire", command=register).pack(pady=20)Erreur de récupération des valeurs
Cette erreur se produit lorsque la valeur n’est pas sélectionnée ou lorsque l’entrée est vide. Pour y remédier, vérifiez que la valeur existe avant de l’utiliser.
def on_select(event):
selected_value = combo.get()
if selected_value:
label.config(text=f"Langage sélectionné : {selected_value}")
else:
label.config(text="Veuillez sélectionner une option.") Erreur de liaison d’événements
Une erreur peut survenir si l’événement n’est pas correctement lié. Assurez-vous que le nom de l’événement est correct et que la liaison fonctionne correctement.
# Utilisation du bon nom d'événement pour la liaison
combo.bind("<>", on_select)Conseils pour le débogage
Le débogage est une étape cruciale pour identifier et corriger les erreurs dans votre code. Voici quelques conseils pour déboguer efficacement votre application.
Ajout de journaux
En ajoutant des journaux dans votre code, vous pouvez suivre l’exécution et identifier les erreurs plus facilement.
import logging
# Configuration du journal
logging.basicConfig(level=logging.DEBUG)
def on_select(event):
selected_value = combo.get()
logging.debug(f"Valeur sélectionnée : {selected_value}")
label.config(text=f"Langage sélectionné : {selected_value}")
combo.bind("<>", on_select)Ajout de gestion des exceptions
Utilisez la gestion des exceptions pour capturer et gérer les erreurs imprévues.
def register():
try:
validate_selection()
if error_label.cget("text") == "":
name = name_entry.get()
email = email_entry.get()
gender = gender_combo.get()
country = country_combo.get()
city = city_combo.get()
print(f"Nom : {name}\nEmail : {email}\nSexe : {gender}\nPays : {country}\nVille : {city}")
except Exception as e:
logging.error(f"Une erreur est survenue : {e}")
tk.Button(root, text="S'inscrire", command=register).pack(pady=20)Code complet avec gestion des erreurs et débogage
Voici le code complet intégrant la gestion des erreurs et le débogage.
import tkinter as tk
from tkinter import ttk
import logging
# Création de la fenêtre principale
root = tk.Tk()
root.title("Formulaire d'inscription utilisateur")
root.geometry("400x400")
# Configuration du journal
logging.basicConfig(level=logging.DEBUG)
# Création des champs de texte
tk.Label(root, text="Nom :").pack(pady=5)
name_entry = tk.Entry(root)
name_entry.pack(pady=5)
tk.Label(root, text="Email :").pack(pady=5)
email_entry = tk.Entry(root)
email_entry.pack(pady=5)
# Combobox pour choisir le sexe
tk.Label(root, text="Sexe :").pack(pady=5)
gender_combo = ttk.Combobox(root, values=["Homme", "Femme", "Autre"])
gender_combo.set("Sélectionner")
gender_combo.pack(pady=5)
# Combobox pour choisir le pays
tk.Label(root, text="Pays :").pack(pady=5)
country_combo = ttk.Combobox(root, values=["Japon", "États-Unis", "Royaume-Uni", "Canada", "Australie"])
country_combo.set("Sélectionner")
country_combo.pack(pady=5)
# Combobox pour choisir la ville
tk.Label(root, text="Ville :").pack(pady=5)
city_combo = ttk.Combobox(root)
city_combo.set("Sélectionner")
city_combo.pack(pady=5)
# Fonction pour mettre à jour les villes en fonction du pays
def update_cities(event):
country = country_combo.get()
if country == "Japon":
city_combo['values'] = ["Tokyo", "Osaka", "Nagoya"]
elif country == "États-Unis":
city_combo['values'] = ["New York", "Los Angeles", "Chicago"]
elif country == "Royaume-Uni":
city_combo['values'] = ["Londres", "Manchester", "Birmingham"]
elif country == "Canada":
city_combo['values'] = ["Toronto", "Vancouver", "Montréal"]
elif country == "Australie":
city_combo['values'] = ["Sydney", "Melbourne", "Brisbane"]
else:
city_combo['values'] = []
# Lier l'événement de sélection du pays à la fonction
country_combo.bind("<>", update_cities)
# Afficher un message d'erreur si nécessaire
error_label = tk.Label(root, text="", fg="red")
error_label.pack(pady=5)
# Ajouter un élément dans la combobox
def add_item():
new_item = entry.get()
if new_item and new_item not in combo['values']:
combo['values'] = (*combo['values'], new_item)
entry.delete(0, tk.END)
# Supprimer l'élément sélectionné
def delete_item():
selected_item = combo.get()
current_values = list(combo['values'])
if selected_item in current_values:
current_values.remove(selected_item)
combo['values'] = current_values
combo.set("Sélectionnez un langage de programmation")
# Gérer l'option sélectionnée
def on_select(event):
selected_value = combo.get()
logging.debug(f"Valeur sélectionnée : {selected_value}")
if selected_value:
label.config(text=f"Langage sélectionné : {selected_value}")
else:
label.config(text="Veuillez sélectionner une option.")
combo.bind("<>", on_select)
# Création de la combobox
languages = ["Python", "Java", "C++", "JavaScript", "Ruby"]
combo = ttk.Combobox(root, values=languages, style="TCombobox")
combo.set("Sélectionnez un langage de programmation")
combo.pack(pady=20)
# Entrée pour un nouvel élément et bouton pour l'ajouter
entry = tk.Entry(root)
entry.pack(pady=5)
add_button = tk.Button(root, text="Ajouter", command=add_item)
add_button.pack(pady=5)
# Bouton pour supprimer un élément
delete_button = tk.Button(root, text="Supprimer", command=delete_item)
delete_button.pack(pady=5)
# Valider l'entrée et s'inscrire
def register():
try:
validate_selection()
if error_label.cget("text") == "":
name = name_entry.get()
email = email_entry.get()
gender = gender_combo.get()
country = country_combo.get()
city = city_combo.get()
print(f"Nom : {name}\nEmail : {email}\nSexe : {gender}\nPays : {country}\nVille : {city}")
except Exception as e:
logging.error(f"Une erreur est survenue : {e}")
tk.Button(root, text="S'inscrire", command=register).pack(pady=20)
# Démarrer la boucle principale
root.mainloop()Ce code améliore la stabilité de l’application en ajoutant des validations d’entrée et un suivi des erreurs.
Conclusion
Dans cet article, nous avons expliqué en détail comment utiliser la combobox en Python pour gérer les choix de l’utilisateur, depuis la création de base jusqu’aux applications avancées. Nous avons exploré comment personnaliser son apparence, gérer les événements, ajouter et supprimer dynamiquement des éléments, et gérer les erreurs pour rendre l’application plus stable et facile à utiliser. La combobox est un outil puissant pour gérer efficacement les entrées utilisateur, et avec les bonnes pratiques, elle peut être utilisée dans une variété de projets. Essayez de l’intégrer dans vos propres applications !