From bb95a7866e3502408d5d9dc2b80bee4ddcccdc5d Mon Sep 17 00:00:00 2001 From: manon Date: Mon, 17 Mar 2025 09:20:45 +0100 Subject: [PATCH] on met tout au propre --- oui.py => brouillon.py | 0 projet_calculatrice.py | 187 +++++++++++++++++++++++++++++++++-------- 2 files changed, 150 insertions(+), 37 deletions(-) rename oui.py => brouillon.py (100%) diff --git a/oui.py b/brouillon.py similarity index 100% rename from oui.py rename to brouillon.py diff --git a/projet_calculatrice.py b/projet_calculatrice.py index 87eb85f..608db07 100644 --- a/projet_calculatrice.py +++ b/projet_calculatrice.py @@ -2,45 +2,158 @@ # GUILLAUMIN-TORRES Ambre # COVIN Clara -class Expression : - """Permet de représenter et manipuler une expression arithmétique sous la forme d'un arbre""" - def __init__ (valeur_racine, fils_gauche, fils_droit): - """Constructeur""" - self.valeur = valeur_racine +from Pile import Pile_lst as Pile +import tkinter as tk + + +fen = tk.Tk() +fen.title("Calculatrice") + +#taille de la fenetre +fen.geometry("550x450") + +canvas = tk.Canvas(fen, width=500, height=300, bg="pink") + +label = tk.Label(canvas, text='Testing') +# canvas.create_window(50, 50, window.label) +canvas.grid(column=0,row=0) + + +class Expression: + """représente une expression arithmétique sous forme d'un arbre""" + def __init__ (self, valeur_racine, fils_gauche, fils_droit): + self.val_racine = valeur_racine self.gauche = fils_gauche self.droit = fils_droit - - def évalue (self): - """Renvoie le résultat de l'expression""" - if self.valeur == '*': - return multiplication(valeur.gauche, valeur.droit) + + def evalue (self) : + """ Permet de renvoyer la valeur de l’expression""" + if self.gauche == None and self.droit == None : + return self.val_racine - elif self.valeur == '+': - return addition(valeur.gauche, valeur.droit) + if self.gauche != None: #on ne met pas elif car les cas sont indépendants" + gauche_val = self.gauche.evalue() + else: + gauche_val = 0 - def __str__ (self): - """Affiche tous les nœuds de l'arbre a par un parcours DFS préfixé.""" - if a is None: - return - parcours_dfs_infixe(a.gauche) - print(a.valeur) - parcours_dfs_infixe(a.droit) + if self.droit != None: + droite_val = self.droit.evalue() + else: + droite_val = 0 -def multiplication(self): - """Multiplie la valeur des fils gauche et droits""" - if self.gauche == int and self.droit == int : - return self.gauche * self.droit - -def addition(self): - """Additionne les valeurs des fils gauche et droits""" - if self.gauche == int and self.droit == int : - return self.gauche + self.droit - - #test -exp = Expression('*', - Expression(6, None, None), - Expression('+', - Expression(4, None, None), - Expression(3, None, None) - ) - ) \ No newline at end of file + if self.val_racine == '+': + return gauche_val + droite_val + elif self.val_racine == '-': + return gauche_val - droite_val + elif self.val_racine == '*': + return gauche_val * droite_val + elif self.val_racine == '/': + return gauche_val / droite_val + else : + raise ValueError ("Cette commande ne peut pas être effectuer") + + def __str__(self): + """Permet d'afficher une expression en ligne, représenter par un arbre""" + result = "" + if self.droit: + result = result + str(self.droit) + result = result + str(self.val_racine) + "\n" #le "/n" c'est pour avoir une nouvelle ligne de l'arbre + if self.gauche: + result += str(self.gauche) + return result + + def npi2tree(lst): + """Convertit une liste représentant une expression en notation polonaise inversée en un arbre d'expression.""" + pille = Pile () + for element in lst: + # Si c'est un opérateur (+, -, * ou /), on crée un nœud opérateur + if element in ('+', '-', '*', '/'): + droit = pille.depiler() + gauche = pille.depiler() + pille.empiler(Expression(element, gauche, droit)) # Créer un nouvel arbre et empiler + else: + # Sinon, ça veut dire que c'est un nombre donc on le convertit et on l'empile. + pille.empiler(Expression(int(element), None, None)) + + return pille.depiler() # Retourne l'arbre complet + +def evaluer_expression(): + expression = entry.get() + elements = expression.split() + if not elements: + label_2.config(text="Erreur: Expression vide") + return + arbre = Expression.npi2tree(elements) + if arbre is None: + label_2.config(text="Erreur: Expression incorrecte") + else: + resultat = arbre.evalue() + label_2.config(text=f"Résultat: {resultat}") # si l'expression est incorrecte + +# Label pour l'interface +label_1 = tk.Label(fen, text="Entrez l'expression :") +label_1.grid() + +# Champ de texte pour l'entrée de l'expression +entry = tk.Entry(fen, width=30) +entry.grid() + +# Bouton pour calculer l'expression +btn_calculer = tk.Button(fen, text="Calculer", command=evaluer_expression) +btn_calculer.grid(row=4, column=0, columnspan=2) + +# Label pour afficher le résultat +label_2 = tk.Label(fen, text="Résultat: ") +label_2.grid(row=5, column=0, columnspan=2) + + +label_2 = tk.Label(fen, text=evaluer_expression().resultat) +label_2.grid() + +# Lancement de l'interface graphique +fen.mainloop() + + +#test: + +exp = Expression(5,None,None) +assert exp.evalue() == 5 + +exp = Expression('+', Expression(8,None,None), Expression(3,None,None))#ça marche comme ça +assert exp.evalue() == 11 + +#exp = Expression('+', 8, 3)#mais ça marche pas comme ça, je sais pas trop comment régler ça +#assert exp.evalue() == 11 + +exp = Expression('*', Expression(8,None,None), Expression(3,None,None))#ça marche comme ça +assert exp.evalue() == 24 + +exp = Expression('-', Expression(45,None,None), Expression(3,None,None))#ça marche comme ça +assert exp.evalue() == 42 + +lst = ["6", "4", "3", "+", "*"] # Correspond à 6 * (4 + 3) +arbre = Expression.npi2tree(lst) # Convertit la liste en un arbre + +print(arbre.evalue()) # Affiche : 42 + +# Test: Expression simple de somme +exp = Expression('+', Expression(8, None, None), Expression(3, None, None)) +assert exp.evalue() == 11, f"Test échoué: {exp.evalue()}" # Vérifie que 8 + 3 = 11 + +# Test: Expression simple de multiplication +exp = Expression('*', Expression(4, None, None), Expression(5, None, None)) +assert exp.evalue() == 20, f"Test échoué: {exp.evalue()}" # Vérifie que 4 * 5 = 20 + +# Test: Expression avec une soustraction +exp = Expression('-', Expression(20, None, None), Expression(5, None, None)) +assert exp.evalue() == 15, f"Test échoué: {exp.evalue()}" # Vérifie que 20 - 5 = 15 + +# Test: Test d'une expression valide en NPI (notation polonaise inversée) +# Correspond à: 6 * (4 + 3) +lst = ["6", "4", "3", "+", "*"] +arbre = Expression.npi2tree(lst) +assert arbre.evalue() == 42, f"Test échoué: {arbre.evalue()}" # Vérifie que 6 * (4 + 3) = 42 + +# Test: Expression avec division +exp = Expression('/', Expression(10, None, None), Expression(2, None, None)) +assert exp.evalue() == 5, f"Test échoué: {exp.evalue()}" # Vérifie que 10 / 2 = 5