Comment contrôler les entrées numériques avec un widget Spinbox en Python

Tkinter est la bibliothèque standard de Python pour l’interface graphique, et elle propose divers widgets. Parmi eux, le Spinbox est un widget très pratique lorsqu’il s’agit de restreindre les entrées de nombres ou de chaînes. Cet article explique en détail les bases de l’utilisation du Spinbox, des exemples d’application, ainsi que les méthodes permettant de contrôler les entrées. L’utilisation du Spinbox permet de contrôler facilement les valeurs que l’utilisateur peut entrer, ce qui aide à créer des applications sécurisées et efficaces.

Utilisation de base du Spinbox

Le Spinbox (boîte à valeurs) est un widget fourni par Tkinter qui permet à l’utilisateur de sélectionner ou d’entrer une valeur dans une plage définie. Voici un exemple de son utilisation de base.

Créer un Spinbox

Le Spinbox est créé en utilisant la classe Spinbox. Voici un exemple de code pour afficher un Spinbox simple.

import tkinter as tk

# Créer une fenêtre Tkinter
root = tk.Tk()
root.title("Exemple de base du Spinbox")

# Créer un Spinbox
spinbox = tk.Spinbox(root, from_=0, to=10)
spinbox.pack()

# Démarrer la boucle principale
root.mainloop()

Explication du code

1. Méthode pack()
• Elle est utilisée pour placer le Spinbox dans la fenêtre.

Vérification du comportement


Lorsque vous exécutez le code ci-dessus, un Spinbox avec les valeurs de 0 à 10 s’affiche, et l’utilisateur peut sélectionner une valeur en utilisant les boutons fléchés.

Dans la section suivante, nous expliquons comment définir de manière plus précise la plage des valeurs que l’utilisateur peut entrer dans le Spinbox.

Définir une plage de valeurs numériques


Le Spinbox vous permet de spécifier la plage des valeurs que l’utilisateur peut entrer. Une configuration appropriée de cette plage peut éviter l’entrée de valeurs inattendues et permettre une saisie de données sûre et efficace.

Plage définie avec from_ et to


En utilisant les options from_ et to, vous pouvez définir la valeur minimale et maximale que l’utilisateur peut saisir dans le Spinbox.

import tkinter as tk

# Créer une fenêtre Tkinter
root = tk.Tk()
root.title("Définition de la plage de valeurs")

# Créer un Spinbox (plage de 1 à 100)
spinbox = tk.Spinbox(root, from_=1, to=100)
spinbox.pack()

# Démarrer la boucle principale
root.mainloop()

Dans cet exemple, seules les valeurs de 1 à 100 peuvent être saisies. Si vous tentez d’entrer une valeur en dehors de cette plage, le Spinbox ne l’acceptera pas.

Définir la taille de l’incrément


L’option increment permet de définir l’intervalle de changement de la valeur lorsque le Spinbox est ajusté.

spinbox = tk.Spinbox(root, from_=0, to=50, increment=5)

Avec cette configuration, les valeurs du Spinbox varient de 0 à 50 par pas de 5 (0, 5, 10, …).

Spécifier des valeurs à partir d’une liste


Si vous souhaitez autoriser uniquement certaines valeurs, vous pouvez définir une liste à l’aide de l’option values.

spinbox = tk.Spinbox(root, values=(10, 20, 30, 40, 50))

Dans cet exemple, seules les valeurs 10, 20, 30, 40, 50 peuvent être sélectionnées.

Changer dynamiquement la plage


La plage et les valeurs du Spinbox peuvent être modifiées dynamiquement dans votre programme. Voici un exemple de modification dynamique de la plage.

def update_range():
    spinbox.config(from_=50, to=200)

button = tk.Button(root, text="Changer la plage", command=update_range)
button.pack()

Avec la méthode config, vous pouvez facilement changer les propriétés du Spinbox.

