Python实现中缀表达式转后缀表达式

中缀表达式转后缀表达式
初始化两个栈，一个放后缀表达式exp，一个放操作符ops
1遇到数字，放到exp中
2遇到左括号，放入ops
3遇到右括号，就把ops的弹出到exp中，直到遇到左括号，这样消除一对括号

4遇到操作符，比较当前的ops，和栈顶ops的优先级，如果当前的比较高，就入ops，不然，就把栈顶的弹出，直到可以入。
5扫描完以后，ops还有运算符，直接放入exp。

            
              ops_rule = {
    '+': 1,
    '-': 1,
    '*': 2,
    '/': 2
}
def middle_to_after(s):
    expression = []
    ops = []
    ss = s.split(' ')
    for item in ss:
        if item in ['+', '-', '*', '/']:
            while len(ops) >= 0:
                if len(ops) == 0:
                    ops.append(item)
                    break
                op = ops.pop()
                if op == '(' or ops_rule[item] > ops_rule[op]:
                    ops.append(op)
                    ops.append(item)
                    break
                else:
                    expression.append(op)
        elif item == '(':
            ops.append(item)
        elif item == ')':
            while len(ops) > 0:
                op = ops.pop()
                if op == '(':
                    break
                else:
                    expression.append(op)
        else:
            expression.append(item)

    while len(ops) > 0:
        expression.append(ops.pop())

    return expression


def expression_to_value(expression):
    stack_value = []
    for item in expression:
        if item in ['+', '-', '*', '/']:
            n2 = stack_value.pop()
            n1 = stack_value.pop()
            result = cal(n1, n2, item)
            stack_value.append(result)
        else:
            stack_value.append(int(item))
    return stack_value[0]


def cal(n1, n2, op):
    if op == '+':
        return n1 + n2
    if op == '-':
        return n1 - n2
    if op == '*':
        return n1 * n2
    if op == '/':
        return n1 / n2


if __name__ == '__main__':
    expression = middle_to_after('9 + ( 3 * ( 4 - 2 ) ) * 3 + 10 / 2')
    value = expression_to_value(expression)
    print(value)
            
          

https://www.bbsmax.com/A/QV5ZeyqVJy/