@mps: tu as écrit: >>> a = (mul, 4, (sub, 3, 1)) Comment as-tu obttenu cette expression? On a au départ: 4*(3-1) C'est la conversion de l'un dans l'autre qu'il faut faire.
Le Tout est souvent plus grand que la somme de ses parties.
Le PO ne dit pas comment il a construit expression = AB('*', feuille(4), AB('-', feuille(3), feuille(1))). C'est l'objet qu'il passe à son calc supposé évaluer l'expression.
Selon moi, le plus compliqué (comme l'a dit mps) n'est pas d'évaluer l'expression. C'est plutôt de construire un arbre qui soit valide. Et j'insiste sur l'idée que d'associer une priorité à chaque élément facilite grandement la tâche. Pour la validation, on parcourt l'arbre récursivement. Si une feuille a des fils, il manque un opérateur. Si un opérateur manque d'un fils (ou deux), il manque un opérand. Rien d'auttre, mais il faut le faire ...
Je vois trois étapes:
+ parsing: analyse et reconnaissance des éléments sémantiques.
+ construction de l'arbre des priorités.
+ évaluation de l'expression.
- Edité par PierrotLeFou 30 décembre 2021 à 7:39:17
Le Tout est souvent plus grand que la somme de ses parties.
Merci mps pour l'info, je pensais que c'était pour des float. Ce que YesyesyesOkokok veut faire est évaluer l'expression avec un arbre. Ce que tu suggères oblige à construire l'expression sous forme de chaîne et utiliser eval() pour l'évaluer. Ce que j'ai fait ne respecte pas tout à fait la philosophie de la POO, mais c'est nettement plus simple. Je réussis à tout coder en incluant la validation en environ 75 lignes.
C'est finalement plus long que je pensais. Ça inclus les exposants ('**') - from operator import * class Node: def __init__(self, value='', priority=0, father=None, left=None, right=None): self.value = value self.priority = priority self.father = father self.left = left self.right = right # Analyse de l'expression. def parsing(expression): digits = "0123456789" number = "" tokens = [] p = "" for c in expression: if c in digits: number += c p = c continue if number: tokens.append(int(number)) number = "" if c in "+-*/%()": if p+c in ('//', '**'): c = c+p tokens[-1] = c else: tokens.append(c) elif c != ' ': print(f"'{c}' est invalide") exit() p = c if number: tokens.append(int(number)) if tokens.count('(') != tokens.count(')'): print("Parenthèses non jumelées") exit() return tokens # Validation de l'arbre. def check(node): if isinstance(node.value, int): if node.left is not None or node.right is not None: print(f"'{node.value}' opérateur absent") return False else: return True elif node.left is None or node.right is None: print(f"'{node.value}' opérand absent") return False else: return check(node.left) and check(node.right) # Génération de l'arbre. def tree(tokens): dicPri = {'+': 1, '-': 1, '*': 2, '/': 2, '%': 2, '//': 2, '**': 3} base = 0 root = Node(value='=') current = root for el in tokens: if el == '(': base += 10 continue elif el == ')': base -= 10 continue elif el in dicPri.keys(): added = Node(value=el, priority=base+dicPri[el]) else: added = Node(value=el, priority=base+9) while added.priority < current.priority: current = current.father added.left = current.right if added.left is not None: added.left.father = added current.right = added added.father = current current = added if not check(root.right): exit() return root # Évaluation de l'expression. def my_eval(node): dicOpe = {'+': add, '-': sub, '*': mul, '/': truediv, '%': mod, '//': floordiv, '**': pow} if isinstance(node.value, int): return node.value else: return dicOpe[node.value](my_eval(node.left), my_eval(node.right)) # Code principal. expression = input("Entrez une expression") tokens = parsing(expression) root = tree(tokens) print(my_eval(root.right))
Le Tout est souvent plus grand que la somme de ses parties.
× Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
× Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
Le Tout est souvent plus grand que la somme de ses parties.
Le Tout est souvent plus grand que la somme de ses parties.
Le Tout est souvent plus grand que la somme de ses parties.