Python Comprehensions and Generator Expressions Guide

Comprehensions let you build and transform collections in a single, readable line instead of writing multi-line for loops. Once you’re comfortable with them, you’ll reach for comprehensions constantly — they’re one of the most practical tools in everyday Python.

List Comprehensions

A list comprehension creates a new list by applying an expression to every item in an iterable, optionally filtering with a condition. Syntax: [expression for item in iterable if condition]

# Traditional loop
squares = []
for x in range(5):
    squares.append(x * x)

# Equivalent list comprehension — one clean line
squares = [x * x for x in range(5)]
print(squares)  # [0, 1, 4, 9, 16]

# With a filter condition — only even numbers
even_squares = [x * x for x in range(10) if x % 2 == 0]
print(even_squares)  # [0, 4, 16, 36, 64]

Transforming a list of dictionaries

A common real-world use case is extracting or reshaping data from a list of records:

products = [
    {"name": "Laptop", "price": 999},
    {"name": "Mouse",  "price": 29},
    {"name": "Monitor","price": 399},
]

# Extract names of products over $100
expensive = [p["name"] for p in products if p["price"] > 100]
print(expensive)  # ['Laptop', 'Monitor']

# Apply a 10% discount to all prices
discounted = [{"name": p["name"], "price": p["price"] * 0.9} for p in products]

Dictionary Comprehensions

A dictionary comprehension builds a dict using the same pattern, but with {key: value ...} syntax. Syntax: {key_expr: value_expr for item in iterable if condition}

# Map each number to its square
squares_dict = {x: x * x for x in range(6)}
print(squares_dict)  # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

# Invert a dictionary (swap keys and values)
original = {"a": 1, "b": 2, "c": 3}
inverted = {v: k for k, v in original.items()}
print(inverted)      # {1: 'a', 2: 'b', 3: 'c'}

# Build a word-length map
words = ["python", "is", "awesome"]
lengths = {word: len(word) for word in words}
print(lengths)       # {'python': 6, 'is': 2, 'awesome': 7}

Set Comprehensions

Set comprehensions work like list comprehensions but produce a set — automatically deduplicated, unordered. Syntax: {expression for item in iterable if condition}

names = ["alice", "bob", "alice", "charlie", "bob"]

# Unique names only
unique_names = {name for name in names}
print(unique_names)    # {'alice', 'bob', 'charlie'}

# Unique string lengths
unique_lengths = {len(name) for name in names}
print(unique_lengths)  # {5, 3, 7}

Generator Expressions

Generator expressions look like list comprehensions but use () instead of []. The crucial difference: they are lazy — they compute one value at a time, only when you ask for the next item. This makes them extremely memory-efficient for large datasets.

# List comprehension — builds entire list in memory immediately
list_comp = [x * x for x in range(1_000_000)]   # ~8 MB

# Generator expression — computes one value at a time
gen_exp = (x * x for x in range(1_000_000))     # negligible memory

print(next(gen_exp))   # 0
print(next(gen_exp))   # 1
print(next(gen_exp))   # 4

When you only need to iterate through results once (e.g., summing, searching, writing to a file), prefer a generator expression. When you need random access or to iterate multiple times, use a list comprehension.

# Generator expression inside sum() — no intermediate list created
total = sum(x * x for x in range(1000))
print(total)   # 332833500

Reading a large file lazily

Generator expressions shine when processing files line by line without loading everything into memory:

# Count non-empty lines in a large log file
with open("server.log", "r") as f:
    line_count = sum(1 for line in f if line.strip())

print(f"Non-empty lines: {line_count}")

Nested Comprehensions

You can nest comprehensions to flatten or work with multi-dimensional data. Keep readability in mind — if nesting gets confusing, a regular for loop is often clearer.

# Flatten a 2D matrix into a 1D list
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flat = [num for row in matrix for num in row]
print(flat)  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

# Cartesian product of two lists
colours  = ["red", "blue"]
sizes    = ["S", "M", "L"]
variants = [(c, s) for c in colours for s in sizes]
print(variants)
# [('red','S'), ('red','M'), ('red','L'), ('blue','S'), ('blue','M'), ('blue','L')]

When to Use Comprehensions vs For Loops

Prefer a comprehension when…

You are building a new collection from an existing one
The transformation or filter fits comfortably on one or two lines
You want expressive, declarative code

# Clean — the intent is immediately clear
active_users = [u["name"] for u in users if u["active"]]

Prefer a for loop when…

You have complex multi-step logic inside the loop body
You need to break or continue mid-iteration
You are performing side effects (printing, writing files, updating external state) rather than building a collection

# Better as a for loop — multiple steps and a side effect
for user in users:
    score = calculate_score(user)
    if score > threshold:
        send_notification(user, score)

Complete Example: Filtering and Transforming Product Data

inventory = [
    {"name": "Laptop",   "price": 999.0,  "in_stock": True},
    {"name": "Mouse",    "price": 29.0,   "in_stock": False},
    {"name": "Keyboard", "price": 79.0,   "in_stock": True},
    {"name": "Monitor",  "price": 399.0,  "in_stock": True},
    {"name": "Webcam",   "price": 49.0,   "in_stock": False},
]

# 1. Names of items that are in stock
available = [item["name"] for item in inventory if item["in_stock"]]
print(available)   # ['Laptop', 'Keyboard', 'Monitor']

# 2. Price map for in-stock items with 15% discount
sale_prices = {
    item["name"]: round(item["price"] * 0.85, 2)
    for item in inventory
    if item["in_stock"]
}
print(sale_prices)
# {'Laptop': 849.15, 'Keyboard': 67.15, 'Monitor': 339.15}

# 3. Unique price tiers (rounded to nearest $100)
tiers = {(item["price"] // 100) * 100 for item in inventory}
print(sorted(tiers))   # [0.0, 300.0, 900.0]

# 4. Total value of in-stock inventory (generator — no list created)
total = sum(item["price"] for item in inventory if item["in_stock"])
print(f"Total in-stock value: ${total:.2f}")   # $1477.00

Generator expressions used inside a function call like sum(...) or max(...) don’t need an extra pair of parentheses — the function’s parentheses serve double duty:

total = sum(x * x for x in range(10))   # ✅ one pair of parens
total = sum((x * x for x in range(10))) # ✅ also fine but redundant

Core Python

Advanced Python

Pydantic

Python Comprehensions and Generator Expressions Guide

List Comprehensions

Transforming a list of dictionaries

Dictionary Comprehensions

Set Comprehensions

Generator Expressions

Reading a large file lazily

Nested Comprehensions

When to Use Comprehensions vs For Loops

Complete Example: Filtering and Transforming Product Data

​List Comprehensions

​Transforming a list of dictionaries

​Dictionary Comprehensions

​Set Comprehensions

​Generator Expressions

​Reading a large file lazily

​Nested Comprehensions

​When to Use Comprehensions vs For Loops

​Complete Example: Filtering and Transforming Product Data

List Comprehensions

Transforming a list of dictionaries

Dictionary Comprehensions

Set Comprehensions

Generator Expressions

Reading a large file lazily

Nested Comprehensions

When to Use Comprehensions vs For Loops

Complete Example: Filtering and Transforming Product Data