Welke nuttige typen biedt de collections-module?

Question

Accepted Answer

De **`collections`**-module biedt gespecialiseerde containertypen die de ingebouwde list/dict/tuple uitbreiden met handige, vaak efficiëntere alternatieven voor veelvoorkomende patronen. Door ze te kennen kunt u schoner en sneller code schrijven.

## defaultdict — dict's met automatische standaardwaarden

```python
from collections import defaultdict

# ❌ without it — must check/initialize keys manually
groups = {}
for item in items:
    if item.category not in groups:
        groups[item.category] = []
    groups[item.category].append(item)

# ✅ defaultdict auto-creates the default for missing keys
groups = defaultdict(list)        # missing key → a new empty list
for item in items:
    groups[item.category].append(item)   # no existence check needed
```

`defaultdict(list)` (of `int`, `set`, enz.) levert een standaard voor elke ontbrekende sleutel — elimineert het vervelende controle-en-initialisatie-patroon. Geweldig voor groepering en tellen.

## Counter — tel voorkomen

```python
from collections import Counter

c = Counter("mississippi")         # Counter({'i': 4, 's': 4, 'p': 2, 'm': 1})
c.most_common(2)                    # [('i', 4), ('s', 4)] — top 2
c["x"]                              # 0 — missing keys return 0, no error

Counter(["a", "b", "a", "c", "a"])  # count list items → {'a': 3, 'b': 1, 'c': 1}
```

`Counter` maakt frequentietelling triviaal — woorden, stemmen, voorkomen tellen — met handige methoden zoals `most_common`.

## deque — snelle append/pop aan BEIDE uiteinden

```python
from collections import deque

q = deque([1, 2, 3])
q.append(4)          # add to the right
q.appendleft(0)      # add to the LEFT — O(1) (a list's insert(0) is O(n)!)
q.popleft()          # remove from the left — O(1)
q = deque(maxlen=3)  # bounded — auto-drops old items (sliding window)
```

`deque` is een dubbelgeëindigde wachtrij met O(1) append/pop aan beide uiteinden — ideaal voor wachtrijen, stapels en schuifvensters (een gewone list is O(n) voor frontbewerkingen).

## namedtuple — lichte, benoemde records

```python
from collections import namedtuple

Point = namedtuple("Point", ["x", "y"])
p = Point(3, 4)
p.x, p.y          # 3, 4 — access by NAME (clearer than p[0], p[1])
p                 # Point(x=3, y=4) — readable
```

`namedtuple` geeft tuple's benoemde velden — leesbaarder dan indexbenadering, onveranderbaar, geheugenefficiënt. (Moderne code gebruikt vaak `@dataclass` in plaats daarvan voor veranderbare records.)

## OrderedDict / ChainMap (minder gebruikelijk nu)

```text
OrderedDict → ordered dict (less needed since regular dicts keep order in 3.7+)
ChainMap    → search multiple dicts as one (e.g. layered config/defaults)
```

## Waarom het belangrijk is

De `collections`-module biedt het juiste gereedschap voor veel voorkomende patronen, resulterend in schoner en vaak efficiënter code. `defaultdict` en `Counter` vereenvoudigen groepering en tellen drastisch (vervangen uitgebreide handmatige logica); `deque` biedt O(1) dubbelgeëindigde bewerkingen waar een list traag zou zijn; `namedtuple` maakt leesbare lichte records.

Deze gebruiken in plaats van dezelfde patronen met gewone dict/list handmatig opnieuw te implementeren is een teken van idiomatische, performante Python — ze worden veel gebruikt in echte code voor gegevensverwerking, algoritmen en schone API's.