
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.

Sets


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 Python `dict` is a mapping from keys to values. Keys must be hashable - strings, numbers, and tuples all work, but lists and other dicts do not. You write a dict literal with curly braces: `{"a": 1, "b": 2}`. Insertion order is preserved (guaranteed since Python 3.7), so iterating a dict always yields keys in the order they were added.

<ExamplePair>
<ExampleProse>

`d[key]` reads a value and raises `KeyError` if the key is missing. `d.get(key)` returns `None` instead of raising, and `d.get(key, default)` returns a custom fallback. Use `.get()` when a missing key is a normal case; use `d[key]` when missing keys are a bug you want to catch immediately.

</ExampleProse>
<ExampleCode>

```python
d = {"name": "Ada", "lang": "Python"}

d["name"]            # "Ada"
d["missing"]         # KeyError: 'missing'

d.get("name")        # "Ada"
d.get("missing")     # None
d.get("missing", 0)  # 0

# Membership check
"name" in d   # True
"age" in d    # False

# Iterating
for key, value in d.items():
    print(key, "->", value)
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

`collections.defaultdict` creates a missing value automatically when you access a key for the first time. Pass it a callable (like `list` or `int`) and it calls that callable to build the default. This is the standard way to bucket items into groups without checking "does this key exist yet?" on every iteration.

</ExampleProse>
<ExampleCode>

```python
from collections import defaultdict

# Group words by their first letter
words = ["apple", "avocado", "banana", "blueberry", "cherry"]

groups = defaultdict(list)
for word in words:
    groups[word[0]].append(word)

dict(groups)
# {"a": ["apple", "avocado"], "b": ["banana", "blueberry"], "c": ["cherry"]}

# Count occurrences with int default (starts at 0)
counter = defaultdict(int)
for ch in "mississippi":
    counter[ch] += 1

dict(counter)
# {"m": 1, "i": 4, "s": 4, "p": 2}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Python 3.9 introduced `|` to merge two dicts into a new one, and `|=` to merge in place. When keys overlap, the right-hand dict wins. This replaces the older `{**a, **b}` idiom, which still works but is harder to read at a glance.

</ExampleProse>
<ExampleCode>

```python
defaults = {"timeout": 30, "retries": 3, "debug": False}
overrides = {"timeout": 10, "debug": True}

# Merge into a new dict (right side wins on conflict)
config = defaults | overrides
config  # {"timeout": 10, "retries": 3, "debug": True}

# In-place merge (mutates defaults)
defaults |= overrides

# Equivalent older syntax
config = {**defaults, **overrides}

# setdefault: set key only if not already present
config.setdefault("timeout", 60)   # returns 10, does not overwrite
config.setdefault("log_level", "INFO")  # inserts "INFO"
```

</ExampleCode>
</ExamplePair>

<InProduction>
Insertion order is part of the language since Python 3.7 - `OrderedDict` is now reserved for the rare case needing `move_to_end()` or order-sensitive equality. The `|` operator merges dicts non-destructively (3.9+) and replaces `{**a, **b}` for clarity. `dict.setdefault(k, [])` is a one-line read-through cache idiom; for hot paths `defaultdict(list)` is faster because it skips the key lookup. See the [read-through cache pattern](/patterns/read-through-cache) for how this scales to a production caching layer.
</InProduction>


Python dict basics: safe access with .get(), defaultdict bucketing, merging with |, and the setdefault idiom.