Dans la section suivante, nous expliquerons comment valider les valeurs en temps réel dans un Spinbox.

Valider les entrées à l’aide d’une fonction de rappel


Valider les valeurs saisies dans un Spinbox en temps réel permet d’éviter les erreurs et de créer des applications plus sûres et robustes. Tkinter permet d’utiliser des fonctions de rappel pour effectuer cette validation.

Enregistrer une fonction de rappel


Pour enregistrer une fonction de rappel qui sera appelée lorsque la valeur du Spinbox change, utilisez l’option command.

import tkinter as tk

# Fonction de rappel
def on_value_change():
    value = spinbox.get()
    print(f"Valeur actuelle: {value}")

# Créer une fenêtre Tkinter
root = tk.Tk()
root.title("Exemple de fonction de rappel")

# Créer un Spinbox
spinbox = tk.Spinbox(root, from_=0, to=10, command=on_value_change)
spinbox.pack()

# Démarrer la boucle principale
root.mainloop()

Dans ce code, chaque fois que la valeur du Spinbox change, la fonction on_value_change est appelée et la valeur actuelle est affichée.

Ajouter une validation des valeurs


Pour vérifier que l’entrée du Spinbox respecte certains critères, vous pouvez analyser la valeur obtenue et effectuer une vérification.

def validate_value():
    value = int(spinbox.get())
    if value % 2 == 0:
        print(f"{value} est pair.")
    else:
        print(f"{value} est impair.")

En enregistrant cette fonction dans l’option command, chaque fois que la valeur du Spinbox change, elle sera validée.

Utiliser validate et validatecommand


Pour des validations plus strictes, vous pouvez combiner les options validate et validatecommand.

def validate_input(value):
    return value.isdigit() and 0 <= int(value) <= 10

# Enregistrer la commande de validation Tkinter
vcmd = root.register(validate_input)

spinbox = tk.Spinbox(root, from_=0, to=10, validate="key", validatecommand=(vcmd, '%P'))
spinbox.pack()

Points clés du code

• validate="key" : Effectue la validation lors de la saisie au clavier.
• validatecommand : Spécifie la fonction utilisée pour valider les valeurs.
• '%P' : Passe la saisie actuelle à la fonction de validation.

Dans cet exemple, la validation empêche l’entrée de valeurs en dehors de la plage de 0 à 10.

Afficher un message d’erreur


Voici un exemple d’affichage d’un message d’erreur lorsque la valeur saisie ne correspond pas aux critères.

def validate_and_alert(value):
    if not value.isdigit() or not (0 <= int(value) <= 10):
        error_label.config(text="Veuillez entrer une valeur entre 0 et 10")
        return False
    error_label.config(text="")
    return True

vcmd = root.register(validate_and_alert)

spinbox = tk.Spinbox(root, from_=0, to=10, validate="key", validatecommand=(vcmd, '%P'))
spinbox.pack()

error_label = tk.Label(root, text="", fg="red")
error_label.pack()

Dans cet exemple, toute entrée invalide est bloquée, et un message d’erreur s’affiche immédiatement pour informer l’utilisateur.

Dans la section suivante, nous expliquerons comment restreindre l’entrée à des nombres à virgule flottante ou à des valeurs spécifiques.

Restreindre les entrées à des nombres à virgule flottante ou à des valeurs spécifiques


Par défaut, le Spinbox gère uniquement les nombres entiers, mais vous pouvez configurer celui-ci pour accepter des valeurs à virgule flottante ou des valeurs spécifiques. Cela permet une gestion plus flexible des entrées en fonction des besoins.

Permettre les nombres à virgule flottante


Pour permettre l’entrée de nombres à virgule flottante, vous pouvez utiliser l’option values et fournir une liste des valeurs autorisées.

import tkinter as tk

# Créer une fenêtre Tkinter
root = tk.Tk()
root.title("Contrôle des nombres flottants")

