Python 如何以前缀表示法获取修改后的输入

我正在尝试制作一个执行数学运算的程序。
作为输入，我得到了一个前缀符号，比如

['+'，['-'，['multiply'，3,5]，8]，2]

我的问题在我执行了最内部的操作之后，我如何才能重新修改我的原始输入？例如，这里我希望我的代码将

3

与

5

相乘，（

=15

）从结果中减去

8

，最后将

2

相加。为此，我首先计算

['multiply'，3,5]

。在我必须用输入运行函数之后，

['+'，['-'，15,8]，2]

。然而，几个小时过去了，我找不到路

def kenobi(k):
    def think(k):   
        if type(k[1]) == int:
            k = calculator(k)
            return kenobi(k) #here I actually want to return [+,[-,15,8],2]
        if type(k[1][0]) == str:
            return kenobi(k[1][1])

    def calculator(k):
        if k[0] == '*':
            k = k[1]*k[2]
            return k
        if k[0] == '-':
            k = k[1]-k[2]
            return k
        if k[0] == '+':
            k = k[1]+k[2]
            return k
    return think(k)

print kenobi(['+',['-',['*',3,5],8],2])

---

您可以通过检查是否有其他列表来使用递归函数。如果没有，则进行数学运算，并用答案替换刚才计算的列表的位置

import operator
def kenobi(l):
    if isinstance(l[1],list):
        l[1] = kenobi(l[1])
    return do_math(l)

def do_math(l):
    #print l
    ops = {'+': operator.add, '-': operator.sub, '*': operator.mul, '/': operator.div}
    return ops[l[0]](l[1],l[2])

print kenobi(['+',['-',['*',3,5],8],2])

9

或者，如果您将有不在索引1中的列表，则可以将其更改为

import operator

def kenobi(l):
    ops = {'+': operator.add, '-': operator.sub, '*': operator.mul, '/': operator.div}

    for i in xrange(1,len(l)):
        if isinstance(l[i],list):
            l[i] = kenobi(l[i])

    return ops[l[0]](l[1],l[2])

print kenobi(['+',['-',['*',['*',5,5],['+',3,5]],8],2])

194

---

有一个非常简单的评估策略。首先，请注意前缀符号定义了一个树：

因此，构建该树并递归地对其进行评估很有吸引力：

def evaluate(root):
    if root == '+':
        return evaluate(left) + evaluate(right)
    elif root == '-':
        return evaluate(left) - evaluate(right)
    elif root == '*':
        return evaluate(left) * evaluate(right)
    elif root == '/':
        return evaluate(left) / evaluate(right)
    else:
        return root

不过，您不必构建树：

def evaluate(seq):
    if type(seq) == list:
        op, left, right = seq[0], seq[1], seq[2]

        if op == '+':
            return evaluate(left) + evaluate(right)
        elif op == '-':
            return evaluate(left) - evaluate(right)
        elif op == '*':
            return evaluate(left) * evaluate(right)
        elif op == '/':
            return evaluate(left) / evaluate(right)
    else:
        return seq

---

来自Arman：您应该使用堆栈在函数调用中存储变量的最佳方法是堆栈，下面是一个示例：

def evaluate(seq):
    if type(seq) == list:
        op, left, right = seq[0], seq[1], seq[2]

        if op == '+':
            return evaluate(left) + evaluate(right)
        elif op == '-':
            return evaluate(left) - evaluate(right)
        elif op == '*':
            return evaluate(left) * evaluate(right)
        elif op == '/':
            return evaluate(left) / evaluate(right)
    else:
        return seq