Question

I know about inlining, and from what I checked it is not done by the Python’s compiler.

My question is : is there any optimizations with the python’s compiler which transforms :

print myList.__len__()
for i in range(0, myList.__len__()):
    print i + myList.__len__()

to

l = myList.__len__()
print l
for i in range(0, l):
    print i + l

So is it done by the compiler ?
If it is not : is it worth it to do it by myself ?

Bonus question (not so related) : I like to have a lot of functions (better for readability IMHO)… like there is no inlining in Python is this something to avoid (lots of functions) ?

Answer 1

No, there isn’t. You can check what Python does by compiling the code to byte-code using the dis module:

>>> def test():
...     print myList.__len__()
...     for i in range(0, myList.__len__()):
...         print i + myList.__len__()
... 
>>> import dis
>>> dis.dis(test)
  2           0 LOAD_GLOBAL              0 (myList)
              3 LOAD_ATTR                1 (__len__)
              6 CALL_FUNCTION            0
              9 PRINT_ITEM          
             10 PRINT_NEWLINE       

  3          11 SETUP_LOOP              44 (to 58)
             14 LOAD_GLOBAL              2 (range)
             17 LOAD_CONST               1 (0)
             20 LOAD_GLOBAL              0 (myList)
             23 LOAD_ATTR                1 (__len__)
             26 CALL_FUNCTION            0
             29 CALL_FUNCTION            2
             32 GET_ITER            
        >>   33 FOR_ITER                21 (to 57)
             36 STORE_FAST               0 (i)

  4          39 LOAD_FAST                0 (i)
             42 LOAD_GLOBAL              0 (myList)
             45 LOAD_ATTR                1 (__len__)
             48 CALL_FUNCTION            0
             51 BINARY_ADD          
             52 PRINT_ITEM          
             53 PRINT_NEWLINE       
             54 JUMP_ABSOLUTE           33
        >>   57 POP_BLOCK           
        >>   58 LOAD_CONST               0 (None)
             61 RETURN_VALUE        

As you can see, the __len__ attribute is looked up and called each time.

Python cannot know what a given method will return between calls, the __len__ method is no exception. If python were to try to optimize that by assuming the value returned would be the same between calls, you’d run into countless different problems, and we haven’t even tried to use multi-threading yet.

Note that you would be much better off using len(myList), and not call the __len__() hook directly:

print len(myList)
for i in xrange(len(myList):
    print i + len(myList)