¿Qué tipos útiles proporciona el módulo collections?

Question

Accepted Answer

El módulo **`collections`** proporciona tipos de contenedores especializados que extienden los list/dict/tuple integrados con alternativas convenientes, y a menudo más eficientes, para patrones comunes. Conocerlos te permite escribir código más limpio y rápido.

## defaultdict: dicts con valores por defecto automáticos

```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)` (o `int`, `set`, etc.) suministra un valor por defecto para cualquier clave faltante, eliminando el tedioso patrón de comprobar-e-inicializar. Excelente para agrupar y contar.

## Counter: contar ocurrencias

```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` hace trivial el recuento de frecuencias —contar palabras, votos, ocurrencias— con métodos prácticos como `most_common`.

## deque: inserciones/extracciones rápidas en AMBOS extremos

```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` es una cola de doble extremo con inserciones/extracciones O(1) en ambos lados: ideal para colas, pilas y ventanas deslizantes (una lista simple es O(n) para operaciones en el frente).

## namedtuple: registros ligeros con nombre

```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` da a las tuplas campos con nombre: más legibles que el acceso por índice, inmutables y eficientes en memoria. (El código moderno suele usar `@dataclass` en su lugar para registros mutables.)

## OrderedDict / ChainMap (menos comunes ahora)

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

## Por qué es importante

El módulo `collections` proporciona la herramienta adecuada para patrones comunes, lo que conduce a un código más limpio y a menudo más eficiente. `defaultdict` y `Counter` simplifican drásticamente la agrupación y el conteo (reemplazando lógica manual verbosa); `deque` ofrece operaciones de doble extremo O(1) donde una lista sería lenta; `namedtuple` produce registros ligeros y legibles.

Recurrir a estos en lugar de implementar a mano los mismos patrones con dicts/lists simples es señal de un Python idiomático y eficiente: se usan ampliamente en código real para procesamiento de datos, algoritmos y APIs limpias.