bellynck.m
/
calculatrice_Ambre-Manon-Clara
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

problème réglé merci Ambre

master
manon 1 month ago
parent
bb95a7866e
commit
e7996b51f3
2 changed files with 100 additions and 99 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 97
      projet_calculatrice.py
  2. 98
      temp.py

97
projet_calculatrice.py
View File

@ -64,18 +64,18 @@ class Expression:
def npi2tree(lst): def npi2tree(lst):
"""Convertit une liste représentant une expression en notation polonaise inversée en un arbre d'expression.""" """Convertit une liste représentant une expression en notation polonaise inversée en un arbre d'expression."""
pille = Pile () pile = Pile ()
for element in lst: for element in lst:
# Si c'est un opérateur (+, -, * ou /), on crée un nœud opérateur # Si c'est un opérateur (+, -, * ou /), on crée un nœud opérateur
if element in ('+', '-', '*', '/'): if element in ('+', '-', '*', '/','^'):
droit = pille.depiler() droit = pile.depiler()
gauche = pille.depiler() gauche = pile.depiler()
pille.empiler(Expression(element, gauche, droit)) # Créer un nouvel arbre et empiler pile.empiler(Expression(element, gauche, droit)) # Créer un nouvel arbre et empiler
else: else:
# Sinon, ça veut dire que c'est un nombre donc on le convertit et on l'empile. # Sinon, ça veut dire que c'est un nombre donc on le convertit et on l'empile.
pille.empiler(Expression(int(element), None, None)) pile.empiler(Expression(int(element), None, None))
return pille.depiler() # Retourne l'arbre complet return pile.depiler() # Retourne l'arbre complet
def evaluer_expression(): def evaluer_expression():
expression = entry.get() expression = entry.get()
@ -106,8 +106,8 @@ btn_calculer.grid(row=4, column=0, columnspan=2)
label_2 = tk.Label(fen, text="Résultat: ") label_2 = tk.Label(fen, text="Résultat: ")
label_2.grid(row=5, column=0, columnspan=2) label_2.grid(row=5, column=0, columnspan=2)
canvas.create_text(250, 50,text=evaluer_expression(),font="Dubai 20",fill="blue")
label_2 = tk.Label(fen, text=evaluer_expression().resultat) label_2 = tk.Label(fen, text=evaluer_expression())
label_2.grid() label_2.grid()
# Lancement de l'interface graphique # Lancement de l'interface graphique
@ -116,44 +116,45 @@ fen.mainloop()
#test: #test:
exp = Expression(5,None,None) # exp = Expression(5,None,None)
assert exp.evalue() == 5 # assert exp.evalue() == 5
#
exp = Expression('+', Expression(8,None,None), Expression(3,None,None))#ça marche comme ça # 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 # 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
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

98
temp.py
View File

