Création d'une Calculatrice Tkinter en Python

Créer une interface utilisateur intuitive pour des calculs simples peut être complexe.

Sans une bonne interface, les utilisateurs peuvent se sentir frustrés par des interactions peu naturelles.

Cet article vous guide dans la création d’une calculatrice simple avec Tkinter, rendant l’expérience utilisateur fluide et efficace.

Table de matière

Création d'une calculatrice Tkinter Code complet pour calculatrice Tkinter Créer une interface graphique Python Spécifications des boutons Tkinter FAQ Conclusion

Formation Python : Interface Graphique TKinter

Créez des interfaces graphiques interactives avec Python et TKinter !

Création d'une calculatrice Tkinter

Dans cet chapitre, nous allons répondre à l’exercice de construction d’une calculatrice simple en utilisant Python et la bibliothèque Tkinter pour l’interface graphique. Ce projet nous permettra de manipuler des éléments fondamentaux de Tkinter tels que les boutons, les champs de saisie, et les cadres, tout en introduisant des concepts de base de la programmation d’interfaces graphiques. La calculatrice sera capable d’évaluer des expressions mathématiques simples, d’afficher le résultat dans un champ de saisie et d’inclure des fonctionnalités de base comme l’effacement et la fermeture de l’application. Voici les différentes parties de résolution de cet exercice :

Importation de la bibliothèque Tkinter

from tkinter import *

Cette ligne importe toutes les classes et fonctions de la bibliothèque Tkinter, qui est utilisée pour créer des interfaces graphiques en Python.

Définition de la fonction calculate

				
					
 defcalculate():
try:
result = eval(entry.get())
entry.delete(0, END)
entry.insert(0, result)
except:
entry.delete(0, END)
entry.insert(0, "error")

La fonction calculate est déclenchée lorsque l’utilisateur appuie sur le bouton = de la calculatrice pour évaluer l’expression mathématique saisie dans le champ d’entrée (entry). Pour effectuer ce calcul, elle utilise la fonction eval(entry.get()) , qui interprète et évalue l’expression contenue dans le champ d’entrée. Par exemple, si l’utilisateur a saisi « 2+3 », eval retournera 5. Cependant, dans le cas où l’expression saisie n’est pas valide (comme « 2++3 »), une gestion des erreurs est mise en place avec except : elle efface le contenu du champ d’entrée et y affiche le message « error », permettant ainsi à l’utilisateur de savoir que l’expression n’a pas pu être calculée.

Infos : La fonction eval est une fonction prédéfinie en Python qui permet d’évaluer et d’exécuter une expression écrite sous forme de chaîne de caractères. Elle peut être utilisée pour exécuter dynamiquement des calculs ou des expressions Python, comme des opérations mathématiques.

Définition de la fonction clear

				
					
 defclear():
entry.delete(0, END)

Fonction clear est appelée lorsque l’utilisateur clique sur le bouton Effacer. Elle supprime tout le contenu du champ d’entrée entry en utilisant la méthode delete(0, END).

Initialisation de la fenêtre principale

				
					
 root = Tk()
root.title("Calculatrice")
root.resizable(False, False)

La ligne root = Tk() crée la fenêtre principale de l’application, qui servira de base pour tous les éléments de l’interface graphique. Ensuite, root.title(« Calculatrice ») définit le titre de cette fenêtre, ici « Calculatrice », qui s’affiche en haut de la fenêtre de l’application. Enfin, l’instruction root.resizable(False, False) empêche la fenêtre d’être redimensionnée, aussi bien horizontalement que verticalement, garantissant ainsi une taille fixe pour l’interface de la calculatrice.

Création du champ d'entrée entry

				
					
 entry = Entry(root,width=30,borderwidth=5)
entry.pack(side=TOP,padx=10,pady=10)

Le champ d’entrée entry est la zone de saisie où l’utilisateur tape les expressions mathématiques qu’il souhaite évaluer. Ses dimensions sont spécifiées par les paramètres width=30 , qui fixe la largeur du champ, et borderwidth=5 , qui définit l’épaisseur de la bordure, apportant ainsi une visibilité renforcée au champ. L’instruction entry.pack(…) positionne le champ d’entrée en haut de la fenêtre de l’application et ajoute des marges de 10 pixels autour de celui-ci, offrant ainsi un espace visuel confortable pour l’utilisateur.

Définition des boutons de la calculatrice

