Python List Comprehension: Syntax, Examples and When to Avoid It

A Python list comprehension builds a new list from any iterable in a single readable line. Instead of creating an empty list, looping and calling append, you describe the result you want.

This guide goes from the basic pattern to filters, nested loops and timings we measured ourselves. If Python is new to you, start with our Python tutorial for beginners and keep a clean setup with the virtual environment guide.

Python list comprehension syntax

Read it from left to right: the expression says what each new item looks like, the for part says where items come from.

squares = [x * x for x in range(6)]
print(squares)          # [0, 1, 4, 9, 16, 25]

names = [" Hi ", "  QA "]
clean = [n.strip().lower() for n in names]
print(clean)            # ['hi', 'qa']

The same result with a loop needs three more lines. That saving is the whole point, as long as the line stays easy to read.

Filter items with a condition

Add an if after the loop to keep only the items that pass.

evens = [x for x in range(10) if x % 2 == 0]
print(evens)            # [0, 2, 4, 6, 8]

Python list comprehension with if-else

When you want a value for every item, put the if-else before the for. This is the part most beginners get wrong, because a trailing else is a syntax error.

labels = ["even" if x % 2 == 0 else "odd" for x in range(4)]
print(labels)           # ['even', 'odd', 'even', 'odd']

Nested loops and flattening

Several for clauses read in the same order as nested loops. Use them to flatten a list of lists or to pair values.

matrix = [[1, 2, 3], [4, 5, 6]]
flat = [n for row in matrix for n in row]
print(flat)             # [1, 2, 3, 4, 5, 6]

pairs = [(x, y) for x in range(1, 3) for y in "ab"]
print(pairs)            # [(1, 'a'), (1, 'b'), (2, 'a'), (2, 'b')]

To transpose the matrix, nest a comprehension inside another: [[r[i] for r in matrix] for i in range(3)] gives [[1, 4], [2, 5], [3, 6]]. Two levels is the practical limit before readability drops.

Dictionary, set and generator forms

Change the brackets and the same idea builds other types.

lengths = {w: len(w) for w in ["pip", "venv", "uv"]}   # {'pip': 3, 'venv': 4, 'uv': 2}
unique  = {len(w) for w in ["pip", "venv", "uv", "git"]}  # {2, 3, 4}
total   = sum(x * x for x in range(1_000_000))           # generator, no list

Compare the types themselves in our guide to lists, tuples, sets and dictionaries.

Speed and memory: what we measured

We timed each version on Python 3.13.6 with 100,000 integers, taking the best of five runs. Your numbers will differ, but the order is stable.

A comprehension beats the append loop clearly, while the gap shrinks when most of the time goes to the condition. On memory, a list of one million doubled integers took about 8.4 MB, while the matching generator object was 200 bytes, because it produces values one at a time.

When not to use a list comprehension

• You only need side effects such as printing or saving. Use a normal loop; a comprehension would build a useless list.
• The logic has several steps. If you need a second variable or a try, write a loop or a small function.
• The data is huge. Use a generator expression so Python never holds the full list in memory.
• It needs more than two for clauses. Split it into named steps for the next reader.

Final thoughts

Use a Python list comprehension when one short line says exactly what you mean, and a loop when it does not. Start with the basic pattern, add one filter, then try the if-else form until the order feels natural.

Frequently asked questions

Keep learning