@ -64,18 +64,18 @@ class Expression:
def npi2tree(lst): def npi2tree(lst):
"""Convertit une liste représentant une expression en notation polonaise inversée en un arbre d'expression.""" """Convertit une liste représentant une expression en notation polonaise inversée en un arbre d'expression."""
pille = Pile () pile = Pile ()
for element in lst: for element in lst:
# Si c'est un opérateur (+, -, * ou /), on crée un nœud opérateur # Si c'est un opérateur (+, -, * ou /), on crée un nœud opérateur
if element in ('+', '-', '*', '/'): if element in ('+', '-', '*', '/','^'):
droit = pille.depiler() droit = pile.depiler()
gauche = pille.depiler() gauche = pile.depiler()
pille.empiler(Expression(element, gauche, droit)) # Créer un nouvel arbre et empiler pile.empiler(Expression(element, gauche, droit)) # Créer un nouvel arbre et empiler
else: else:
# Sinon, ça veut dire que c'est un nombre donc on le convertit et on l'empile. # Sinon, ça veut dire que c'est un nombre donc on le convertit et on l'empile.
pille.empiler(Expression(int(element), None, None)) pile.empiler(Expression(int(element), None, None))
return pille.depiler() # Retourne l'arbre complet return pile.depiler() # Retourne l'arbre complet
def evaluer_expression(): def evaluer_expression():
expression = entry.get() expression = entry.get()
@ -106,8 +106,8 @@ btn_calculer.grid(row=4, column=0, columnspan=2)
label_2 = tk.Label(fen, text="Résultat: ") label_2 = tk.Label(fen, text="Résultat: ")
label_2.grid(row=5, column=0, columnspan=2) label_2.grid(row=5, column=0, columnspan=2)
canvas.create_text(250, 50,text=evaluer_expression(),font="Dubai 20",fill="blue")
label_2 = tk.Label(fen, text=evaluer_expression().resultat) label_2 = tk.Label(fen, text=evaluer_expression())
label_2.grid() label_2.grid()
# Lancement de l'interface graphique # Lancement de l'interface graphique
@ -116,44 +116,44 @@ fen.mainloop()
#test: #test:
exp = Expression(5,None,None) # exp = Expression(5,None,None)
assert exp.evalue() == 5 # assert exp.evalue() == 5
#
exp = Expression('+', Expression(8,None,None), Expression(3,None,None))#ça marche comme ça # 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 # assert exp.evalue() == 11
#
exp = Expression('*', Expression(8,None,None), Expression(3,None,None))#ça marche comme ça # #exp = Expression('+', 8, 3)#mais ça marche pas comme ça, je sais pas trop comment régler ça
assert exp.evalue() == 24 # #assert exp.evalue() == 11
#
exp = Expression('-', Expression(45,None,None), Expression(3,None,None))#ça marche comme ça # exp = Expression('*', Expression(8,None,None), Expression(3,None,None))#ça marche comme ça
assert exp.evalue() == 42 # assert exp.evalue() == 24
#
lst = ["6", "4", "3", "+", "*"] # Correspond à 6 * (4 + 3) # exp = Expression('-', Expression(45,None,None), Expression(3,None,None))#ça marche comme ça
arbre = Expression.npi2tree(lst) # Convertit la liste en un arbre # assert exp.evalue() == 42
#
print(arbre.evalue()) # Affiche : 42 # lst = ["6", "4", "3", "+", "*"] # Correspond à 6 * (4 + 3)
# arbre = Expression.npi2tree(lst) # Convertit la liste en un arbre
# Test: Expression simple de somme #
exp = Expression('+', Expression(8, None, None), Expression(3, None, None)) # print(arbre.evalue()) # Affiche : 42
assert exp.evalue() == 11, f"Test échoué: {exp.evalue()}" # Vérifie que 8 + 3 = 11 #
# # Test: Expression simple de somme
# Test: Expression simple de multiplication # exp = Expression('+', Expression(8, None, None), Expression(3, None, None))
exp = Expression('*', Expression(4, None, None), Expression(5, None, None)) # assert exp.evalue() == 11, f"Test échoué: {exp.evalue()}" # Vérifie que 8 + 3 = 11
assert exp.evalue() == 20, f"Test échoué: {exp.evalue()}" # Vérifie que 4 * 5 = 20 #
# # Test: Expression simple de multiplication
# Test: Expression avec une soustraction # exp = Expression('*', Expression(4, None, None), Expression(5, None, None))
exp = Expression('-', Expression(20, None, None), Expression(5, None, None)) # assert exp.evalue() == 20, f"Test échoué: {exp.evalue()}" # Vérifie que 4 * 5 = 20
assert exp.evalue() == 15, f"Test échoué: {exp.evalue()}" # Vérifie que 20 - 5 = 15 #
# # Test: Expression avec une soustraction
# Test: Test d'une expression valide en NPI (notation polonaise inversée) # exp = Expression('-', Expression(20, None, None), Expression(5, None, None))
# Correspond à: 6 * (4 + 3) # assert exp.evalue() == 15, f"Test échoué: {exp.evalue()}" # Vérifie que 20 - 5 = 15
lst = ["6", "4", "3", "+", "*"] #
arbre = Expression.npi2tree(lst) # # Test: Test d'une expression valide en NPI (notation polonaise inversée)
assert arbre.evalue() == 42, f"Test échoué: {arbre.evalue()}" # Vérifie que 6 * (4 + 3) = 42 # # Correspond à: 6 * (4 + 3)
# lst = ["6", "4", "3", "+", "*"]
# Test: Expression avec division # arbre = Expression.npi2tree(lst)
exp = Expression('/', Expression(10, None, None), Expression(2, None, None)) # assert arbre.evalue() == 42, f"Test échoué: {arbre.evalue()}" # Vérifie que 6 * (4 + 3) = 42
assert exp.evalue() == 5, f"Test échoué: {exp.evalue()}" # Vérifie que 10 / 2 = 5 #
# # 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

Write Preview
Loading…
Cancel
Save