Liste buttons : Cette liste contient les étiquettes des boutons de la calculatrice, qui représentent les chiffres, les opérateurs et les actions spéciales (Effacer pour réinitialiser et Quitter pour fermer l’application).

				
					
 buttons = [
"1", "2", "3", "+",
"4", "5", "6", "-",
"7", "8", "9", "*",
"0", ".", "=", "/",
"Effacer", "Quitter"
]

Création d'un cadre pour les boutons

				
					
 button_frame = Frame(root)
button_frame.pack(side=TOP,padx=10,pady=10)

Le cadre button_frame agit comme un conteneur destiné à organiser les boutons de la calculatrice dans une grille ordonnée, facilitant leur disposition et leur gestion au sein de l’interface. L’instruction de positionnement place ce cadre en haut de la fenêtre de l’application, en lui ajoutant des marges pour séparer visuellement le cadre des autres éléments et rendre l’interface plus structurée.

Boucle de création des boutons

				
					
 r = 0
c = 0
for button in buttons:
if button == "=":
cmd = calculate
elif button == "Effacer":
cmd = clear
elif button == "Quitter":
cmd = root.quit
else:
cmd =lambdax=button: entry.insert(END, x)
Button(button_frame,text=button,width=7,height=3,command=cmd).grid(row=r,column=c,padx=5,pady=5)
c += 1
if c > 3:
c = 0
r += 1

Les variables r et c représentent respectivement les lignes et les colonnes dans la grille de boutons. Elles permettent de positionner chaque bouton à un emplacement précis de la grille. La boucle for parcourt chaque élément de la liste buttons et crée un bouton correspondant pour chaque élément.

À l’intérieur de la boucle, plusieurs conditions déterminent quelle fonction sera exécutée lorsque l’on clique sur un bouton particulier :

Condition if button == « = » :Si le bouton est « = », la commande cmd est définie pour appeler la fonction calculate, qui évalue l’expression mathématique.
Condition elif button == « Effacer » :Si le bouton est « Effacer », la commande cmd appelle la fonction clear, qui vide le champ d’entrée.
Condition elif button == « Quitter » :Si le bouton est « Quitter », la commande cmd utilise root.quit pour fermer l’application.
Sinon :Pour tous les autres boutons (les chiffres et les opérateurs), cmd utilise une fonction lambda qui insère la valeur du bouton dans le champ d’entrée entry lorsqu’on clique dessus.

Pour la création du bouton , chaque bouton est défini avec Button(button_frame, text=button, width=7, height=3, command=cmd), où text est l’étiquette du bouton, width et height définissent sa taille, et command associe l’action appropriée à chaque bouton. Le placement en grille utilise grid(row=r, column=c, padx=5, pady=5), qui place chaque bouton dans une grille de 4 colonnes. La boucle incrémente c (colonne) et r (ligne) au besoin pour disposer les boutons en une structure 4×5, facilitant ainsi une disposition ordonnée et intuitive pour l’utilisateur.

Lancement de la boucle principale

root.mainloop() : Cette ligne lance la boucle principale de l’application Tkinter. Elle reste active tant que la fenêtre est ouverte, permettant à l’utilisateur d’interagir avec l’interface.

				
					
 root.mainloop()

Code complet pour calculatrice Tkinter

Voici le code complet :

				
					
 from tkinter import *
defcalculate():
try:
result = eval(entry.get())
entry.delete(0, END)
entry.insert(0, result)
except:
entry.delete(0, END)
entry.insert(0,"error")
defclear():
entry.delete(0,END)
root = Tk()
root.title("Calculatrice")
root.resizable(False,False)
entry = Entry(root,width=30,borderwidth=5)
entry.pack(side=TOP,padx=10,pady=10)
buttons = [
"1","2","3","+",
"4","5","6","-",
"7","8","9","*",
"0",".","=","/",
"Effacer", "Quitter"
]
button_frame = Frame(root)
button_frame.pack(side=TOP,padx=10,pady=10)
r=0
c=0
for button in buttons:
if button == "=":
cmd = calculate
elif button == "Effacer":
cmd = clear
elif button == "Quitter":
cmd = root.quit
else:
cmd =lambdax=button: entry.insert(END, x)
Button(button_frame,text=button,width=7,height=3,command=cmd).grid(row=r,column=c,padx=5,pady=5)
c+=1
if c > 3:
c=0
r+=1
root.mainloop()

