@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 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

PierrotLeFou a écrit:

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.

Pouvons nous avoir un aperçus de celui ci ?

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))