# Liste de nombres flottants
decimal_values = [x / 10 for x in range(0, 101)]  # 0.0 à 10.0

# Créer un Spinbox
spinbox = tk.Spinbox(root, values=decimal_values)
spinbox.pack()

# Démarrer la boucle principale
root.mainloop()

Dans cet exemple, seules les valeurs décimales entre 0.0 et 10.0 sont acceptées (0.0, 0.1, 0.2, …, 10.0).

Autoriser les nombres flottants avec une valeur d’incrément


En utilisant les options from_, to et increment, vous pouvez gérer les pas de changement dans le Spinbox et autoriser les nombres à virgule flottante.

spinbox = tk.Spinbox(root, from_=0, to=10, increment=0.1)
spinbox.pack()

Avec cette configuration, les valeurs du Spinbox peuvent varier de 0.0 à 10.0 par pas de 0.1.

Restreindre à des valeurs spécifiques


Si vous souhaitez permettre seulement des valeurs spécifiques, utilisez l’option values pour les spécifier.

spinbox = tk.Spinbox(root, values=(1.5, 2.5, 3.5, 4.5))
spinbox.pack()

Dans cet exemple, seules les valeurs 1.5, 2.5, 3.5 et 4.5 peuvent être sélectionnées.

Combinaison flexible de validation


Pour restreindre le nombre de décimales ou permettre uniquement des valeurs respectant certaines conditions, vous pouvez combiner l’option validate avec validatecommand.

def validate_float(value):
    try:
        # Vérifier si l'entrée est un nombre à virgule flottante et dans la plage
        float_value = float(value)
        return 0.0 <= float_value <= 10.0
    except ValueError:
        return False

vcmd = root.register(validate_float)

spinbox = tk.Spinbox(root, from_=0, to=10, validate="key", validatecommand=(vcmd, '%P'))
spinbox.pack()

Ce code permet uniquement l’entrée de nombres à virgule flottante valides entre 0.0 et 10.0.

Forcer un format d’entrée spécifique


Pour limiter le nombre de chiffres après la virgule, vous pouvez utiliser une fonction de rappel pour formater l’entrée.

def format_input():
    value = spinbox.get()
    try:
        formatted_value = f"{float(value):.2f}"  # Formater à 2 décimales
        spinbox.delete(0, tk.END)
        spinbox.insert(0, formatted_value)
    except ValueError:
        pass

spinbox = tk.Spinbox(root, from_=0, to=10, increment=0.01, command=format_input)
spinbox.pack()

Ce code applique un formatage à deux décimales chaque fois que la valeur du Spinbox change.

La section suivante explique comment manipuler la valeur du Spinbox avec un bouton.

Manipuler la valeur du Spinbox avec un bouton


Manipuler dynamiquement la valeur du Spinbox dans le programme peut améliorer l’expérience utilisateur et être utile dans certains scénarios. En utilisant des boutons, vous pouvez changer la valeur sans interaction directe de l’utilisateur.

Obtenir la valeur du Spinbox


Pour obtenir la valeur actuelle du Spinbox, utilisez la méthode get.

def get_value():
    value = spinbox.get()
    print(f"Valeur actuelle: {value}")

button_get = tk.Button(root, text="Obtenir la valeur", command=get_value)
button_get.pack()

Ce code récupère la valeur du Spinbox lorsqu’on clique sur le bouton « Obtenir la valeur » et l’affiche dans la console.

Définir la valeur du Spinbox


Vous pouvez modifier la valeur du Spinbox en utilisant les méthodes delete et insert.

def set_value(new_value):
    spinbox.delete(0, tk.END)
    spinbox.insert(0, new_value)

button_set = tk.Button(root, text="Définir la valeur", command=lambda: set_value(5))
button_set.pack()

Ce code définit la valeur du Spinbox à 5 lorsqu’on clique sur le bouton « Définir la valeur ».

Créer des boutons d’incrémentation et de décrémentation


