Saltearse al contenido

collections completo

El módulo collections existe porque seis patrones se repetían en todos los programas de Python: contar, agrupar con valor por defecto, usar una cola por los dos extremos, combinar ámbitos, mantener orden explícito y heredar de un diccionario. Cada uno tiene su clase, y cada una evita un dict mal escrito.

Si estás a punto de escribir d[k] = d.get(k, ...), ya existe una clase que lo hace mejor.

Contar un millón de elementos
Forma Tiempo
Counter(letras) 42.1 ms
for x: d[x] = d.get(x, 0) + 1 66.2 ms
c.most_common(3) 2.10 µs

python mediciones/02-08-10-heap-registros-collections.py

Counter está escrito en C y recorre el iterable una vez, sin despachar Python por elemento. La diferencia del 57 % no es lo importante: lo importante es que most_common ordena por frecuencia sin que escribas el sorted(..., key=..., reverse=True) y sus empates.

from collections import Counter
c = Counter("abracadabra")
c.most_common(2) # [('a', 5), ('b', 2)]
c["z"] # 0 — no lanza KeyError
c.update("aaa") # suma
c - Counter("aa") # resta, descartando negativos

La resta de Counter descarta los recuentos que quedan en cero o negativos, lo que sirve para comparar bolsas de elementos (faltan = necesarios - disponibles).

defaultdict: el valor por defecto en el acceso

Sección titulada «defaultdict: el valor por defecto en el acceso»

Ya medido en el capítulo 05: defaultdict(list) es un 26 % más rápido que setdefault y un 43 % más que get+set, porque la fábrica se llama sólo cuando la clave falta.

from collections import defaultdict
grupos = defaultdict(list)
for fila in filas:
grupos[fila.categoria].append(fila)

Cuidado con un detalle: leer una clave inexistente la crea. grupos["nuevo"] devuelve [] y deja la clave dentro. Si sólo quieres consultar, in o get.

El capítulo 01 lo midió: popleft cuesta 0,03 µs frente a 11,6 µs de list.pop(0). Además acepta un tamaño máximo que descarta por el extremo opuesto:

from collections import deque
ultimos = deque(maxlen=3)
for x in range(5):
ultimos.append(x) # deque([2, 3, 4])

Ese maxlen es la forma más limpia de mantener una ventana deslizante o un historial acotado, sin comprobar longitudes a mano.

from collections import ChainMap
config = ChainMap(argumentos, variables_entorno, por_defecto)
config["puerto"] # busca en orden y devuelve el primero que exista

Es el patrón de configuración por capas: argumentos de línea de comandos, luego entorno, luego valores por defecto. Las escrituras van siempre al primer mapa, que es lo que quieres para «sobrescribir en tiempo de ejecución».

Desde Python 3.7 el dict normal conserva el orden de inserción, así que OrderedDict es redundante para casi todo. Sigue teniendo dos operaciones propias: move_to_end(k) y popitem(last=False). Si las necesitas, úsalo; si no, es un dict.

Heredar de dict es una trampa conocida: los métodos en C no llaman a los que sobrescribes. UserDict envuelve un dict interno y sí pasa por tus métodos:

from collections import UserDict
class Config(UserDict):
def __setitem__(self, clave, valor):
print(f"cambiando {clave}")
super().__setitem__(clave, valor)

La regla: si vas a sobrescribir el comportamiento de un mapeo, hereda de UserDict o de collections.abc.MutableMapping, nunca de dict.

  • Counter para contar dos o tres elementos. Un dict normal es más simple y el rendimiento da igual.
  • deque como pila. Una lista con append/pop es más rápida para LIFO; deque existe para FIFO y para ambos extremos.
  • ChainMap para dos diccionarios fijos. {**a, **b} es una línea y no crea una vista dinámica que confunde al leer.
  • OrderedDict «porque es más ordenado». No lo es: desde 3.7 es el mismo orden, con más memoria.

Un programa lee configuración de tres fuentes: un archivo JSON, variables de entorno y argumentos de línea de comandos, en ese orden de prioridad (los argumentos mandan). Escribe el código con ChainMap y explica qué pasa si el programa modifica un valor en tiempo de ejecución.

Solución
import os
from collections import ChainMap
def cargar(argumentos: dict) -> ChainMap:
archivo = leer_json("config.json")
entorno = {k: v for k, v in os.environ.items() if k.startswith("APP_")}
return ChainMap(argumentos, entorno, archivo)

El orden importa: el primer mapa gana. config["puerto"] mira argumentos, luego entorno, luego archivo.

Si el programa hace config["puerto"] = 9000, el valor se escribe en el mapa de argumentos, aunque el original estuviera en el archivo. Eso es lo correcto: el cambio es una decisión de ejecución, no una modificación de la configuración persistida. El archivo queda intacto y el cambio se pierde al terminar.

Si lo que quieres es persistir, no uses ChainMap para escribir: calcula el valor efectivo, modifícalo en el diccionario de archivo y guárdalo explícitamente.

  • Ramalho, L. Fluent Python, 2ª ed. Capítulos 3 y 5.
  • Lott, S. F. Modern Python Cookbook, 3ª ed. Capítulos 4 y 5.
  • Mediciones: mediciones/02-08-10-heap-registros-collections.py.
  • 05 · dict por dentro: la base de Counter, defaultdict y ChainMap.
  • 06 · set y tablas hash: Counter como multiconjunto.
  • 11 · Elección por coste: el cierre de la parte, con todas las tablas juntas.