python中if语句的性能

Question

I prefer to assign conditions to variables when I have to write a long if statement.

But when the conditions are time-wasting, I think it is not good because the interpreter should run all the conditions even if just few conditions should be run.

In the codes below for example, the test1 is more readable but slower than test2 because con1 is True and test2 just run only one condition.

(I know the logic is ugly, because it is just for example)

def x(arg):
    '''
    A time-wasting method
    '''
    res = 0
    for i in range(2000000):
        res += i * arg
    return res

def test1():
    con1 = x(1) > 1000.24
    con2 = x(2) < 2000
    con3 = x(3) < 3000
    con4 = x(4) < 4000
    con5 = x(5) < 555
    con6 = x(6) < 666
    con7 = x(7) < 777
    con8 = x(8) < 888
    con9 = x(9) < 234
    con10 = x(10) < 345
    con11 = x(11) < 456
    con12 = x(12) < 445
    con13 = x(13) < 745
    con14 = x(14) < 3475
    con15 = x(15) < 334545
    con16 = x(16) < 323445
    con17 = x(17) < 37645
    con18 = x(18) < 3445
    con19 = x(19) < 37745
    con20 = x(20) < 3455

    if con1 or con2 or con3 or con4 or con5 or con6 or con7 or con8 or con9 or \
       con10 or con11 or con12 or con13 or con14 or con15 or con16 or con17 or \
       con18 or con19 or con20:
        print('test1')

def test2():
    if x(1) > 1000.24 or x(2) < 2000 or x(3) < 3000 or x(4) < 4000 or x(5) < 555 or \
       x(6) < 666 or x(7) < 777 or x(8) < 888 or x(9) < 234 or x(10) < 345 or \
       x(11) < 456 or x(12) < 445 or x(13) < 745 or x(14) < 3475 or x(15) < 334545 or \
       x(16) < 323445 or x(17) < 37645 or x(18) < 3445 or x(19) < 37745 or x(20) < 3455:
        print('test2')

What is the best way to deal with that?

Answer 1

Whenever you have a long list of or statements, you probably want to formulate those conditions as a list of uniform predicates and use any . Eg:

predicates = [
    (2, 2000),
    (3, 3000),
    ...
]

if x(1) > 1000.24 or any(x(y) < z for y, z in predicates):
    ...

In this case all but the first case differ only in the specific numbers used, so writing them this way is the most compact. You can of course also use a list of callables, which can do anything you need:

from functools import partial

predicates = [
    lambda: x(1) > 1000.24,
    lambda: x(2) < 2000,
    ...
    partial(sum, range(42)),
    ...
]

if any(p() for p in predicates):
    ...

Answer 2

Use any when you need to lazily or multiple expressions. You can feed it with a generator that goes through the parameters of comparison:

test_parameters = ((2, 2000), (3, 3000), (4, 4000), (5, 555))

if x(1) < 1000.24 or any(x(a) > b for a, b in test_parameters):
   ...

You can also use all to and expressions.

Answer 3

We can use containers and any function here like

from operator import gt, lt

def test3():
    domain = range(1, 21)
    predicates_with_bounds = [(gt, 1000.24),
                              (lt, 2000),
                              (lt, 3000),
                              (lt, 4000),
                              (lt, 555),
                              (lt, 666),
                              (lt, 777),
                              (lt, 888),
                              (lt, 234),
                              (lt, 345),
                              (lt, 456),
                              (lt, 445),
                              (lt, 745),
                              (lt, 3475),
                              (lt, 334545),
                              (lt, 323445),
                              (lt, 37645),
                              (lt, 3445),
                              (lt, 37745),
                              (lt, 3455)]
    if any(predicate(x(element), bound)
           for element, (predicate, bound) in zip(domain,
                                                  predicates_with_bounds)):
        print('test3')

or by "switching" < -> > and using functools.partial we can make container of predicates with bounds bounded (sorry for pun)

from functools import partial
from operator import gt, lt

def test4():
    domain = range(1, 21)
    predicates = [partial(lt, 1000.24),
                  partial(gt, 2000),
                  partial(gt, 3000),
                  partial(gt, 4000),
                  partial(gt, 555),
                  partial(gt, 666),
                  partial(gt, 777),
                  partial(gt, 888),
                  partial(gt, 234),
                  partial(gt, 345),
                  partial(gt, 456),
                  partial(gt, 445),
                  partial(gt, 745),
                  partial(gt, 3475),
                  partial(gt, 334545),
                  partial(gt, 323445),
                  partial(gt, 37645),
                  partial(gt, 3445),
                  partial(gt, 37745),
                  partial(gt, 3455)]
    if any(predicate(x(element))
           for element, predicate in zip(domain, predicates)):
        print('test4')

Answer 4

Assign lambda expressions to the variables, so they aren't executed until you call them in the if statement.

def test1():
    con1 = lambda: x(1) > 1000.24
    con2 = lambda: x(2) < 2000
    con3 = lambda: x(3) < 3000
    ...

    if con1() or con2() or con3() or ...:
        print('test1')

But really I think you need to re-examine the logic of your program. Why does it need so many conditions in a single if statement? Is there some pattern to it that you can extract to simplify it?

Another method would be to make a list that represents all the comparisons:

cons = [('>', 1000.24), ('<', 2000), ('<', 3000), ...]
def test1():
    for i, test in enumerate(cons):
        if test[0] == '<':
            if x(i+1) < test[1]:
                print('test')
                break
        elif x(i+1) > test[1]:
            print('test')
            break

Answer 5

You can make it data driven with something like:

# Each item has index, less-than-value and greater-than-value.
data = [[1, None, 1000.24], [2, 2000, None], … [19, 37745, None], [20, 3455, None]]

outcome = False
for item in data:
    if item[1] is not None: outcome = outcome or x[item[0]] < item[1]
    if item[2] is not None: outcome = outcome or x[item[0]] > item[2]

# Outcome now contains result of all data driven comparisons, or'ed together.