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 4 weeks 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
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 99
      projet_calculatrice.py
  2. 100
      temp.py

99
projet_calculatrice.py
View File

@ -64,18 +64,18 @@ class Expression:
def npi2tree(lst):
"""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:
# 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
if element in ('+', '-', '*', '/','^'):
droit = pile.depiler()
gauche = pile.depiler()
pile.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))
pile.empiler(Expression(int(element), None, None))
return pille.depiler() # Retourne l'arbre complet
return pile.depiler() # Retourne l'arbre complet
def evaluer_expression():
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.grid(row=5, column=0, columnspan=2)
label_2 = tk.Label(fen, text=evaluer_expression().resultat)
canvas.create_text(250, 50,text=evaluer_expression(),font="Dubai 20",fill="blue")
label_2 = tk.Label(fen, text=evaluer_expression())
label_2.grid()
# Lancement de l'interface graphique
@ -116,44 +116,45 @@ 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
# 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
# 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

100
temp.py
View File

@ -64,18 +64,18 @@ class Expression:
def npi2tree(lst):
"""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:
# 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
if element in ('+', '-', '*', '/','^'):
droit = pile.depiler()
gauche = pile.depiler()
pile.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))
pile.empiler(Expression(int(element), None, None))
return pille.depiler() # Retourne l'arbre complet
return pile.depiler() # Retourne l'arbre complet
def evaluer_expression():
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.grid(row=5, column=0, columnspan=2)
label_2 = tk.Label(fen, text=evaluer_expression().resultat)
canvas.create_text(250, 50,text=evaluer_expression(),font="Dubai 20",fill="blue")
label_2 = tk.Label(fen, text=evaluer_expression())
label_2.grid()
# Lancement de l'interface graphique
@ -116,44 +116,44 @@ 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
# 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

Write Preview
Loading…
Cancel
Save