Dict, Set and Generator Comprehensions

The comprehension pattern extends beyond lists to three other powerful constructs: dict comprehensions for building dictionaries from iterables, set comprehensions for creating sets with automatic deduplication, and generator expressions for producing values one at a time without building a collection in memory. Dict comprehensions are particularly valuable in FastAPI for transforming database query results into response-ready dictionaries, set comprehensions for extracting unique tags or roles, and generator expressions for processing large datasets efficiently without loading everything into RAM.

Dict Comprehensions #

# Syntax: {key_expr: value_expr for item in iterable if condition}

# ── Build a dict from two lists ────────────────────────────────────────────────
ids    = [1, 2, 3]
names  = ["Alice", "Bob", "Charlie"]

user_map = {uid: name for uid, name in zip(ids, names)}
# {1: "Alice", 2: "Bob", 3: "Charlie"}

# ── Transform a dict ───────────────────────────────────────────────────────────
prices = {"apple": 1.20, "banana": 0.50, "cherry": 2.00}

# Apply 10% discount
discounted = {item: round(price * 0.9, 2) for item, price in prices.items()}
# {"apple": 1.08, "banana": 0.45, "cherry": 1.80}

# ── Filter a dict — keep only expensive items ──────────────────────────────────
expensive = {item: price for item, price in prices.items() if price >= 1.00}
# {"apple": 1.20, "cherry": 2.00}

# ── Invert a dict (swap keys and values) ───────────────────────────────────────
code_to_name = {"PY": "Python", "JS": "JavaScript", "TS": "TypeScript"}
name_to_code = {name: code for code, name in code_to_name.items()}
# {"Python": "PY", "JavaScript": "JS", "TypeScript": "TS"}

# ── FastAPI: shape database results into API response ─────────────────────────
db_rows = [
    {"user_id": 1, "full_name": "Alice Smith",  "email": "alice@example.com"},
    {"user_id": 2, "full_name": "Bob Jones",    "email": "bob@example.com"},
]

# Create a lookup dict: user_id → name (for quick access)
id_to_name = {row["user_id"]: row["full_name"] for row in db_rows}
# {1: "Alice Smith", 2: "Bob Jones"}

# Rename and select fields for the response
response_users = [
    {"id": row["user_id"], "name": row["full_name"], "email": row["email"]}
    for row in db_rows
]

Set Comprehensions #

# Syntax: {expression for item in iterable if condition}
# Same as list comprehension but uses {} and produces a set (unique values)

posts = [
    {"id": 1, "tags": ["python", "fastapi"]},
    {"id": 2, "tags": ["python", "postgresql"]},
    {"id": 3, "tags": ["fastapi", "react"]},
]

# All unique tags across all posts
all_tags = {tag for post in posts for tag in post["tags"]}
# {"python", "fastapi", "postgresql", "react"} — no duplicates

# Unique author IDs from comments
comments = [
    {"author_id": 1, "text": "Great!"},
    {"author_id": 2, "text": "Thanks!"},
    {"author_id": 1, "text": "Agreed!"},
]
unique_author_ids = {c["author_id"] for c in comments}
# {1, 2} — automatically deduplicated

# Sets support fast membership testing — O(1) vs O(n) for lists
allowed_roles = {"user", "editor", "admin"}

def is_valid_role(role: str) -> bool:
    return role in allowed_roles   # O(1) lookup in set

# Deduplication pattern: list → set → list (preserves no order guarantee)
raw_tags = ["python", "fastapi", "python", "react", "fastapi"]
unique_tags = list({tag.lower() for tag in raw_tags})
# ["python", "fastapi", "react"] (any order — sets are unordered)

Generator Expressions #

# Syntax: (expression for item in iterable if condition)
# Like a list comprehension but lazy — produces values one at a time

# List comprehension — builds ALL results in memory first
squares_list = [x ** 2 for x in range(1_000_000)]   # ~8MB in memory

# Generator expression — produces one value at a time (almost no memory)
squares_gen  = (x ** 2 for x in range(1_000_000))   # tiny object

# Use generators with functions that consume iterables
total   = sum(x ** 2 for x in range(100))         # sum without a list
maximum = max(len(name) for name in ["Alice", "Bob", "Charlie"])  # 7
joined  = ", ".join(str(x) for x in [1, 2, 3])   # "1, 2, 3"

# When a function already takes a generator, no extra () needed
# sum((x for x in range(10))) is the same as:
sum(x for x in range(10))   # double () not needed — generator inferred

# Chaining generators — process data pipeline without intermediary lists
with open("data.txt") as f:
    line_count = sum(1 for line in f if line.strip())
# Counts non-empty lines without loading the file into memory

# FastAPI: process large query results efficiently
def get_published_titles(db_cursor):
    # Generator — does not load all rows into memory at once
    return (row["title"] for row in db_cursor if row["published"])

Choosing the Right Comprehension Type #

Common Mistakes #

Mistake 1 — Forgetting that {} without colons makes a set, not a dict #

❌ Wrong — expecting a dict from value-only comprehension:

result = {x for x in [1, 2, 3]}
type(result)   # <class 'set'> — not a dict!

✅ Correct — dict comprehensions must have key: value:

result = {x: x**2 for x in [1, 2, 3]}
type(result)   # <class 'dict'> ✓  →  {1: 1, 2: 4, 3: 9}

Mistake 2 — Using list comprehension where generator is appropriate #

❌ Wrong — builds entire list just to compute a sum:

total = sum([x ** 2 for x in range(1_000_000)])   # wastes 8MB of memory

✅ Correct — use generator expression with sum():

total = sum(x ** 2 for x in range(1_000_000))   # ✓ tiny memory footprint

Mistake 3 — Trying to index a generator like a list #

❌ Wrong — generators do not support indexing:

gen = (x for x in range(10))
gen[0]   # TypeError: 'generator' object is not subscriptable

✅ Correct — convert to list first if indexing is needed:

items = list(x for x in range(10))
items[0]   # 0 ✓

Quick Reference #