Ytukyg

I'm trying calculate (using operators) the innermost list then the second innermost list etc. until there is no more lists. I'm also trying to do this so that it should be able to calculate the list no matter how many nested lists that's in it.

import operator



lst = [['x1', '*', ['x2', '*', 'x3']], '-', 'x3']

dictionary = {'x1': 4, 'x2': 5, 'x3': 7}

operator_dictionary = {"+": operator.add, "-": operator.sub, "*": 

operator.mul, "/": operator.truediv}



def BINARYEXPR(program, dictionary):

    for i in range(len(program)):

        if isinstance(program[i],list):

            return BINARYEXPR(program[i],dictionary)



    operator = operator_dictionary[program[1]]

    operand1 = dictionary[program[0]]

    print("operand1: ", operand1)

    operand2 = dictionary[program[2]]

    print("operand2: ", operand2)



    return operator(operand1,operand2)



print (BINARYEXPR(lst,dictionary))

So what I wanted to do here was to first calculate x2*x3 (5*7) which should give us 35, then calculate x1*35 (4*35) which should give us 140 and then finally take 140 - x3 (140-7) which should return 133. But instead I only managed to calculate the innermost list and hit return operator(operand1,operand2) which ends the function.

So what I'm stuck at is the recursion as I can't seem to figure out how to move on to the second innermost list whenever the innermost list has been calculated.

A recursive function as follows should do the job:

import operator





lst = [['x1', '*', ['x2', '*', 'x3']], '-', 'x3']

dictionary = {'x1': 4, 'x2': 5, 'x3': 7}

operator_dictionary = {"+": operator.add, "-": operator.sub, "*":

                       operator.mul, "/": operator.truediv}





def calc(lst):

    if type(lst) == str:

        return dictionary[lst]



    if len(lst) != 3:

        raise ValueError("Incorrect expression: {}".format(lst))



    op = operator_dictionary[lst[1]]

    return op(calc(lst[0]), calc(lst[2]))

Since you are using infix notation, each expression has three components: expression, operator, expression. The function works by assuming the 0th and 2nd elements are operands and the 1st element is the operator. We calculate the sub-expressions recursively, and then apply the operation. Also, if at any point our function receives a list with length different than 3, we throw since this cannot be a well-formed expression.