Python Comprehensions Explained (List, Dict, Set)

A comprehension builds a list, dictionary, or set in a single readable line by transforming (and optionally filtering) an iterable. It’s the most recognisable Python idiom — [n * n for n in range(5)] replaces a three-line loop — and writing comprehensions fluently is a hallmark of Pythonic code.

They’re a Phase 3 skill in the Python roadmap. Here’s all three forms and when to use them.

List comprehensions

The form is [expression for item in iterable if condition]:

squares = [n * n for n in range(5)]            # [0, 1, 4, 9, 16]
evens = [n for n in range(10) if n % 2 == 0]   # [0, 2, 4, 6, 8]
names = [u.name for u in users if u.active]    # transform + filter

Read it left to right: the expression, for each item, if a condition holds. It replaces the loop-and-append pattern:

# The long way comprehensions replace:
squares = []
for n in range(5):
    squares.append(n * n)

Dict comprehensions

Same idea, building a dictionary with key: value:

squares = {n: n * n for n in range(5)}         # {0: 0, 1: 1, 2: 4, ...}
prices = {p.name: p.cost for p in products}    # from objects
swapped = {v: k for k, v in original.items()}  # invert a dict

Set comprehensions

Curly braces without a colon, producing a set of unique values:

unique_lengths = {len(word) for word in words}   # a set, deduped

See lists vs tuples vs sets vs dicts for which collection you actually want.

Filtering and conditionals

The trailing if filters (decides whether to include an item). An if/else in the expression part transforms (chooses the value):

# Filter: only evens
[n for n in nums if n % 2 == 0]

# Transform: label each number (note the different position)
["even" if n % 2 == 0 else "odd" for n in nums]

Mixing these up is the most common comprehension confusion: a filtering if goes at the end; a transforming if/else goes at the start.

Nested comprehensions (use sparingly)

You can nest, e.g. to flatten a 2D list:

flat = [x for row in matrix for x in row]   # read like nested for-loops

But nesting more than one level quickly becomes unreadable — at that point, a normal loop is clearer.

When a comprehension helps vs hurts

• Use one for a simple transform/filter that fits comfortably on one line.
• Use a regular loop when the logic is complex, has side effects, or won’t fit readably — clarity beats cleverness.
• Use a generator expression (parentheses instead of brackets) for large data you only iterate once, to save memory.

Common mistakes

• Putting a filtering if in the wrong place (see the callout).
• Cramming complex logic into a comprehension until it’s unreadable — switch to a loop.
• Building a huge list when a generator expression would do — wastes memory.
• Side effects inside comprehensions (calling functions for their effect) — comprehensions are for building collections, not doing work.

Where this fits

Comprehensions are Phase 3 of the Python roadmap, closely tied to generators (the lazy cousin) and the collection types they build.

They’re introduced with worked examples in Python in One Month and used throughout the job-ready Python in Three Months.

Reach for a comprehension when it makes a simple transform clearer — and a loop when it doesn’t.