
A comprehension builds a collection from an iterable in a single expression. Python has four forms: list (`[...]`), dict (`{k: v ...}`), set (`{v ...}`), and generator (`(...)`). They replace many for-loop-then-append patterns and express the intent more directly.

<ExamplePair>
<ExampleProse>

List, dict, and set comprehensions all follow the same shape: `[expression for item in iterable if condition]`. The `if` part is optional. Each form produces a different collection type.

</ExampleProse>
<ExampleCode>

```python
xs = [1, 2, 3, 4, 5]
d = {"a": 1, "b": 2, "c": 3}

# List comprehension
doubled = [x * 2 for x in xs]
doubled  # [2, 4, 6, 8, 10]

# With a filter
evens = [x for x in xs if x % 2 == 0]
evens  # [2, 4]

# Dict comprehension
scaled = {k: v * 2 for k, v in d.items()}
scaled  # {"a": 2, "b": 4, "c": 6}

# Set comprehension (duplicates removed automatically)
last_digits = {x % 10 for x in [11, 21, 31, 22]}
last_digits  # {1, 2}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

A generator expression looks like a list comprehension but uses parentheses instead of square brackets. It is lazy: values are produced one at a time as the consumer asks for them, so the whole sequence is never held in memory at once. This makes generator expressions ideal when feeding functions that iterate once, like `sum()`, `any()`, `all()`, or `max()`.

</ExampleProse>
<ExampleCode>

```python
xs = range(1_000_000)

# List comprehension: builds the entire list in memory first
total_list = sum([x * 2 for x in xs])

# Generator expression: produces values lazily, uses constant memory
total_gen = sum(x * 2 for x in xs)

# Both give the same result, but the generator uses far less memory.
# When passing a generator expression as the sole argument to a
# function, you can drop the extra parentheses:
total_gen = sum(x * 2 for x in xs)   # not sum((x * 2 for x in xs))

any(x > 999_990 for x in xs)   # True  (stops early on first match)
all(x >= 0 for x in xs)        # True
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

The walrus operator (`:=`, added in Python 3.8) assigns a value inside an expression. In a comprehension it lets you call an expensive function once and both filter and use the result in a single pass - no need for a temporary list or a two-step filter-then-transform.

</ExampleProse>
<ExampleCode>

```python
import re

logs = [
    "ERROR: disk full",
    "INFO: started",
    "ERROR: timeout",
    "DEBUG: ping",
]

# Without walrus: re.search called twice per item
errors = [line for line in logs if re.search(r"ERROR: (.+)", line)]

# With walrus: call once, bind to `m`, filter on it, use it
messages = [
    m.group(1)
    for line in logs
    if (m := re.search(r"ERROR: (.+)", line)) is not None
]
messages  # ["disk full", "timeout"]
```

</ExampleCode>
</ExamplePair>

<InProduction>
A generator expression `(x * 2 for x in xs)` is lazy and constant-memory - reach for it over a list comprehension when feeding `sum()`, `any()`, `all()`, or any consumer that iterates once. Two levels of nesting in a comprehension are readable; three are not - extract the inner level to a named function or a plain `for` loop. The walrus operator (`:=`) filters and binds in one pass, which is its clearest use case; overusing it in complex expressions hurts readability more than it helps.
</InProduction>


List, dict, set, and generator comprehensions: concise collection building, generator laziness, and the walrus operator for filter-and-bind.

Comprehensions


A function is defined with `def name(parameters):`. Python functions support positional arguments, keyword arguments, default values, `*args` for variadic positional arguments, and `**kwargs` for variadic keyword arguments. Two separator symbols - `/` and `*` - let you control exactly how callers may pass each argument.

<ExamplePair>
<ExampleProse>

Placing `*` in a parameter list means every argument after it must be passed by name (keyword-only). Placing `/` means every argument before it must be passed by position (positional-only). These are not just style rules - Python enforces them at call time. Keyword-only arguments make call sites self-documenting and prevent argument-order bugs.

</ExampleProse>
<ExampleCode>

```python
# timeout and retries are keyword-only (after *)
def fetch(url, *, timeout=10, retries=3):
    ...

fetch("https://example.com")                # ok
fetch("https://example.com", timeout=5)     # ok
fetch("https://example.com", 5)             # TypeError: too many positional arguments

# x is positional-only (before /); y can be either
def transform(x, /, y):
    return x + y

transform(1, 2)       # ok - both positional
transform(1, y=2)     # ok - y as keyword
transform(x=1, y=2)   # TypeError: x is positional-only

# Combining both: url is positional-only, timeout and retries are keyword-only
def request(url, /, *, timeout=10, retries=3):
    ...
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Default argument values are evaluated once when Python reads the `def` statement, not each time the function is called. For immutable defaults like strings and numbers this does not matter. For mutable objects like lists and dicts it causes a subtle bug: every call that omits the argument shares the same object. The fix is to use `None` as the sentinel and build the mutable default inside the function body.

</ExampleProse>
<ExampleCode>

```python
# Bug: items is created once; all calls share the same list
def append_item(value, items=[]):
    items.append(value)
    return items

append_item(1)   # [1]
append_item(2)   # [1, 2]  -- not [2]!
append_item(3)   # [1, 2, 3]

