向表达式解析器添加中缀运算符

import re
from typing import List, Union

class Token:
    def __init__(self, type: str, value: Union[str, int]):
        self.type = type
        self.value = value

def tokenize(expression: str) -> List[Token]:
    tokens = []
    token_specification = [
        ('NUMBER',   r'\d+(\.\d*)?'),  # Integer or decimal number
        ('OPERATOR', r'[+*/()-]'),     # Arithmetic operators
        ('SKIP',     r'\s+'),          # Skip over spaces
    ]
    tok_regex = '|'.join(f'(?P<{pair[0]}>{pair[1]})' for pair in token_specification)
    for mo in re.finditer(tok_regex, expression):
        kind = mo.lastgroup
        value = mo.group(kind)
        if kind == 'NUMBER':
            value = float(value) if '.' in value else int(value)
        elif kind == 'SKIP':
            continue
        tokens.append(Token(kind, value))
    return tokens

def parse(tokens: List[Token]) -> 'Expression':
    # This is a simplified example; a real parser would be more complex
    class Expression:
        def evaluate(self) -> float:
            raise NotImplementedError
    
    class NumberExpression(Expression):
        def __init__(self, value: float):
            self.value = value
        
        def evaluate(self) -> float:
            return self.value
    
    class BinaryOperation(Expression):
        def __init__(self, left: Expression, operator: str, right: Expression):
            self.left = left
            self.operator = operator
            self.right = right
        
        def evaluate(self) -> float:
            left_value = self.left.evaluate()
            right_value = self.right.evaluate()
            if self.operator == '+':
                return left_value + right_value
            elif self.operator == '-':
                return left_value - right_value
            elif self.operator == '*':
                return left_value * right_value
            elif self.operator == '/':
                return left_value / right_value
            else:
                raise ValueError(f"Unknown operator: {self.operator}")
    
    # Simple recursive descent parser
    def parse_expression(index: int) -> (Expression, int):
        token = tokens[index]
        if token.type == 'NUMBER':
            return NumberExpression(token.value), index + 1
        elif token.type == 'OPERATOR':
            left, index = parse_expression(index - 1)
            right, index = parse_expression(index + 1)
            return BinaryOperation(left, token.value, right), index
        else:
            raise ValueError(f"Unexpected token: {token}")
    
    ast, _ = parse_expression(0)
    return ast

# Example usage
expression = "3 + 5 * (10 - 6)"
tokens = tokenize(expression)
ast = parse(tokens)
result = ast.evaluate()
print(f"Result: {result}")  # Output: Result: 23.0