Quels types utiles le module `collections` fournit-il ?

Question

Accepted Answer

Le module **`collections`** fournit des types de conteneurs spécialisés qui étendent les list/dict/tuple natifs avec des alternatives pratiques et souvent plus efficaces pour les motifs courants. Les connaître vous permet d'écrire un code plus propre et plus rapide.

## defaultdict — dicts avec des valeurs par défaut automatiques

```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)` (ou `int`, `set`, etc.) fournit une valeur par défaut pour toute clé manquante — éliminant le motif fastidieux de vérification et d'initialisation. Excellent pour le regroupement et le comptage.

## Counter — compter les occurrences

```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` rend le comptage des fréquences trivial — compter des mots, des votes, des occurrences — avec des méthodes pratiques comme `most_common`.

## deque — appends/pops rapides aux DEUX extrémités

```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` est une file bidirectionnelle avec des appends/pops en O(1) aux deux extrémités — idéal pour les files d'attente, les piles et les fenêtres glissantes (une liste ordinaire est O(n) pour les opérations frontales).

## namedtuple — enregistrements légers et nommés

```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` donne aux tuples des champs nommés — plus lisible que l'accès par index, immuable, efficace en mémoire. (Le code moderne utilise souvent `@dataclass` à la place pour les enregistrements mutables.)

## OrderedDict / ChainMap (moins courants maintenant)

```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)
```

## Pourquoi c'est important

Le module `collections` fournit le bon outil pour les motifs courants, conduisant à un code plus propre et souvent plus efficace. `defaultdict` et `Counter` simplifient dramatiquement le regroupement et le comptage (remplaçant la logique manuelle verbeuse) ; `deque` offre des opérations bidirectionnelles en O(1) où une liste serait lente ; `namedtuple` crée des enregistrements légers lisibles.

Utiliser ces outils au lieu de réinventer les mêmes motifs avec des dicts/lists ordinaires est la marque d'un Python idiomatique et performant — ils sont largement utilisés dans le code réel pour le traitement des données, les algorithmes et les APIs propres.