关键点在于，我们借助两个栈，一个栈存放操作数，一个栈存放运算符。每次计算都是从运算符栈弹出一个运算符，从操作数栈弹出两个操作数，计算后的结果压回操作数栈。

    输入以空格隔开。

    3. def get_value(operator, num1, num2):
    4.     '''实现两个数的四则运算'''
    5.     if operator == '+':
    6.         return num1 + num2
    7.     elif operator == '-':
    8.         return num1 - num2
    9.     elif operator == '*':
    10.         return num1 * num2
    11.     elif operator == '/':
    12.         return num1 / num2
    15. def infix_evaluator(infix_expression: str) -> int:
    16.     """ 中缀表达式函数求值 """
    17.     token_list = infix_expression.split()
    18.     operator_priority = {'*': 3, '/': 3, '+': 2, '-': 2, '(': 1}
    19.     digital_stack = []
    20.     operator_stack = []
    21.     for token in token_list:
    22.         if token.isdecimal() or token[1:].isdecimal():
    23.             # 正数、负数都入栈
    24.             digital_stack.append(int(token))
    25.         elif token == '(':
    26.             operator_stack.append(token)
    27.         elif token == ')':
    28.             # 碰到右括号，把栈顶左括号上面的运算符都出栈
    29.             top = operator_stack.pop()
    30.             while top != '(':
    31.                 op1 = digital_stack.pop()
    32.                 op2 = digital_stack.pop()  # 弹出两个数用于计算
    33.                 tmp_ans = get_value(top, op1, op2)
    34.                 digital_stack.append(tmp_ans)
    35.                 top = operator_stack.pop()  # 弹出下一个栈顶运算符
    36.         elif token in '+-*/':
    37.             # 比较当前运算符token与opeartor_stack栈顶中运算符的优先级
    38.             # 如果栈顶优先级相等或较高，则可以执行两数运算
    39.             while operator_stack and operator_priority[operator_stack[-1]] >= operator_priority[token]:
    40.                 top = operator_stack.pop()
    41.                 op2 = digital_stack.pop()
    42.                 op1 = digital_stack.pop()
    43.                 tmp_ans = get_value(top, op1, op2)
    44.                 digital_stack.append(tmp_ans)
    45.             operator_stack.append(token)
    47.     #  表达式遍历完，栈里剩下的操作符也要求值
    48.     while operator_stack:
    49.         top = operator_stack.pop()
    50.         op2 = digital_stack.pop()
    51.         op1 = digital_stack.pop()
    52.         digital_stack.append(get_value(top, op1, op2))
    54.     return digital_stack[0]
    57. if __name__ == '__main__':
    58.     s = input()
    59.     print(infix_evaluator(s))