解决后缀表达式解析器返回错误答案的问题

import re

token_patterns = [
    ('OPERATOR', r'[+\-*/]'),
    ('NUMBER', r'\d+'),
    ('WHITESPACE', r'\s+'),
]

def tokenize(source_code):
    tokens = []
    source_code = source_code.strip()

    while source_code:
        matched = False

        for token_type, pattern in token_patterns:
            match = re.match(pattern, source_code)
            if match:
                value = match.group(0)
                tokens.append((token_type, value))
                source_code = source_code[len(value):].lstrip()
                matched = True
                break

        if not matched:
            raise ValueError(f"Invalid character in source code: {source_code[0]}")

    return tokens

def parse_expression(tokens):
    stack = []
    for token_type, value in tokens:
        if token_type == 'NUMBER':
            stack.append(int(value))
        elif token_type == 'OPERATOR':
            if len(stack) < 2:
                raise ValueError("Not enough operands for operator")
            right = stack.pop()
            left = stack.pop()
            stack.append((value, left, right))
        else:
            raise ValueError(f"Unexpected token: {token_type}")

    if len(stack) != 1:
        raise ValueError("Invalid expression")

    return stack[0]


def evaluate_expression(expression):
    if isinstance(expression, int):
        return expression
    elif isinstance(expression, tuple):
        operator, left, right = expression
        if operator == '+':
            return evaluate_expression(left) + evaluate_expression(right)
        elif operator == '-':
            return evaluate_expression(left) - evaluate_expression(right)
        elif operator == '*':
            return evaluate_expression(left) * evaluate_expression(right)
        elif operator == '/':
            return evaluate_expression(left) / evaluate_expression(right)
    else:
        raise ValueError(f"Invalid expression: {expression}")

def main():
    source_code = "2 3 4 * +"
    tokens = tokenize(source_code)
    parsed_expression = parse_expression(tokens)

    print(f"Source code: {source_code}")
    print(f"Parsed expression: {parsed_expression}")

    result = evaluate_expression(parsed_expression)
    print(f"Result: {result}")

if __name__ == "__main__":
    main()

Source code: 2 3 4 * +
Parsed expression: ('+', 2, ('*', 3, 4))
Result: 14