Laura 6 days ago
parent
commit
df0c760447
  1. 65
      calculette.py
  2. 78
      intergraph.py
  3. BIN
      modules/__pycache__/calculette.cpython-313.pyc
  4. 76
      modules/calculette.py

65
calculette.py

@ -3,27 +3,32 @@ from Pile import Pile_chaine as Pile
class Expression:
"""Classe représentant une expression arithmétique"""
def __init__(self, valeur, gauche=None, droite=None):
self.valeur = valeur
self.gauche = gauche
self.droite = droite
def evalue(self):
"""Méthode permettant d'évaluer l'expression"""
if type(self.valeur) == int:
return self.valeur
if self.valeur == '+':
return self.gauche.evalue() + self.droite.evalue()
if self.valeur == '*':
elif self.valeur == '*':
return self.gauche.evalue() * self.droite.evalue()
if self.valeur == '/':
elif self.valeur == '/':
if self.droite.valeur == 0:
raise ValueError ("division par 0 impossible !! ")
return self.gauche.evalue() / self.droite.evalue()
if self.valeur == '-':
elif self.valeur == '-':
return self.gauche.evalue() - self.droite.evalue()
def __str__(self):
"""Méthode permettant d'afficher l'expression"""
if type(self.valeur) == int:
return str(self.valeur)
if self.valeur == '+':
@ -34,34 +39,38 @@ class Expression:
return "("+ str (self.gauche) + "/" + str (self.droite) + ")"
if self.valeur == '-':
return "("+ str (self.gauche) + "-" + str (self.droite) + ")"
def __repr__(self):
"""Méthode permettant d'afficher l'expression"""
return str(self)
if __name__ =="__main__":
e = Expression('*',
Expression(6, None, None),
Expression('+',
Expression(4, None, None),
Expression(3, None, None)
)
)
e = Expression('*',Expression(6, None, None),Expression('+',Expression(4, None, None),Expression(3, None, None)))
def npi2tree(lst):
"""fonction npi2tree prenant en paramètre une liste correspondant l’expression en notation
polonaise inversée et renvoyant larbre (de type Expression) correspondant"""
exp = []
for ele in lst :
if ele in ["+","-","/","*"]:
ex = Expression(ele, exp.pop(), exp.pop())
exp.append(ex)
else:
exp.append(int(ele))
return exp.pop()
class Calculette:
"""Classe représentant une calculette"""
def __init__(self):
pass
class Conversion:
def npi2tree (lst):
"""fonction npi2tree prenant en paramètre une liste correspondant l’expression en notation
polonaise inversée et renvoyant larbre (de type Expression) correspondant"""
lst = []
for ele in lst :
if ele == '+' or ele == '*':
exp = Expression(ele, Expression())
return exp
# if + or * :
# else :
# return
def calculer(self, expression):
"""Méthode permettant de calculer une expression"""
try:
return eval(expression)
except Exception as e:
return str(e)
if __name__ == "__main__":
npi2tree(["3","4","+","6","*"])

78
intergraph.py