Pour augmenter ou diminuer la valeur du Spinbox avec un bouton, vous pouvez obtenir la valeur actuelle, effectuer un calcul, puis mettre à jour la valeur.

def increment():
    value = int(spinbox.get())
    spinbox.delete(0, tk.END)
    spinbox.insert(0, value + 1)

def decrement():
    value = int(spinbox.get())
    spinbox.delete(0, tk.END)
    spinbox.insert(0, value - 1)

button_increment = tk.Button(root, text="Augmenter", command=increment)
button_increment.pack()

button_decrement = tk.Button(root, text="Diminuer", command=decrement)
button_decrement.pack()

Dans ce code, le bouton « Augmenter » ajoute 1 à la valeur du Spinbox, et le bouton « Diminuer » soustrait 1.

Implémentation avec des limites de plage


Assurez-vous que la valeur du Spinbox ne dépasse pas les limites de la plage spécifiée en utilisant les options from_ et to.

def increment_safe():
    value = int(spinbox.get())
    if value < 10:  # Vérifier la limite supérieure
        spinbox.delete(0, tk.END)
        spinbox.insert(0, value + 1)

def decrement_safe():
    value = int(spinbox.get())
    if value > 0:  # Vérifier la limite inférieure
        spinbox.delete(0, tk.END)
        spinbox.insert(0, value - 1)

button_increment_safe = tk.Button(root, text="Augmenter en toute sécurité", command=increment_safe)
button_increment_safe.pack()

button_decrement_safe = tk.Button(root, text="Diminuer en toute sécurité", command=decrement_safe)
button_decrement_safe.pack()

Cette implémentation empêche le Spinbox d’afficher des valeurs en dehors de la plage définie.

Exemple avancé : Réinitialisation à la valeur par défaut


Vous pouvez ajouter une fonctionnalité pour réinitialiser la valeur du Spinbox à une valeur par défaut dans certaines conditions.

def reset_value():
    spinbox.delete(0, tk.END)
    spinbox.insert(0, 0)

button_reset = tk.Button(root, text="Réinitialiser", command=reset_value)
button_reset.pack()

Ce code réinitialise la valeur du Spinbox à 0 lorsque le bouton « Réinitialiser » est cliqué.

La section suivante montre comment utiliser le Spinbox dans des formulaires d’entrée.

Exemple d’application : Utilisation dans un formulaire


Le Spinbox peut être très utile pour permettre à l’utilisateur de saisir des nombres ou de choisir parmi certaines options dans un formulaire. Cette section présente quelques exemples pratiques d’utilisation du Spinbox dans des formulaires.

Exemple : Formulaire d’entrée de l’âge


Créons un formulaire où l’utilisateur peut saisir son âge à l’aide d’un Spinbox.

import tkinter as tk

# Créer une fenêtre Tkinter
root = tk.Tk()
root.title("Formulaire d'âge")

# Créer un Spinbox pour l'âge
tk.Label(root, text="Veuillez entrer votre âge :").pack()
age_spinbox = tk.Spinbox(root, from_=0, to=120)
age_spinbox.pack()

# Soumettre le formulaire
def submit_form():
    age = age_spinbox.get()
    result_label.config(text=f"Âge saisi : {age}")

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

# Étiquette pour afficher le résultat
result_label = tk.Label(root, text="")
result_label.pack()

# Démarrer la boucle principale
root.mainloop()

Ce code permet à l’utilisateur de saisir son âge avec le Spinbox et d’afficher l’âge saisi lorsqu’il clique sur le bouton « Soumettre ».

Exemple : Utilisation dans un formulaire de réservation


Nous pouvons également utiliser le Spinbox pour spécifier le nombre de personnes pour une réservation ou l’heure de réservation.

# Créer une fenêtre Tkinter
root = tk.Tk()
root.title("Formulaire de réservation")

# Spinbox pour le nombre de personnes
tk.Label(root, text="Nombre de personnes :").pack()
guest_spinbox = tk.Spinbox(root, from_=1, to=20)
guest_spinbox.pack()