Ainsi voici le résultat obtenue après l’exécution de ce code :

Conclusion :

Ce code crée une calculatrice simple avec une interface graphique en Tkinter, permettant à l’utilisateur de :

Saisir une expression mathématique.
Utiliser des boutons pour les chiffres, opérateurs et actions spéciales.
Calculer le résultat ou effacer l’entrée.

Le code utilise des fonctions calculate et clear pour gérer les actions des boutons = et Effacer, ainsi qu’une boucle pour créer et positionner les boutons. Cette structure facilite la modification ou l’extension de la calculatrice.

Top of Form

Bottom of Form

Créer une interface graphique Python

L’objectif de cet exercice est de concevoir une calculatrice fonctionnelle avec une interface graphique en utilisant la bibliothèque Tkinter en Python. La calculatrice doit permettre à l’utilisateur d’effectuer des opérations de base comme l’addition, la soustraction, la multiplication et la division, en plus de pouvoir effacer l’affichage ou quitter l’application.

Spécifications des boutons Tkinter

Interface graphique :

Créer une fenêtre intitulée « Calculatrice ».
Ajouter un champ d’entrée (Entry) qui servira d’écran pour afficher les chiffres et les résultats.
Organiser les boutons numériques (0 à 9) et les boutons des opérations (+, -, *, /) de manière structurée sur une grille.

Ajouter deux boutons supplémentaires : »Effacer » (pour réinitialiser le champ d’affichage) et « Quitter » (pour fermer l’application).

Fonctionnalités :

Lorsque l’utilisateur clique sur un bouton numérique, le chiffre correspondant doit être affiché dans le champ d’entrée.
L’utilisateur doit pouvoir entrer une opération (addition, soustraction, multiplication, division) en cliquant sur les boutons correspondants.
Après avoir entré une opération et les chiffres nécessaires, l’utilisateur doit pouvoir cliquer sur = pour afficher le résultat dans le champ d’entrée.
Le bouton « Effacer » doit réinitialiser le champ d’affichage, supprimant tous les chiffres et les opérations en cours.
Le bouton « Quitter » doit fermer l’application.

Formez-vous gratuitement avec Alphorm !

Maîtrisez les compétences clés en IT grâce à nos formations gratuites et accélérez votre carrière dès aujourd'hui.

FAQ

Comment importer la bibliothèque Tkinter en Python?

Pour importer la bibliothèque Tkinter en Python, utilisez la commande `from tkinter import *`. Cette instruction permet d’accéder à toutes les classes et fonctions nécessaires pour créer des interfaces graphiques. Tkinter est la bibliothèque standard pour les interfaces graphiques en Python, facilitant la création d’applications interactives.

Quelle est la fonction de la méthode calculate dans le code?

La fonction `calculate` est déclenchée lorsque l’utilisateur appuie sur le bouton =. Elle évalue l’expression saisie dans le champ d’entrée `entry` à l’aide de la fonction `eval(entry.get())`. Si l’expression est valide, le résultat est affiché dans le champ d’entrée. En cas d’erreur, la fonction affiche ‘error’.

Comment créer un champ d'entrée avec Tkinter?

Pour créer un champ d’entrée avec Tkinter, utilisez `Entry(root, width=30, borderwidth=5)` où `root` est votre fenêtre principale. Cela configure un champ de saisie avec une largeur de 30 et une bordure de 5 pixels. Ensuite, utilisez `entry.pack()` pour le positionner correctement dans l’interface graphique.

Comment organiser les boutons dans une interface Tkinter?

Les boutons peuvent être organisés dans une interface Tkinter en utilisant un `Frame` pour contenir les boutons, puis en les disposant avec la méthode `grid(row=r, column=c)`. Cette méthode permet de placer chaque bouton dans une grille, facilitant l’organisation structurée sur l’interface.

Comment fonctionne la boucle principale de Tkinter?

La boucle principale de Tkinter est activée avec `root.mainloop()`. Elle maintient l’application ouverte, permettant l’interaction utilisateur avec l’interface. Tant que cette boucle est active, l’application répond aux événements tels que les clics de boutons et les saisies clavier.

Conclusion

En créant cette calculatrice Tkinter, vous avez appris à manipuler des interfaces graphiques en Python. Quel autre projet complexe aimeriez-vous réaliser avec Tkinter?

Création d’une Calculatrice Tkinter en Python