List comprehension disasm vs. naive disasm

lc-disasm.py

>>> from dis import dis
>>> def foo(n):
...     a = []
...     for i in range(n):
...         a.append(i * 2)
...     return a
... 
>>> def bar(n):
...     return [i * 2 for i in range(n)]
... 
>>> dis(foo)
  2           0 BUILD_LIST               0
              3 STORE_FAST               1 (a)

  3           6 SETUP_LOOP              37 (to 46)
              9 LOAD_GLOBAL              0 (range)
             12 LOAD_FAST                0 (n)
             15 CALL_FUNCTION            1
             18 GET_ITER            
        >>   19 FOR_ITER                23 (to 45)
             22 STORE_FAST               2 (i)

  4          25 LOAD_FAST                1 (a)
             28 LOAD_ATTR                1 (append)
             31 LOAD_FAST                2 (i)
             34 LOAD_CONST               1 (2)
             37 BINARY_MULTIPLY     
             38 CALL_FUNCTION            1
             41 POP_TOP             
             42 JUMP_ABSOLUTE           19
        >>   45 POP_BLOCK           

  5     >>   46 LOAD_FAST                1 (a)
             49 RETURN_VALUE        
>>> dis(bar)
  2           0 BUILD_LIST               0
              3 LOAD_GLOBAL              0 (range)
              6 LOAD_FAST                0 (n)
              9 CALL_FUNCTION            1
             12 GET_ITER            
        >>   13 FOR_ITER                16 (to 32)
             16 STORE_FAST               1 (i)
             19 LOAD_FAST                1 (i)
             22 LOAD_CONST               1 (2)
             25 BINARY_MULTIPLY     
             26 LIST_APPEND              2
             29 JUMP_ABSOLUTE           13
        >>   32 RETURN_VALUE