# Spinbox pour l'heure de réservation
tk.Label(root, text="Heure de réservation :").pack()
time_spinbox = tk.Spinbox(root, values=("12:00", "13:00", "14:00", "15:00", "16:00"))
time_spinbox.pack()

# Soumettre la réservation
def submit_reservation():
    guests = guest_spinbox.get()
    time = time_spinbox.get()
    result_label.config(text=f"Nombre de personnes : {guests}, Heure : {time}")

submit_button = tk.Button(root, text="Soumettre la réservation", command=submit_reservation)
submit_button.pack()

# Étiquette pour afficher le résultat
result_label = tk.Label(root, text="")
result_label.pack()

# Démarrer la boucle principale
root.mainloop()

Ce formulaire permet à l’utilisateur de spécifier le nombre de personnes pour la réservation ainsi que l’heure de la réservation.

Exemple : Combinaison de plusieurs Spinbox


Il est possible de combiner plusieurs Spinbox pour des formulaires plus complexes, comme dans l’exemple suivant pour saisir une date.

# Créer des Spinbox pour la date
tk.Label(root, text="Année :").pack()
year_spinbox = tk.Spinbox(root, from_=2000, to=2100)
year_spinbox.pack()

tk.Label(root, text="Mois :").pack()
month_spinbox = tk.Spinbox(root, from_=1, to=12)
month_spinbox.pack()

tk.Label(root, text="Jour :").pack()
day_spinbox = tk.Spinbox(root, from_=1, to=31)
day_spinbox.pack()

# Soumettre la date
def submit_date():
    year = year_spinbox.get()
    month = month_spinbox.get()
    day = day_spinbox.get()
    result_label.config(text=f"Date saisie : {year}-{month}-{day}")

submit_button = tk.Button(root, text="Soumettre la date", command=submit_date)
submit_button.pack()

Dans cet exemple, l’utilisateur peut sélectionner l’année, le mois et le jour via plusieurs Spinbox.

Améliorer le design des formulaires


Voici quelques astuces pour rendre vos formulaires plus conviviaux en utilisant les Spinbox.

• Disposition des étiquettes : Organisez les étiquettes pour que l’utilisateur puisse facilement comprendre ce qui est demandé.
• Valeurs par défaut : Pour réduire les choix de l’utilisateur, définissez des valeurs par défaut utiles.
• Messages d’erreur : Ajoutez des messages d’erreur pour informer l’utilisateur en cas d’entrée incorrecte.

La prochaine section aborde comment personnaliser les Spinbox.

Personnalisation des Spinbox


Les Spinbox peuvent être personnalisés pour correspondre à l’apparence et au comportement de votre application. Cette section montre comment personnaliser l’apparence et le comportement d’un Spinbox.

Changer la police et les couleurs


Pour changer la police du texte, ainsi que les couleurs de fond et de premier plan, utilisez les options font, bg (couleur de fond) et fg (couleur du texte).

import tkinter as tk

# Créer une fenêtre Tkinter
root = tk.Tk()
root.title("Personnalisation du Spinbox")

# Créer un Spinbox avec police et couleurs modifiées
spinbox = tk.Spinbox(
    root,
    from_=0,
    to=10,
    font=("Helvetica", 16),  # Police et taille
    bg="lightblue",         # Couleur de fond
    fg="darkblue"           # Couleur du texte
)
spinbox.pack()

# Démarrer la boucle principale
root.mainloop()

Ce code définit la police à Helvetica de taille 16, le fond en bleu clair et le texte en bleu foncé.

Personnaliser les boutons du Spinbox


Il est difficile de changer directement les boutons de flèche du Spinbox, mais vous pouvez masquer les flèches et ajouter des boutons personnalisés.

def increment():
    value = int(spinbox.get())
    spinbox.delete(0, tk.END)
    spinbox.insert(0, value + 1)