# Fix: use None as sentinel, build the default inside the body
def append_item_fixed(value, items=None):
    if items is None:
        items = []
    items.append(value)
    return items

append_item_fixed(1)   # [1]
append_item_fixed(2)   # [2]   -- fresh list each time
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

A Python function can return multiple values by returning a tuple. The caller can unpack them directly into separate names. For shapes that will be passed around or stored, a `typing.NamedTuple` adds names and type annotations without the overhead of a full class.

</ExampleProse>
<ExampleCode>

```python
from typing import NamedTuple

# Plain tuple return: works, but callers must remember the order
def divmod_plain(a, b):
    return a // b, a % b

quotient, remainder = divmod_plain(17, 5)
# quotient=3, remainder=2

# NamedTuple: adds names, type annotations, and dot-access
class DivResult(NamedTuple):
    quotient: int
    remainder: int

def divmod_named(a, b):
    return DivResult(a // b, a % b)

result = divmod_named(17, 5)
result.quotient    # 3
result.remainder   # 2

# Still unpackable like a plain tuple
q, r = divmod_named(17, 5)
```

</ExampleCode>
</ExamplePair>

<InProduction>
`def f(items=[]):` evaluates the default once at definition time - every call without an argument shares the same list across the lifetime of the program; use `def f(items=None): items = items if items is not None else []`. Functions with more than two or three positional arguments become unreadable at call sites - use `*` to make the rest keyword-only (`def fetch(url, *, timeout, retries)`); positional arguments past three are a code-review signal. See the [idempotency key pattern](/patterns/idempotency-key) for how careful parameter design makes retry-safe APIs possible.
</InProduction>


Python function signatures: keyword-only and positional-only args, the mutable-default footgun, and returning multiple values cleanly.

Functions


A Python `set` is an unordered collection of unique, hashable values. Two elements are "the same" if they compare equal and share the same hash. Sets are useful for membership testing (`x in s` is O(1)), deduplication, and set-algebra operations. `frozenset` is the immutable variant - it can be used as a dict key or a member of another set.

<ExamplePair>
<ExampleProse>

Set literals use curly braces with values inside: `{1, 2, 3}`. There is one important trap: `{}` is an empty *dict*, not an empty set. To create an empty set you must write `set()`. This silent type confusion is a real source of bugs because `{}` and `set()` look similar in code review.

</ExampleProse>
<ExampleCode>

```python
s = {1, 2, 3}
type(s)   # <class 'set'>

# The empty-set trap
empty_dict = {}        # dict, NOT a set
type(empty_dict)       # <class 'dict'>

empty_set = set()      # correct empty set
type(empty_set)        # <class 'set'>

# Basic operations
s.add(4)       # {1, 2, 3, 4}
s.remove(2)    # {1, 3, 4}   -- raises KeyError if missing
s.discard(99)  # no-op if missing, no error
3 in s         # True
len(s)         # 3
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Set algebra uses operators that mirror the mathematical notation. Union (`|`) gives all elements from both sets. Intersection (`&`) gives only elements present in both. Difference (`-`) removes elements of the right set from the left. Symmetric difference (`^`) gives elements that are in one set but not the other.

</ExampleProse>
<ExampleCode>

```python
a = {1, 2, 3, 4}
b = {3, 4, 5, 6}

a | b   # {1, 2, 3, 4, 5, 6}  -- union
a & b   # {3, 4}               -- intersection
a - b   # {1, 2}               -- difference (in a but not b)
b - a   # {5, 6}               -- difference (in b but not a)
a ^ b   # {1, 2, 5, 6}         -- symmetric difference

# Subset and superset checks
{1, 2} <= a    # True  (subset)
a >= {1, 2}    # True  (superset)
{1, 2} < a     # True  (proper subset, not equal)
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Converting a list to a set and back is the fastest way to deduplicate, but it does not preserve order. For an "all needles present?" check, `set(needles) <= set(haystack)` is cleaner than a loop and runs in O(n+m) time. `frozenset` is the immutable variant and can be used wherever a hashable value is needed.

</ExampleProse>
<ExampleCode>

```python
# Deduplication (order not preserved)
xs = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3]
unique = list(set(xs))
# e.g. [1, 2, 3, 4, 5, 6, 9]  -- order is arbitrary

# "All needles present?" check
required = {"name", "email", "age"}
provided = {"name", "email", "age", "country"}
required <= set(provided)   # True

# frozenset as a dict key
roles = frozenset({"admin", "editor"})
permissions = {
    frozenset({"admin"}):          ["read", "write", "delete"],
    frozenset({"admin", "editor"}): ["read", "write"],
}
permissions[roles]   # ["read", "write"]
```

</ExampleCode>
</ExamplePair>

<InProduction>
`{}` is an empty *dict*, not an empty set - use `set()` for empty sets; only `{1, 2, 3}` with elements is a set literal, and the silent type confusion bites code review. Sets require elements to be hashable, so lists and dicts cannot be set members; for a "set of records" reach for tuples of items or `frozenset(d.items())`.
</InProduction>


Python set basics: literals, the empty-set {} trap, set algebra, deduplication, and frozenset for immutable membership.