测试在循环内不会改变的条件

Question

Sometimes I have to check for some condition that doesn't change inside a loop, this means that the test is evaluated in every iteration, but I think this isn't the right way.

I thought since the condition doesn't change inside the loop I should only test it only once outside the loop, but then I will have to "repeat myself" and possibly write the same loop more than once. Here's a code showing what I mean:

#!/usr/bin/python

x = True      #this won't be modified  inside the loop
n = 10000000

def inside():
    for a in xrange(n):
        if x:    #test is evaluated n times
            pass
        else:
            pass

def outside():
    if x:        #test is evaluated only once
        for a in xrange(n):  
            pass
    else:
        for a in xrange(n):
            pass

if __name__ == '__main__':
    outside()
    inside()

Running cProfile on the previous code gave the following output:

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
        1    0.542    0.542    0.542    0.542 testloop.py:5(inside)
        1    0.261    0.261    0.261    0.261 testloop.py:12(outside)
        1    0.000    0.000    0.803    0.803 testloop.py:3(<module>)

This shows that obviously, testing once outside the loop gives better performance, but I had to write the same loop twice (maybe more if there were some elif s).

I know that this performance won't matter in most cases, but I need to know what's the best way to write this kind of code. For example is there a way to tell python to only evaluate the test once ?

Any help is appreciated, thanks.

EDIT:

Actually after making some tests, I'm now convinced that the difference in performance is mainly affected by other code performed within the loops, not by the evaluation of tests. So for now I'm sticking with the first form, which is more readable, and better for debugging later.

Answer 1

First, a major component of the performance difference between your examples is the time it takes to lookup a global. If we capture it into a local variable:

def inside_local():
    local_x = x
    for a in xrange(n):
        if local_x:
            pass
        else:
            pass

ncalls  tottime  percall  cumtime  percall filename:lineno(function)
    1    0.258    0.258    0.258    0.258 testloop.py:13(outside)
    1    0.314    0.314    0.314    0.314 testloop.py:21(inside_local)
    1    0.421    0.421    0.421    0.421 testloop.py:6(inside)

most of the performance difference disappears.

In general whenever you have common code you should try to encapsulate it. If the branches of the if have nothing in common apart from the loop then try to encapsulate the loop iterator eg into a generator.

Answer 2

This is what I usally do in this situation.

def inside():
    def x_true(a):
        pass

    def x_false(a):
        pass

    if x:
        fn = x_true
    else:
        fn = x_false

    for a in xrange(n):
        fn(a)

Answer 3

python has things like closures, lambda functions, gives first class status to functions and many many built-in functions, that really help us remove duplicate code, for example imagine you needed to apply a function to a sequence of values, you could do it this way

def outside():              
    if x:        # x is a flag or it could the function itself, or ...
        fun = sum # calc the sum, using pythons, sum function
    else:
        fun = lambda values: sum(values)/float(len(values)) # calc avg using our own function

    result = fun(xrange(101))

If you give us an exact scenario we can help you optimize it.

Answer 4

I know of no interpreted language providing support in that direction, compiled languages are likely to make the comparison only once (loop invariant optimization) but this would not help much, if the evaluation of x is simple. Obviously the code to be in place of the pass statements can't be completely identical, since "if" would have no use then. Typically one would write a procedure called in both places.

Answer 5

def outside():
    def true_fn(a):
        pass
    def false_fn(a):
        pass

    fn = true_fn if x else false_fn
    for a in xrange(n):
        fn(a)

Answer 6

In your case It depends on what you want: readability or performance.

If the task you are doing is some kind of filter you also can use a list_comprehension to run the loop:

[e for e in xrange(n) if x]

If you show a little more of your code I could suggest something.

Answer 7

Based on your original question, that you would like to test x's value without spending a lot of system resources, you already accepted an answer involving copying the value of global x to a local variable.

Now, if returning the value of x involved a multi-step function, but you were guaranteed the result would always be the same for x, then I would considering memoizing the function. Here is a very nice stackoverflow link on the subject