
A Python `tuple` is an immutable, ordered sequence of values. You create one with parentheses (`(1, 2, 3)`) or just by separating values with commas (`1, 2, 3` - the parentheses are optional). Because tuples are immutable they can be used as dictionary keys and set members, which plain lists cannot.

<ExamplePair>
<ExampleProse>

Packing is creating a tuple; unpacking is pulling its values into separate names. You can pack without parentheses: `t = 1, 2` creates a two-tuple. To unpack, put the same number of names on the left: `a, b = t`. The one-tuple trap: `(1)` is just the integer 1 wrapped in parentheses. You need a trailing comma to make a real one-element tuple: `(1,)`.

</ExampleProse>
<ExampleCode>

```python
# Packing - parentheses are optional
t = 1, 2
t        # (1, 2)

# Unpacking
a, b = t
a  # 1
b  # 2

# Swap without a temp variable
a, b = b, a

# One-tuple trap
(1)     # just int 1
(1,)    # tuple with one element
type((1,))   # <class 'tuple'>
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

The `*rest` syntax in unpacking lets you collect "the middle" or "the tail" into a list. `first, *middle, last = seq` splits the sequence at both ends, regardless of how long the middle is. The starred name always collects into a plain list even though it came from a tuple.

</ExampleProse>
<ExampleCode>

```python
seq = (1, 2, 3, 4, 5)

first, *rest = seq
first   # 1
rest    # [2, 3, 4, 5]  -- list, not tuple

first, *middle, last = seq
first   # 1
middle  # [2, 3, 4]
last    # 5

# Useful for splitting at known positions
host, *path_parts = "api.example.com/users/42".split("/")
host        # "api.example.com"
path_parts  # ["users", "42"]
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

`typing.NamedTuple` lets you give names to tuple positions and add type annotations. You access fields by name (`point.x`) instead of index (`point[0]`), which makes code easier to read. The class still behaves as a tuple - you can unpack it, use it as a dict key, and compare it with `==`. For legacy code you may see `collections.namedtuple`, which has no type annotation support.

</ExampleProse>
<ExampleCode>

```python
from typing import NamedTuple

class Point(NamedTuple):
    x: float
    y: float

p = Point(3.0, 4.0)
p.x       # 3.0
p.y       # 4.0
p[0]      # 3.0  -- still a tuple underneath

# Works as a dict key
distances = {Point(0.0, 0.0): "origin", Point(1.0, 0.0): "unit"}

# Unpacks like a plain tuple
x, y = p
```

</ExampleCode>
</ExamplePair>

<InProduction>
Tuple immutability is shallow - `t = ([], [])` lets you mutate `t[0].append(1)` even though `t` itself cannot be rebound; if you need deep immutability, use `frozenset` for sets, freeze contents explicitly, or build with `@dataclass(frozen=True)`. Prefer `typing.NamedTuple` or `@dataclass(frozen=True, slots=True)` over `collections.namedtuple` in new code - you get type checking, stricter equality semantics, and IDE autocomplete on field names.
</InProduction>


Python tuple basics: packing and unpacking, the one-tuple comma, *rest unpacking, and typing.NamedTuple for named fields.

Tuples


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.

Dicts


A Python `list` is a mutable, ordered sequence of items. You create one with square brackets (`[1, 2, 3]`) or by calling `list(iterable)`. Lists grow with `.append()` and `.extend()`, shrink with `.pop()` and `.remove()`, and can be sliced with `xs[start:stop]`.

<ExamplePair>
<ExampleProse>

The most common list operations: `.append(x)` adds one item to the end, `.extend(iterable)` appends every item from another iterable, `.insert(i, x)` inserts at a specific index, `.pop()` removes and returns the last item, and `.remove(x)` removes the first occurrence of a value. Appending and popping at the right end (index -1) is O(1) - fast regardless of list size. Inserting or removing at the left end (index 0) is O(n) because every other item must shift.

</ExampleProse>
<ExampleCode>

```python
xs = [1, 2, 3]

xs.append(4)        # [1, 2, 3, 4]
xs.extend([5, 6])   # [1, 2, 3, 4, 5, 6]
xs.insert(0, 0)     # [0, 1, 2, 3, 4, 5, 6]  -- O(n), shifts everything
xs.pop()            # returns 6, list is [0, 1, 2, 3, 4, 5]
xs.remove(0)        # removes first 0, list is [1, 2, 3, 4, 5]

len(xs)             # 5
3 in xs             # True
xs.index(3)         # 2  (position of the value 3)
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Slicing returns a new list containing the selected items. `xs[a:b]` gives items from index `a` up to (but not including) `b`. Negative indices count from the end: `xs[-1]` is the last item. `xs[::-1]` steps backwards and returns a reversed copy. `xs[:]` copies the entire list shallowly - useful when you need a separate list that starts with the same values.

</ExampleProse>
<ExampleCode>

```python
xs = [10, 20, 30, 40, 50]

xs[1:3]     # [20, 30]          -- items at index 1 and 2
xs[:2]      # [10, 20]          -- first two
xs[2:]      # [30, 40, 50]      -- from index 2 to end
xs[-1]      # 50                -- last item
xs[::-1]    # [50, 40, 30, 20, 10]  -- reversed copy
xs[:]       # [10, 20, 30, 40, 50]  -- shallow copy

copy = xs[:]
copy.append(99)
xs   # [10, 20, 30, 40, 50]  -- original unchanged
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

`[[]] * n` looks like it creates `n` independent empty lists, but it actually creates `n` references to the same inner list. Appending to any one of them mutates all of them. The fix is a list comprehension: `[[] for _ in range(n)]` calls `[]` once per iteration, producing `n` distinct list objects.

</ExampleProse>
<ExampleCode>

```python
# Bug: all three rows point to the same list
grid = [[]] * 3
grid[0].append(1)
grid  # [[1], [1], [1]]  -- all three changed!

# Fix: comprehension creates a new [] each iteration
grid = [[] for _ in range(3)]
grid[0].append(1)
grid  # [[1], [], []]  -- only row 0 changed

# Same trap with any mutable default
row = [0] * 5     # [0, 0, 0, 0, 0]  -- safe: ints are immutable
matrix = [[0] * 5 for _ in range(3)]  # correct 3x5 grid
```

</ExampleCode>
</ExamplePair>

<InProduction>
`[[]] * n` creates n references to the same inner list - appending to one mutates all of them. Use `[[] for _ in range(n)]` instead. Lists are O(1) for `.append()` and `.pop()` at the right end but O(n) for `.pop(0)` and `.insert(0, x)` because every item must shift; for FIFO queues reach for `collections.deque`, which is O(1) at both ends.
</InProduction>


Python list basics: append, extend, slicing, shallow copies, and the shared-reference trap with [[]] * n.