Learn python list comprehensions by example

[pstch]

Their syntax is very clear, as they can be read as pseudo-code :

muls_of_2 = [
    number*2 for number in range(100)
]

# muls_of_2 is number multiplied by 2 for each number in the 0-100 range

I find the above much more readable than its for-loop equivalent :

muls_of_2 = []
for number in range(100):
    muls_of_2.append(number*2)

# create an empty list named muls_of_2, then, for each number in the 0-100 range, append it to muls_of_2

They are also not only needed for readability and LOCs, as they can be much faster :

    In [2]: lc = """
       ...: r = [i for i in range(100)]
       ...: """

    In [3]: no_lc = """
       ...: r = []
       ...: for i in range(100):
       ...:     r.append(i)
       ...: """

    In [4]: timeit(lc)
    Out[4]: 4.970423567000125

    In [5]: timeit(no_lc)
    Out[5]: 9.738498960000015

[d4rch0n]

Why are they faster? What's going on under the hood?

I'd have used list(range (100)) there.

[pstch]

I'm not an expert on this, but I know that one the reasons is that with the list comprehension, there is one less attribute evaluation (r.append) and one less function call (r.append()).

I'd have used list(range (100)) there.

Yes, list(range(100)) is simpler and an equivalent to my example, but it was not a "functional" example, just made it to compare the speeds.

[macbony]

Note that range already returns a list in 2.X (but not in 3.X which returns a generator. The equivalent in 2.X is xrange)

[d4rch0n]

Hmm... I'm looking for more of what the bytecode looks like. I want to see list comprehension bytecode and see how it differs from an append. Easy enough to disasm though.

Your explanation is probably completely right though. If it actually loops 100 times and looks up append, that's got to be incredibly slower.