在python中检查（“ and”，“ or”）优先级的简单方法

Question

I have a python list like this

[True, "and", False, "or", False, "or", True ....]

How to operate them and find the boolean value (True and False or False or True ...) efficiently ?

I know and has more precedence than or. So I know about the way where we break the list about every or and take or of booleans computed from each list.

I want to know is there a more easy way to do so ?

if my_list = [True, "and", False, "or", False, "or", True ] this will output
True as (True and False) or False or True = False or False or True which is True. 

if my_list = [True, "and", True, "or", False, "or", False ] this will output 
True as (True and True) or False or False = True or False or False which is True

if my_list = [False, "or", False, "and", False, "and", True ] = False or False which is False

Answer 1

One way to do operator precedence is through the shunting-yard algorithm , which requires a stack:

def evaluate(e):
    ops = {'and': 1, 'or': 0} 
    op_stack = []
    output = []
    for i in e:
        if i in ops:
            while op_stack and ops[op_stack[-1]] > ops[i]:
                output.append(op_stack.pop())
            op_stack.append(i)
        else:
            output.append(i)
    op_stack.reverse()
    output.extend(op_stack)

    stack = []
    for i in output:
        #print(stack, i)
        if i in ops:
            a, b = stack.pop(), stack.pop()
            if i == 'and':
                i = a and b
            else:
                i = a or b
        stack.append(i)
    return stack[0]

>>> evaluate([True, "and", False, "or", False, "or", True])
True
>>> evaluate([True, 'or', True, 'and', False])
True

The other way to do operator precedence is a recursive precedence climbing algorithm:

ops = {'and': 1, 'or': 0}

def tokenizer(l):
    for i in l:
        o = yield i
        while o:
            yield None
            o = yield o

def evaluate(token, prec=0):
    lhs = next(token)

    while True:
        op = next(token, None)
        if op is None or ops[op] < prec:
            if op: token.send(op)
            break

        rhs = evaluate(token, ops[op]+1)
        #print(lhs, op, rhs)
        lhs = lhs and rhs if op == 'and' else lhs or rhs
    return lhs

>>> evaluate(tokenizer([True, 'or', True, 'and', False]))
True
>>> evaluate(tokenizer([True, "and", False, "or", False, "or", False, "or",
...                     True, "and", False, "or", False, "or", False]))
False

With the prints:

>>> evaluate(tokenizer([True, "and", False, "or", False, "or", False, "or",
...                     True, "and", False, "or", False, "or", False]))
True and False
False or False
False or False
True and False
False or False
False or False
False or False
False

Answer 2

IIUC you could use map , isinstance :

l = [True, "and", False, "or", False, "or", True]
res = list(map(lambda x: isinstance(x, bool), l))

print(res)
[True, False, True, False, True, False, True]

Answer 3

Not sure if this will be faster, but:

l = [True, "and", False, "or", False, "or", False, "or", True, "and", False, "or", False, "or", False]
eval(' '.join([ str(z) for z in l]))

result:

False

Answer 4

If I understand correctly this should be the simplest (less elegant) solution

expression = [True, "and", False, "or", False, "or", True]


def eval_expr( value1, operator, value2):
    if operator == 'and':
        return value1 and value2

    else:
        return value1 or value2


result = None

while len(expression) != 1:
    v1 = expression.pop()
    op =  expression.pop()
    v2 = expression.pop()
    partial_result = eval_expr(v1, op, v2)
    expression.insert(0, partial_result)
    result = partial_result

print result

Answer 5

@Iliyan 's answer is correct. Less hacky than me.

I came up with a trick to do so.

my_list = [True, "and", False, "or", False, "or", True]

1. I created a file temp.py
2. Entered all values in list of my_list in order space separated in temp.py
3. Executed temp.py
4. Deleted temp.py

Kind of a hack ;)