Dict & Set Comprehensions

Also Known As

TL;DR

Explanation

Comprehensions: list [expr for x in iterable if cond], dict {k: v for ...}, set {expr for ...}, generator (expr for ...). They are faster than equivalent for-loops (built-in optimisation), more readable for simple transformations, and composable. Nested comprehensions (matrix flattening) are possible but harm readability beyond two levels. Generator expressions are lazy — use when you only iterate once to avoid building the full list. dict.fromkeys() and Counter() are preferable to comprehensions for specific patterns.

Common Misconception

Why It Matters

Common Mistakes

• Nested comprehensions with 3+ levels — break into named generators for readability.
• List comprehension when a generator suffices — [x for x in data] passed to sum() builds a full list; use sum(x for x in data).
• Complex filtering logic in comprehension conditions — extract to a named function.
• Mutating state inside a comprehension — comprehensions are for building new structures, not side effects.

Code Examples

# Verbose for-loop patterns:
name_map = {}
for user in users:
    name_map[user.id] = user.name

active_ids = []
for user in users:
    if user.is_active:
        active_ids.append(user.id)

unique_roles = set()
for user in users:
    unique_roles.add(user.role)

# Concise comprehensions:
name_map = {user.id: user.name for user in users}

active_ids = [user.id for user in users if user.is_active]

unique_roles = {user.role for user in users}

# Generator expression (lazy — no full list built):
total = sum(order.total for order in orders if order.is_complete)

# Nested — flatten matrix:
flat = [cell for row in matrix for cell in row]

References

• ↗ https://docs.python.org/3/tutorial/datastructures.html#list-comprehensions

Tags

Related Terms