Comprehensions vs Loops: Readability and Speed

The two versions do the same thing, and the comprehension is consistently quicker.

import time

data = range(500_000)

start = time.perf_counter()
result = []
for value in data:
    result.append(value * 2)
loop_seconds = time.perf_counter() - start

start = time.perf_counter()
fast = [value * 2 for value in data]
comp_seconds = time.perf_counter() - start

print(f"loop:         {loop_seconds:.4f}s")
print(f"comprehension: {comp_seconds:.4f}s")
print(len(result), len(fast))

Both produce 500,000 doubled values. The comprehension is usually around twice as fast on CPython, though the exact numbers depend on your machine and Python version, so treat the output as a demonstration rather than a figure to quote.

The reason is the bytecode. A list comprehension compiles to a dedicated loop that the interpreter runs directly, while the explicit version runs a Python-level for statement whose body performs a method lookup and a method call on every iteration. The overhead of resolving items.append each time is a large part of the difference.

That said, speed is not the reason to prefer comprehensions. Readability is. The comprehension says what the code produces in one expression, whereas the loop separates the intent across three lines and leaves the reader to notice that the append is the only thing happening.

The honest caveat is that a comprehension is only clearer while it stays short. Once it needs a condition and a transformation and a nested loop, it becomes a dense line of brackets that is harder to scan than a loop with a named variable. The right rule is: comprehension when it fits on one or two lines, loop when it does not.

No. A comprehension is better when the transformation is a single expression, and a loop is better when the body needs statements. That is the whole decision rule.

Use a comprehension when you are mapping values, filtering them, or doing both in one expression. It is shorter, it is usually faster, and the result reads as a description of the data rather than a sequence of instructions.

Use an explicit loop when the body needs more than one expression — a try block, a conditional that spans several lines, an assignment to a separate variable, a break or a continue. A comprehension is an expression, so none of those are possible inside it. Also use a loop when the intermediate value needs a name, because you cannot bind a name inside a comprehension in Python 3.

Two more reasons to prefer the loop. If the logic is subtle enough to need a comment, a comment cannot go inside a comprehension, so you would have to put it above the whole thing — which is a sign the logic wants to be a loop with the comment on the line it describes. And if the comprehension would have to wrap over several lines, most Python style guides — including PEP 8's advice on long comprehensions — say to use an explicit loop instead.

The performance point is worth one sentence in an interview: a comprehension is faster because it avoids the repeated method lookup in the loop body, but that is a constant-factor difference and only matters in a hot path. Readability wins everywhere else.