Are list comprehensions actually faster than for loops in Python?

The short version

A list comprehension is modestly faster than an equivalent for loop with append, because it avoids looking up and calling the append method on every iteration. But the gap is small. For numeric work, both are dwarfed by a vectorised NumPy or pandas operation, which is where the real performance lies.

Measuring it

import timeit

comp = timeit.timeit("[x * 2 for x in range(1000)]", number=1000)
loop = timeit.timeit(
    "r = []\nfor x in range(1000): r.append(x * 2)", number=1000
)
print(comp, loop)   # roughly 0.047 vs 0.052 seconds

The comprehension wins, but only by around ten per cent here. That is a real difference and worth having for free, but it will not rescue slow code.

Why the comprehension is faster

The loop version looks up r.append on every pass and makes a function call each time. The comprehension uses a specialised bytecode path that appends directly, skipping that overhead. It is a constant-factor saving, not a change in the fundamental amount of work.

Where the real speed is

For numeric data, neither approach is the right tool. The loop and the comprehension both run Python once per element; a vectorised operation runs compiled code across the whole array.

import numpy as np
arr = np.arange(1000)
arr * 2       # one operation, in C, over the whole array

On a large array this is not ten per cent faster; it is often a hundred times faster. So the meaningful question is rarely "loop or comprehension" but "can I avoid the Python-level loop altogether".

Do not choose on speed alone

Because the difference is small, readability should decide between a loop and a comprehension in ordinary code. Use a comprehension when it expresses a simple transform or filter clearly. Use a loop when the logic has several steps, side effects, or branching that would make a comprehension cryptic. A slightly slower loop that a colleague can read at a glance is the better engineering choice.

Generators when memory matters

If you are feeding the results straight into a reduction, a generator expression avoids building the list at all, which saves memory on large inputs.

sum(x * 2 for x in range(1_000_000))   # no list is ever created

This is not about speed so much as footprint, and it is the right habit for large sequences.

Measure before you optimise

The honest summary: micro-optimising a loop into a comprehension is rarely where your time goes. Profile first. Nine times out of ten the bottleneck is an unnecessary row-wise apply, a repeated in test against a list, or a query that should have been done in the database, and fixing that is worth far more than any comprehension.