利用栈实现表达式求值代码实现

好的，以下是利用栈实现表达式求值的代码实现：

def evaluate_expression(expression):
    operators = []
    operands = []
    i = 0
    while i < len(expression):
        token = expression[i]
        if token.isdigit():
            operand = int(token)
            while i+1 < len(expression) and expression[i+1].isdigit():
                operand = operand * 10 + int(expression[i+1])
                i += 1
            operands.append(operand)
        elif token == '(':
            operators.append(token)
        elif token == ')':
            while operators[-1] != '(':
                op2 = operands.pop()
                op1 = operands.pop()
                operator = operators.pop()
                operands.append(apply_operator(operator, op1, op2))
            operators.pop()
        elif token in "+-*/":
            while len(operators) > 0 and precedence(token) <= precedence(operators[-1]):
                op2 = operands.pop()
                op1 = operands.pop()
                operator = operators.pop()
                operands.append(apply_operator(operator, op1, op2))
            operators.append(token)
        i += 1
    while len(operators) > 0:
        op2 = operands.pop()
        op1 = operands.pop()
        operator = operators.pop()
        operands.append(apply_operator(operator, op1, op2))
    return operands[-1]

def precedence(operator):
    if operator in "+-":
        return 1
    elif operator in "*/":
        return 2
    return 0

def apply_operator(operator, op1, op2):
    if operator == "+":
        return op1 + op2
    elif operator == "-":
        return op1 - op2
    elif operator == "*":
        return op1 * op2
    elif operator == "/":
        return op1 // op2

这个函数接受一个字符串参数 `expression`，代表一个简单的数学表达式，例如 "2+3*4" 或者 "(2+3)*4"。函数返回表达式的值。

在算法中，我们维护两个栈 `operators` 和 `operands`。`operators` 存储运算符， `operands` 存储操作数。我们遍历表达式的每个字符，如果这是一个数字，我们将这个数字压入 `operands` 栈中。如果这是一个左括号，我们将左括号压入 `operators` 中。如果这是一个右括号，我们将 `operators` 中的运算符弹出并应用在 `operands` 中对应的两个操作数上，直到遇到对应的左括号。如果这是一个运算符，我们将其与 `operators` 中的前一个运算符比较。如果它优先级较低，则将 `operators` 中的运算符弹出并应用于 `operands` 中的操作数。最后我们遍历完整个表达式后，我们将剩余的运算符依次应用到操作数上，直到 `operands` 中只剩下一个元素，即表达式的值。

希望这个代码能够满足你的需求，有任何问题，请随时给我留言。