def decrement():
    value = int(spinbox.get())
    spinbox.delete(0, tk.END)
    spinbox.insert(0, value - 1)

spinbox = tk.Spinbox(root, from_=0, to=10, state="readonly")  # Définir en lecture seule
spinbox.pack()

button_up = tk.Button(root, text="▲", command=increment)
button_up.pack()

button_down = tk.Button(root, text="▼", command=decrement)
button_down.pack()

Dans cet exemple, le Spinbox est en mode « lecture seule », et les boutons personnalisés permettent d’ajuster la valeur.

Ajuster la largeur et la disposition


Vous pouvez ajuster la largeur du Spinbox en utilisant l’option width, qui mesure la largeur en nombre de caractères.

spinbox = tk.Spinbox(root, from_=0, to=10, width=10)
spinbox.pack(padx=10, pady=10)  # Ajouter de l'espace autour du Spinbox

Vous pouvez également utiliser les options de la méthode pack pour disposer le Spinbox de manière appropriée dans la fenêtre.

Changer la valeur avec la molette de la souris


Il est possible de personnaliser le comportement du Spinbox pour changer la valeur à l’aide de la molette de la souris.

def scroll(event):
    value = int(spinbox.get())
    if event.delta > 0:  # Défilement vers le haut
        spinbox.delete(0, tk.END)
        spinbox.insert(0, value + 1)
    elif event.delta < 0:  # Défilement vers le bas
        spinbox.delete(0, tk.END)
        spinbox.insert(0, value - 1)

spinbox.bind("<MouseWheel>", scroll)

Ce code permet de changer la valeur du Spinbox en utilisant la molette de la souris.

Ajouter un tooltip


Vous pouvez ajouter un tooltip (infobulle) au Spinbox pour expliquer son utilisation à l’utilisateur.

def show_tooltip(event):
    tooltip_label.place(x=event.x_root, y=event.y_root)

def hide_tooltip(event):
    tooltip_label.place_forget()

tooltip_label = tk.Label(root, text="Veuillez sélectionner une valeur", bg="yellow", relief="solid")
spinbox.bind("<Enter>", show_tooltip)
spinbox.bind("<Leave>", hide_tooltip)

Ce code affiche un tooltip lorsque le curseur survole le Spinbox et le cache lorsqu’il en sort.

Résumé

• Changer la police et les couleurs : Utilisez font, bg, fg pour personnaliser le design.
• Utiliser des boutons personnalisés : Masquez les flèches par défaut et utilisez des boutons personnalisés.
• Disposition et largeur : Ajustez le design avec width et pack.
• Ajouter des interactions : Utilisez la molette de la souris ou un tooltip.

La section suivante explique les problèmes et erreurs courants avec le Spinbox.

Dépannage et points à surveiller


Il est possible que des erreurs ou des comportements inattendus surviennent si le Spinbox n’est pas correctement configuré. Cette section explique certains problèmes courants et comment les résoudre.

1. L’utilisateur peut entrer des valeurs en dehors de la plage


Même si vous définissez les options from_ et to, il est possible que l’utilisateur entre une valeur en dehors de cette plage manuellement. Pour éviter ce problème, utilisez les options validate et validatecommand pour valider les entrées en temps réel.

def validate_input(value):
    return value.isdigit() and 0 <= int(value) <= 10

vcmd = root.register(validate_input)

spinbox = tk.Spinbox(root, from_=0, to=10, validate="key", validatecommand=(vcmd, '%P'))
spinbox.pack()

Ce code empêche l’utilisateur de saisir une valeur hors de la plage définie.

2. Pas de prise en charge des nombres flottants


Le Spinbox gère par défaut les entiers. Si vous voulez permettre les nombres flottants, vous devez utiliser les options values ou increment.

Exemples de solutions :

• Utilisez values pour permettre des décimales spécifiques.
• Utilisez increment pour définir des pas décimaux.

