Python利用中缀表达式求值

好的，这是关于Python编程的技术问题，我可以回答。对于中缀表达式求值，可以使用栈数据结构和逆波兰表达式来实现。具体做法是，首先将中缀表达式转换成后缀表达式（逆波兰表达式），然后再利用栈对后缀表达式进行求值。如果表达式中包含括号，则需要遵循一定的规则进行计算。如果您需要更详细的解释，可以提供更具体的表达式，我可以给您举例说明。

相关问题

python 中缀表达式求值

在 Python 中，可以通过使用栈来实现中缀表达式求值。具体步骤如下：

1. 定义一个操作符优先级字典，用于判断两个操作符的优先级，方便后续比较。
2. 定义一个数字栈和操作符栈。
3. 从左到右遍历中缀表达式中的每一个元素。
4. 如果当前元素是数字，则将该数字入栈。
5. 如果当前元素是左括号，则将左括号入操作符栈。
6. 如果当前元素是右括号，则执行以下操作：
a. 将操作符栈中的元素弹出，直到遇到左括号为止。弹出的操作符依次与数字栈中的两个数字进行计算，并将计算结果入栈。
b. 将左括号弹出。
7. 如果当前元素是操作符，则执行以下操作：
a. 如果当前操作符的优先级小于或等于栈顶操作符的优先级，则将栈顶操作符弹出，并将其与数字栈中的两个数字进行计算，并将计算结果入栈。
b. 否则将当前操作符入操作符栈。
8. 最终，数字栈中剩余的唯一元素即为表达式的计算结果。

以下是 Python 的代码实现：

def infix_eval(expression):
    precedence = {'+': 1, '-': 1, '*': 2, '/': 2, '**': 3}
    num_stack = []
    op_stack = []
    tokens = expression.split()

    for token in tokens:
        if token.isdigit():
            num_stack.append(int(token))
        elif token == '(':
            op_stack.append(token)
        elif token == ')':
            while op_stack[-1] != '(':
                op = op_stack.pop()
                num2 = num_stack.pop()
                num1 = num_stack.pop()
                result = apply_op(op, num1, num2)
                num_stack.append(result)
            op_stack.pop()
        elif token in precedence:
            while op_stack and op_stack[-1] != '(' and precedence[token] <= precedence[op_stack[-1]]:
                op = op_stack.pop()
                num2 = num_stack.pop()
                num1 = num_stack.pop()
                result = apply_op(op, num1, num2)
                num_stack.append(result)
            op_stack.append(token)

    while op_stack:
        op = op_stack.pop()
        num2 = num_stack.pop()
        num1 = num_stack.pop()
        result = apply_op(op, num1, num2)
        num_stack.append(result)

    return num_stack[0]

def apply_op(op, num1, num2):
    if op == '+':
        return num1 + num2
    elif op == '-':
        return num1 - num2
    elif op == '*':
        return num1 * num2
    elif op == '/':
        return num1 / num2
    elif op == '**':
        return num1 ** num2

使用python语言实现中缀表达式求值

可以通过以下步骤使用 Python 实现中缀表达式求值：

1. 定义一个函数 `infix_eval(expr)`，其中 `expr` 是中缀表达式的字符串形式。
2. 创建两个空栈，一个用于存储操作数，一个用于存储操作符。
3. 定义一个函数 `priority(op)`，用于返回操作符的优先级。例如，`priority('+')` 返回 1，`priority('*')` 返回 2。
4. 遍历中缀表达式的每个字符，如果是数字则将其作为操作数入栈，如果是操作符则将其与操作符栈顶元素比较优先级，如果优先级较高则入栈，否则将操作符栈中的操作符弹出并计算，直到当前操作符可以入栈。
5. 当遍历完中缀表达式后，将操作符栈中的所有操作符依次弹出并计算。

下面是 Python 代码实现：

def infix_eval(expr):
    operands = []
    operators = []
    i = 0
    while i < len(expr):
        if expr[i].isdigit():
            num = ""
            while i < len(expr) and expr[i].isdigit():
                num += expr[i]
                i += 1
            operands.append(int(num))
        elif expr[i] in "+-*/":
            while operators and priority(operators[-1]) >= priority(expr[i]):
                op = operators.pop()
                b = operands.pop()
                a = operands.pop()
                operands.append(eval_expr(a, b, op))
            operators.append(expr[i])
            i += 1
        else:
            i += 1
    while operators:
        op = operators.pop()
        b = operands.pop()
        a = operands.pop()
        operands.append(eval_expr(a, b, op))
    return operands[0]

def priority(op):
    if op in "+-":
        return 1
    elif op in "*/":
        return 2
    else:
        return 0

def eval_expr(a, b, op):
    if op == "+":
        return a + b
    elif op == "-":
        return a - b
    elif op == "*":
        return a * b
    elif op == "/":
        return a / b

# 测试
print(infix_eval('1+2*3'))  # 输出 7
print(infix_eval('(1+2)*3'))  # 输出 9

注意，上述代码只适用于整数运算，如果要支持小数运算，可以将 `int(num)` 改为 `float(num)`。