REPUBLIQUE DU CAMEROUN REPUBLIC OF CAMEROON
Paix-Travail-Patrie Peace – Work - Fatherland
--------------- --------------
UNIVERSITE DE BERTOUA THE UNIVERSITY OF BERTOUA
---------- ----------
ECOLE NORMALE SUPERIEURE HIGHER TEACHER TRAINING
BP : 652 Bertoua COLLEGE
Tél : 673 507 416 / 692 604 875 P.O. Box 652 Bertoua
[Link] Phone: 673 507 416 / 692 604 875
---------- [Link]
----------
Département : informatique
EC : Programmation Python
Code UE : INF 213_1
THEME :
TKINTER
ENSEIGNANT :
M. EMINI ME ZENANGA Amstrong
Groupe 5 : Noms des etudiants :
1- NONO ANGE Jessica …………………………. 24N1163B
2- YIBITA Daniel …………………………………… 24N1120B
ANNEE ACADEMIQUE : 2025/2026
INTRODUCTION
La venue de l’informatique a permis de faciliter la création des interfaces graphiques des applications lors de leurs
développement. Ainsi, Python est l’une, parmi tant d’autres qui offre plusieurs bibliothèques de la création
d’interface graphique, donc celle de Tkinter qui est une bibliothèque graphique standard. Il est donc devoir de
concevoir une calculatrice scientifique a l’aide de Tkinter qui permet de mettre en pratique les notions de
programmation Python, la gestion des évènements, utilisation de widgets graphique, puis l’organisation du code
dans une application complète et fonctionnelle.
I- PRESENTATION GENERALE DU PROJET
Le projet a pour but de développer une calculatrice scientifique qui peut :
❖ Effectuer des opérations arithmétiques simple, c’est-à-dire, capable de faire l’addition, la soustraction, la
multiplication, et la division d’un nombre
❖ Effectuer des fonctions scientifiques, c’est-à-dire, calculer la racine carrée, la puissance, le sinus, le
cosinus, la tangente, … etc. d’un nombre.
L’application dispose :
❖ Unr fenêtre principale ;
❖ Un écran d’affichage ;
❖ Un Button d’interactif ;
❖ Une gestion efficace des évènements utilisateur.
Le projet vise aussi à :
❖ Renforcer la logique algorithmique ;
❖ La programmation évènementielle ;
❖ La conception d’interface graphique avec Tkinter.
II- PRESENTATION DE LA BIBLIOTHEQUE TKINTER
1- Introduction à Tkinter
Tkinter est la bibliothèque graphique par défaut de Python. Elle permet de créer des interfaces graphiques simple
et efficace sans utilisation supplémentaire. Tkinter est basée sur la bibliothèque Tk, utilisée dans plusieurs langages.
1- Composants principaux (Widgets)
Les Widgets sont des éléments graphiques utilises dans une interface :
- Tk () : fenêtre principale ;
- Label : afficher du texte statique ;
- Entry : zone de saisie texte pour afficher les chiffres ;
- Button : buton cliquable pour déclencher des actions ;
- Frame : conteneur de Widgets.
2- Gestion de la mise en page
Tkinter propose trois gestionnaires :
- Pack () : empile les widgets les uns sur les autres ;
- Grig () : disposition dans un tableau imaginaire des lignes et des colonnes ;
- Place() : positionne les widgets avec des coordonnées précises.
3- Les variables Tkinter
Pour lier les données de l’interface au code Python, nous allons utiliser les objets comme StringVar, IntVar,
DoubleVar qui permettent de modifier automatiquement le texte affiché sur l’écran de la calculatrice dès que les
valeurs de la variable changent dans le code.
4- Gestion des évènements
Elle permet à l’application de réagir aux actions de l’utilisateur. Lorsqu’un bouton est pressé, une fonction Python
est appelée via le paramètre command ou la méthode. bind().
Exemple
Button (root, text=’’=’’, command=calculer), ici, la fonction calculer est exécuter lorsqu’on clique le bouton
5- Avantages de Tkinter
▪ Inclus par défaut : aucune installation externe n’est requise avec Python ;
▪ Simplicité : syntaxe facile à apprendre pour les débutants ;
▪ Portabilité : le code fonctionne sur la majorité des systèmes d’exploitation.
III- ANALYSES DES BESOINS
1- Structure de base (fenêtre principale)
• La création : initialisation de l’Object racine avec root = Tk() et définition du titre ;
• Codage : configuration des dimensions (géométrie) et interdiction du redimensionnement si nécessaire.
2- Ecran d’affichage
• Entrée : utilisation du widget Entry pour la zone de texte ;
• Configuration : choix de la police, de la taille et l’alignement (a droite, standard pour les calculatrices) ;
• Positionnement ; placement en haut de la grille en utilisant columnspan pour qu’il occupe toute la largeur.
3- Les boutons
• Gestion des listes : créations d’une liste contenant tous les symboles des touches (0-9, +, -, *, etc.).
• Utilisation d’une boucle : afin d’éviter de répéter le code, une boucle for parcourt la liste pour générer et
placer chaque bouton automatiquement dans la grille.
4- Gestion des évènements
- Fonction d’ajout : ajoute le chiffre clique à l’expression actuelle sur l’écran ;
- Fonction de suppression : efface le contenu de l’écran (bouton « C » ou « AC ») ;
- Fonction de calcul : utilise la fonction eval () de Python pour transformer la chaine de caractère en résultat
mathématique ;
- Association : liaison de chaque fonction au bouton correspondant.
5- Fonctions scientifiques
- Fonctions : intégration des calculs comme la racine carrée x, le carre x2, ou le logarithme log(x) ;
- Catégories : séparation visuelle entre les touches numériques et les touches scientifiques.
6- Boucle principale
L’appel a root .mainloop () maintient la fenêtre ouverte et attend les interactions de l’utilisateur.
IV- CODE SOURCES
import tkinter as tk # import du module Tkinter de base pour créer des inter-
faces graphiques (fenêtres, boutons, labels…).
from tkinter import ttk # import des widgets avancés ttk (boutons, cadre,
themes, ....)
import math # import du module math pour les fonctions scientifiques,mathema-
tique et bin d'autre
# Dictionnaire des fonctions math autorisées pour l'évaluation sécurisée
SAFE_NAMES = {name: getattr(math, name) for name in [ # génère un dictionnaire
automatiquement des fonctions autoriseés lors du calcul
'sin','cos','tan','asin','acos','atan','sinh','cosh','tanh',
'log','log10','exp','sqrt','pi','e','floor','ceil' # liste des fonctions
permises
]}
# Ajout manuel d'alias supplémentaires
SAFE_NAMES.update({ # permet d'ajouter manuellement d'autres noms au dictionnaire
'ln': [Link], # permet d'ecrire ln(x) au lieu de log(x)
'log10': math.log10, # base 10
'log': math.log10, # log = log10
'deg': [Link],
'^': '**' # remplace '^' (non Python) par '**' qui est un operateur de puis-
sance en python
})
# definition de la Classe principale de la calculatrice
class Calculator([Link]): # cree une classe calculator qui hérite de Tk (fenêtre
principale)
def __init__(self):
super().__init__() # initialise la fenêtre
[Link]('Calculatrice scientifique') # donne le titre fenêtre" cal-
culatrice scientifique"
[Link]('480x500') # dimensions fixes de la longueur et le hauteur
de la fenetre
[Link](False, False) # defini si la fenetre peu etre redimen-
tionner ou pas, 'false' dans ce cas elle n'est pas redimentionner
self._create_widgets() # appelle la méthode de création des widgets(in-
terface graphique)
def _create_widgets(self): # crée l'interface graphique c'est à dire definir
le style des boutons , cree ecran d'affichage,cree et organise les boutons
# associe chaque bouton a une action, active les raccourcis clavier et
initialise les variables last answers
style = [Link](self) # initialisation du style ttk
[Link]('TButton', font=('Helvetica', 12), padding=8) # defini
la police(helvetica) de taille 12 et espace interne des boutons(padding)
[Link]('[Link]', font=('Consolas', 20), back-
ground='black', foreground='white') # cree unstyle personnalisé pour ecran
# police = consolas taille 20 pour les chiffres, fond = noir, texte = blanc
self.display_var = [Link]() # cree une variable liée à l'affi-
chage qui peut etre mise a jour automatiquemnet
display_frame = [Link](self, padding=(10,10)) # cree cadre contenant
l'écran
display_frame.pack(fill='x') # occupe toute la largeur
[Link] = [Link](
display_frame,
textvariable=self.display_var, # contenu dynamique
anchor='e', # aligné à droite
font=('Consolas', 24), # police type console
bg='black', fg='white', # couleur fond/texte
height=2, bd=6, relief='sunken' # style encadré "enfoncé"
)
[Link](fill='x') # occupe la largeur
# Définition de la grille des boutons
btns = [
['7','8','9','÷','√'], # chaque sous liste correspond à une ligne de
boutons
['4','5','6','*','^'],
['1','2','3','-','('],
['0','.','=','+',')'],
['sin','cos','tan','ln','log'],
['sinh','cosh','tanh','deg','2ndf'],
['π ','e','C','CE','ans']
]
btn_frame = [Link](self, padding=(10,10)) # cadre contenant les bou-
tons
btn_frame.pack() #permet d'ajouter un cadre à la fenetre'
# Génération automatique des boutons
for r, row in enumerate(btns): # parcours des lignes
for c, label in enumerate(row): # parcours colonnes
cmd = lambda v=label: self._on_button(v) # callback associé au
bouton
b = [Link](btn_frame, text=label, command=cmd) # création
bouton
[Link](row=r, column=c, sticky='nsew', padx=4, pady=6) # place-
ment grille
for i in range(len(btns[0])):
btn_frame.grid_columnconfigure(i, weight=1) # colonnes extensibles
# Raccourcis clavier
[Link]('<Return>', lambda e: self._on_button('=')) # touche entrée
[Link]('<BackSpace>', lambda e: self._on_button('CE')) # effacer un
caractère
[Link]('<Escape>', lambda e: self._on_button('C')) # clear complet
self.last_answer = '' # stocke le dernier résultat
# Gestion des boutons
'''La fonction _on_button gère le comportement de la calculatrice lorsqu’un
bouton est cliqué.
Elle récupère l’expression actuellement affichée, identifie le type de bouton
pressé (chiffre, opérateur, fonction, commande),
puis met à jour l’écran en conséquence ou déclenche le calcul du résultat.'''
def _on_button(self, label):
expr = self.display_var.get() # expression actuelle
if label == 'C': # effacer tout
self.display_var.set('')
elif label == 'CE': # effacer le dernier caractère
self.display_var.set(expr[:-1])
elif label == '=': # évaluer l'expression
self._evaluate(expr)
elif label == '√': # racine carrée
self.display_var.set(expr + '√(')
elif label in ('sin','cos','tan','sinh','cosh','tanh','ln','log'): #
fonctions trigonometrique/logarithme
self.display_var.set(expr + f"{label}(")
elif label == 'deg':
self.display_var.set(expr + "deg(")
elif label == '2ndf':
self.display_var.set(expr + "")
elif label == '^': # puissance
self.display_var.set(expr + '^')
elif label == 'π ': # constante pi
self.display_var.set(expr + str([Link]))
elif label == 'e': # constante e
self.display_var.set(expr + str(math.e))
elif label == 'ans': # dernier résultat
self.display_var.set(expr + str(self.last_answer))
else: # tout autre caractère (chiffres, parenthèses...)
self.display_var.set(expr + label)
# Évaluation sécurisée de l'expression
def _safe_eval(self, expression):
expression = [Link]('^', '**') # conversion puissance Python
expression = [Link](',', '.') # conversion virgule -> point
local_dict = {} # environnement local vide
local_dict.update(SAFE_NAMES) # ajoute les fonctions autorisées
try:
result = eval(expression, { '__builtins__': None }, local_dict) #
évaluation sécurisée
except Exception as e:
raise e # renvoi l'erreur
return result
# Procédure complète d'évaluation
#elle consiste à evaluer expression entrer par utilisateur de maniere precise
,par exemple utilisateur entre sin(2)
#,sin est contenu dans la categorie des safe_names alors le resulat renvoyer
est 0.909....'''
def _evaluate(self, expr): #
try:
res = self._safe_eval(expr) # calcule le résultat
if isinstance(res, float) and res.is_integer(): # si float entier
res = int(res) # convertir les nombres decimaux entiers en in-
tiers pour un affichage propre
self.last_answer = res # memorise le resultat pour une utilisation
ulterieure avec "ans"
self.display_var.set(str(res)) # mise à jour affichage
except Exception as e:
self.display_var.set('Erreur') # En cas d'erreur elle affiche un
message d'erreur
# Exécution du programme
# maintient execution de l'interface jusqu'a la fermeture de l'application
if __name__ == '__main__': # point d'entrée principal
app = Calculator() # instanciation de la calculatrice
[Link]() # boucle graphique Tkinter
1- Description de ligne par ligne du code
Les étapes clés du code sont :
- import tkinter as tk : Importation de la bibliothèque Tkinter sous l’alias tk pour faciliter l’accès aux
composants graphiques(widgets)
- from math import * : importation de tous les fonctions du module math nécessaire pour les fonctions
scientifiques
- root = [Link]() : permet la création de la fenêtre principale de l’application
- [Link](…) et [Link](….) : configuration du titre et des dimensions de la fenêtre
- [Link](false, false) : permet d’empêcher l’utilisateur de redimensionner la fenêtre pour conserver la
mise en page
2- Gestion de l’écran d’Affichage
Ici, la partie traite du visuel et de la liaison de données
- equation = [Link]() : contient des méthodes get() (pour lire) et set() (pour écrire) permet la création
d’une variable Tkinter de type chaine. Permet de modifier dynamiquement le texte affiché a l’écran
- [Link](…) : permet de créer le champ de saisie. On le lie a equation via textvariable.
- Grid(row=0, …) : permet de positionner l’écran tout en haut. Et columnspan=4 signifie qu’il est assez large
pour couvrir 4 colonnes de boutons.
3- La logique évènementielle (fonctions)
Ici, nous parlons de ce qui se passe lors d’un clic sur un bouton.
- Pour l’ajout de caractères, on récupère ce qui est déjà écrit (get), on ajoute le nouveau chiffre, puis on
renvoie le tout à l’écran(set).
- Pour supprimer, la fonction effacer() réinitialise la variable equation a une chaine vide
4- Fonction de calcul
- eval () : fonction puissante qui prend une chaine de caractères et la calcule réellement
- try…except : ici, si l’utilisateur tape par exemple quelque chose d’impossible, le programme affiche
« erreur » au lieu de s’arrêter brusquement
5- Création des boutons par boucle
Pour éviter de saisir plusieurs fois le même code, on automatise la création. On place les symboles dans une liste,
une boucle for crée chaque bouton et le place dans la grille selon des coordonnées (row, column) qui augmentent
automatiquement.
6- La boucle principale
La fonction [Link] () est le moteur de l’application. Elle donne des instructions à Python de rester ouvert
et surveiller si l’utilisateur clique sur quelque chose, sinon, sans cela, la fenêtre va disparaitre instantanément après
ouverture.
CONCLUSION
En somme, ce projet nous a permis de comprendre le fonctionnement d’une application événementielle sous Python.
Tkinter s’est révélé être un outil puissant pour transformer un algorithme mathématique en un logiciel utilitaire
concret.