spinbox = tk.Spinbox(root, from_=0, to=10, increment=0.1)
spinbox.pack()

3. Difficulté à désactiver les entrées


Si vous souhaitez désactiver temporairement le Spinbox, vous pouvez utiliser l’option state.

spinbox.config(state="disabled")  # Désactiver
spinbox.config(state="normal")    # Réactiver

Cette configuration empêche l’utilisateur d’interagir avec le Spinbox.

4. Pas de valeur par défaut


Si la valeur initiale du Spinbox est vide, l’utilisateur pourrait être confus. Pour définir une valeur par défaut, utilisez la méthode insert.

spinbox.delete(0, tk.END)
spinbox.insert(0, 5)  # Définir la valeur initiale à 5

5. Les valeurs entrées directement ne sont pas mises à jour immédiatement


Si les valeurs entrées manuellement dans le Spinbox ne sont pas immédiatement prises en compte, vous pouvez utiliser command ou des événements pour récupérer la valeur en temps réel.

def on_change():
    value = spinbox.get()
    print(f"Valeur modifiée : {value}")

spinbox = tk.Spinbox(root, from_=0, to=10, command=on_change)
spinbox.pack()

6. La molette de la souris ne fonctionne pas


Le Spinbox par défaut ne réagit pas à la molette de la souris. Vous pouvez lier un événement <MouseWheel> pour ajouter cette fonctionnalité.

def scroll(event):
    value = int(spinbox.get())
    if event.delta > 0:  # Défilement vers le haut
        spinbox.delete(0, tk.END)
        spinbox.insert(0, value + 1)
    elif event.delta < 0:  # Défilement vers le bas
        spinbox.delete(0, tk.END)
        spinbox.insert(0, value - 1)

spinbox.bind("<MouseWheel>", scroll)

7. Modification dynamique de la plage


Si vous souhaitez modifier dynamiquement la plage du Spinbox, utilisez la méthode config.

spinbox.config(from_=10, to=100)

Cette méthode vous permet de modifier la plage du Spinbox pendant l’exécution du programme.

8. Affichage du message d’erreur


Pour afficher un message d’erreur lorsque l’utilisateur entre une valeur incorrecte, vous pouvez utiliser l’exemple suivant.

def validate_and_alert(value):
    if not value.isdigit() or not (0 <= int(value) <= 10):
        error_label.config(text="Veuillez entrer une valeur entre 0 et 10")
        return False
    error_label.config(text="")
    return True

vcmd = root.register(validate_and_alert)

spinbox = tk.Spinbox(root, from_=0, to=10, validate="key", validatecommand=(vcmd, '%P'))
spinbox.pack()

error_label = tk.Label(root, text="", fg="red")
error_label.pack()

Résumé

• Utiliser validate pour empêcher l’entrée de valeurs hors plage.
• Configurer correctement les options pour les nombres flottants et la plage dynamique.
• Utiliser des boutons ou des événements pour améliorer l’interaction.
• Afficher des messages d’erreur pour les entrées incorrectes.

La section suivante résume les avantages du Spinbox dans le développement d’applications.

Résumé


Dans cet article, nous avons exploré différentes façons d’utiliser le widget Spinbox de Tkinter pour contrôler les entrées numériques en Python. Nous avons couvert l’utilisation de base, la validation des entrées, les valeurs à virgule flottante et spécifiques, la manipulation des valeurs à l’aide de boutons et d’événements, et comment personnaliser l’apparence et le comportement des Spinbox.

En utilisant le Spinbox correctement, vous pouvez facilement limiter les valeurs que l’utilisateur peut entrer, créant ainsi des interfaces et des formulaires plus sécurisés et efficaces. Cela améliore la fiabilité et l’utilisabilité de vos applications.

Dans vos prochains projets GUI, vous pouvez utiliser ces techniques pour créer des interfaces de saisie plus intuitives et pratiques.