
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.

Lists


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


Python has two loop forms: `for` iterates over a collection or range, and `while` runs as long as a condition is true. Both support `break` (exit early) and `continue` (skip to the next iteration). Both also accept an `else` clause - uncommon but worth knowing.

<ExamplePair>
<ExampleProse>

`for x in xs:` works with any iterable - lists, ranges, strings, dicts, files. `range(n)` produces integers 0 through n-1. `enumerate(xs)` gives you each item paired with its index, removing the need for a separate counter. `zip(a, b)` steps through two iterables in parallel, pairing items at the same position.

</ExampleProse>
<ExampleCode>

```python
fruits = ["apple", "banana", "cherry"]

# Basic for loop
for fruit in fruits:
    print(fruit)

# range: 0, 1, 2, 3, 4
for i in range(5):
    print(i)

# enumerate: index + value
for i, fruit in enumerate(fruits):
    print(i, fruit)   # 0 apple, 1 banana, 2 cherry

# zip: iterate two lists in parallel
prices = [1.20, 0.50, 2.00]
for fruit, price in zip(fruits, prices):
    print(f"{fruit}: ${price:.2f}")
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

`while` runs as long as its condition is true. Use `break` to exit early when a goal is reached, and `continue` to skip the rest of the loop body for the current iteration. A `while True:` loop with an explicit `break` is a common pattern for "keep reading until a sentinel value."

</ExampleProse>
<ExampleCode>

```python
# Read lines until the user types "quit"
lines = []
while True:
    line = input("> ")
    if line == "quit":
        break
    lines.append(line)

print(f"Collected {len(lines)} line(s)")

# continue: skip blank lines
for line in lines:
    if not line.strip():
        continue
    process(line)
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Both `for` and `while` accept an optional `else` clause. The `else` block runs when the loop finishes normally - that is, without hitting a `break`. It reads as "no early exit occurred." Most teams avoid this because readers unfamiliar with Python expect `else` to mean "condition was false," not "loop completed." A sentinel variable is usually clearer.

</ExampleProse>
<ExampleCode>

```python
# for/else: runs the else block only when break was never hit
def find(items: list, target: int) -> str:
    for item in items:
        if item == target:
            break
    else:
        return "not found"
    return f"found {target}"

find([1, 2, 3], 2)  # 'found 2'
find([1, 2, 3], 9)  # 'not found'

# Same logic, clearer with a sentinel variable
def find_v2(items: list, target: int) -> str:
    found = False
    for item in items:
        if item == target:
            found = True
            break
    return f"found {target}" if found else "not found"
```

</ExampleCode>
</ExamplePair>

<InProduction>
The `for`/`else` clause runs when the loop exits without `break` - it reads as "no match found." Most teams use a sentinel variable instead because `else` on a loop is widely misunderstood and will surprise reviewers unfamiliar with Python. Modifying a list while iterating it (`for x in xs: xs.remove(x)`) skips elements because the iterator's position shifts after each removal; iterate over a copy (`for x in xs[:]:`) or build a new list with a comprehension.
</InProduction>


Python for and while loops, enumerate and zip for cleaner iteration, break and continue, and the for/else clause.