堆栈计算器（后缀，Python）

Question

我遇到的问题是计算后缀形式表达式：例如，(1, 2, '+', 3, '*')。

通过使用以下算法计算表达式： 1. 如果表达式仅包含整数，则返回该整数。2. 否则，维护一个堆栈。循环遍历元组并将每个元素推入堆栈。如果该元素是运算符，则将前两个元素弹出堆栈，计算结果并将结果压入堆栈。为了说明这一点，我们以上面的例子为例。最初，堆栈是空的。测试用例是

calculate((1, 2, '*', 3, '-', 2, '*', 5, '+'))  
3

而我的第一个代码不好（硬编码和所有 >< ）：

def calculate(inputs):
    if len(inputs) ==1:
        return inputs[0]
    elif len(inputs) == 5:
        s= []
        push_stack(s, inputs[0])
        push_stack(s, inputs[1])
        if inputs[2] == '*':
            A = s.pop() * s.pop()
        elif inputs[2] == '+':
            A = s.pop() + s.pop()
        elif inputs[2] == '-':
            A= s.pop() - s.pop()
        elif inputs[2] == '/':
            A = s.pop() / s.pop()
        s.clear()
        s= [A]
        push_stack(s, inputs[3])
        if inputs[4] == '*':
            A = s.pop() * s.pop()
        elif inputs[4] == '+':
            A = s.pop() + s.pop()
        elif inputs[4] == '-':
            A= s.pop() - s.pop()
        elif inputs[4] == '/':
            A = s.pop() / s.pop()
        return A
    else:
        s= []
        push_stack(s, inputs[0])
            push_stack(s, inputs[1])
        if inputs[2] == '*':
            A = s.pop() * s.pop()
        elif inputs[2] == '+':
            A = s.pop() + s.pop()
        elif inputs[2] == '-':
            A= s.pop() - s.pop()
        elif inputs[2] == '/':
            A = s.pop() / s.pop()
        s.clear()
        s= [A]
        push_stack(s, inputs[3])
        if inputs[4] == '*':
            A = s.pop() * s.pop()
        elif inputs[4] == '+':
            A = s.pop() + s.pop()
        elif inputs[4] == '-':
            A= s.pop() - s.pop()
        elif inputs[4] == '/':
            A = s.pop() / s.pop()
        s.clear()
        s= [A]
        push_stack(s, inputs[5])
        if inputs[6] == '*':
            A = s.pop() * s.pop()
        elif inputs[6] == '+':
            A = s.pop() + s.pop()
        elif inputs[6] == '-':
            A= s.pop() - s.pop()
        elif inputs[6] == '/':
            A = s.pop() / s.pop()
        s.clear()
        s= [A]
        push_stack(s, inputs[7])
        if inputs[8] == '*':
            A = s.pop() * s.pop()
        elif inputs[8] == '+':
            A = s.pop() + s.pop()
        elif inputs[8] == '-':
            A= s.pop() - s.pop()
        elif inputs[8] == '/':
            A = s.pop() / s.pop()
        return A

很抱歉让您读到这篇文章！然后我将样式更改为

def calculate(inputs):
    if len(inputs) ==1:
        return inputs[0]
    else:
        s =[]
        for i in inputs:
            if type(i) == int:
                return push_stack(s, i)
            elif i is '*' or '/' or 'x' or '+':
                A = s.pop()
                B =s.pop()
                know = operator(i, A, B)
                C = push_stack(s, know)
        return C

def operator(sign, one, two):
    if sign == '*':
        A = one * two
    elif sign == '+':
        A = one + two
    elif sign == '-':
        A= one - two
    elif sign == '/':
        A = one / two
    return A

我是否越来越接近这个想法以及我的代码如何改进？

** 编辑 ** 使用 IDLE：

>>> calculate((1, 2, '*', 3, '-'))
[1]
>>> calculate((1, 2, '+', 3, '*'))
[1]
>>> calculate((1, 2, '*', 3, '-', 2, '*', 5, '+'))
[1]

这不是我正在寻找的答案。应该是 1 然后 9 然后 3。

Answer 1

有一个问题

elif i is '*' or '/' or 'x' or '+':

这被视为

elif (i is '*') or ('/') or ('x') or ('+'):

这不是你想要的（这总是正确的）。你可以使用类似的东西：

elif i in ('*', '/', 'x', '+'):

还：

if type(i) == int:
    return push_stack(s, i)

你不应该回到那里。你只是想要：

if type(i) == int:
    push_stack(s, i)

最后，我认为更好的方法是始终使用堆栈，并在函数末尾返回堆栈顶部。这使您不必为 1 元素参数创建特殊情况calculate()。把这一切放在一起，类似这样的事情应该有效：

def calculate(inputs):
    stack = []
    for a in inputs:
        if type(a) is int:
            stack.append(a)
            continue

        op1, op2 = stack.pop(), stack.pop()

        if a == '+':
            stack.append(op2 + op1)
        elif a == '-':
            stack.append(op2 - op1)
        elif a == '*':
            stack.append(op2 * op1)
        elif a == '/':
            stack.append(op2 / op1)

    return stack.pop()

目前，这不会进行错误检查（例如，对于格式错误的表达式），但它很容易添加。