@ -1,39 +1,55 @@
from tkinter import *
from modules.calculette import Calculette
fenetre = Tk()
label = Label(fenetre, text="Calculatrice")
label.grid(row=0, column=0)
# Creating the buttons
bouton1 = Button(fenetre, text="1")
bouton1.grid(row=1, column=0)
bouton2 = Button(fenetre, text="2")
bouton2.grid(row=1, column=1)
bouton3 = Button(fenetre, text="3")
bouton3.grid(row=1, column=2)
bouton4 = Button(fenetre, text="4")
bouton4.grid(row=2, column=0)
def ajouter_au_calcul(symbol):
'''Ajoute un symbole à la saisie'''
current_text = calc.get()
calc.set(current_text + symbol)
bouton5 = Button(fenetre, text="5")
bouton5.grid(row=2, column=1)
def calculer_expression():
'''Calcule l'expression saisie'''
expression = calc.get()
resultat = calculatrice.calculer(expression)
result_label.config(text="Résultat: " + str(resultat))
bouton6 = Button(fenetre, text="6")
bouton6.grid(row=2, column=2)
def effacer():
'''Efface la saisie'''
calc.set("")
bouton7 = Button(fenetre, text="7")
bouton7.grid(row=3, column=0)
bouton8 = Button(fenetre, text="8")
bouton8.grid(row=3, column=1)
bouton9 = Button(fenetre, text="9")
bouton9.grid(row=3, column=2)
bouton0 = Button(fenetre, text="0")
bouton0.grid(row=4, column=1)
fenetre = Tk()
fenetre.geometry("350x300")
fenetre.title("Calculatrice")
calculatrice = Calculette()
calcLabel = Label(fenetre, text="Saisir le calcul")
calcLabel.pack()
calc = StringVar()
calc.set("")
saisie = Entry(fenetre, textvariable=calc, width=40)
saisie.pack()
buttons_frame = Frame(fenetre)
buttons_frame.pack()
#matrices des boutons
buttons = [
('7', 1, 0), ('8', 1, 1), ('9', 1, 2), ('/', 1, 3),
('4', 2, 0), ('5', 2, 1), ('6', 2, 2), ('*', 2, 3),
('1', 3, 0), ('2', 3, 1), ('3', 3, 2), ('-', 3, 3),
('0', 4, 0), ('.', 4, 1), ('+', 4, 2), ('=', 4, 3),
]
for (text, row, col) in buttons:
if text == '=':
Button(buttons_frame, text=text, width=10, height=3, command=calculer_expression).grid(row=row, column=col)
else:
Button(buttons_frame, text=text, width=10, height=3, command=lambda t=text: ajouter_au_calcul(t)).grid(row=row, column=col)
Button(fenetre, text="EFFACER", width=40, command=effacer).pack()
result_label = Label(fenetre, text="")
result_label.pack()
fenetre.mainloop()

BIN
modules/__pycache__/calculette.cpython-313.pyc

Binary file not shown.

76
modules/calculette.py

@ -0,0 +1,76 @@
from File import File_chaine as File
from Pile import Pile_chaine as Pile
class Expression:
"""Classe représentant une expression arithmétique"""
def __init__(self, valeur, gauche=None, droite=None):
self.valeur = valeur
self.gauche = gauche
self.droite = droite
def evalue(self):
"""Méthode permettant d'évaluer l'expression"""
if type(self.valeur) == int:
return self.valeur
if self.valeur == '+':
return self.gauche.evalue() + self.droite.evalue()
elif self.valeur == '*':
return self.gauche.evalue() * self.droite.evalue()
elif self.valeur == '/':
if self.droite.valeur == 0:
raise ValueError ("division par 0 impossible !! ")
return self.gauche.evalue() / self.droite.evalue()
elif self.valeur == '-':
return self.gauche.evalue() - self.droite.evalue()
def __str__(self):
"""Méthode permettant d'afficher l'expression"""
if type(self.valeur) == int:
return str(self.valeur)
if self.valeur == '+':
return "("+ str (self.gauche) + "+" + str (self.droite) + ")"
if self.valeur == '*':
return "("+ str (self.gauche) + "*" + str (self.droite) + ")"
if self.valeur == '/':
return "("+ str (self.gauche) + "/" + str (self.droite) + ")"
if self.valeur == '-':
return "("+ str (self.gauche) + "-" + str (self.droite) + ")"
def __repr__(self):
"""Méthode permettant d'afficher l'expression"""
return str(self)
if __name__ =="__main__":
e = Expression('*',Expression(6, None, None),Expression('+',Expression(4, None, None),Expression(3, None, None)))
def npi2tree(lst):
"""fonction npi2tree prenant en paramètre une liste correspondant l’expression en notation
polonaise inversée et renvoyant larbre (de type Expression) correspondant"""
exp = []
for ele in lst :
if ele in ["+","-","/","*"]:
ex = Expression(ele, exp.pop(), exp.pop())
exp.append(ex)
else:
exp.append(int(ele))
return exp.pop()
class Calculette:
"""Classe représentant une calculette"""
def __init__(self):
pass
def calculer(self, expression):
"""Méthode permettant de calculer une expression"""
try:
return eval(expression)
except Exception as e:
return str(e)
if __name__ == "__main__":
npi2tree(["3","4","+","6","*"])
Loading…
Cancel
Save