Saltearse al contenido

dict por dentro

Un diccionario es la estructura más usada de Python y la que menos se entiende. Todo el mundo sabe que es «clave-valor» y que va rápido; casi nadie sabe por qué ocupa treinta y siete bytes por entrada, por qué conserva el orden de inserción sin pagar por él, o por qué defaultdict es más rápido que setdefault cuando los dos hacen lo mismo.

Un dict es una tabla hash con dos arrays: uno de índices y otro de entradas en orden de inserción.

Cómo se guarda un diccionario compacto
índice: 1 B por hueco (8 huecos) 1 B 1 B 1 B 1 B 1 B 1 B 1 B 1 B entradas: 24 B cada una (hash, clave, valor) entrada 24 B entrada 24 B entrada 24 B entrada 24 B

El array de índice es pequeño y disperso: dice en qué entrada está cada hash. Las entradas se guardan compactas, en orden de inserción. Por eso el orden es gratis: ya está en el array de entradas.

Esa separación explica los 36,9 bytes por entrada: no es un objeto por clave, son dos arrays que se redimensionan juntos. Y explica por qué dict conserva el orden desde 3.7 sin coste extra: el array de entradas nunca se reordena.

Construir un diccionario de grupos con 200 000 pares
Patrón Tiempo Comentario
defaultdict(list) 13.9 ms el más rápido
try/except KeyError 14.5 ms casi igual
d.setdefault(k, []).append(v) 18.8 ms crea una lista por llamada
d[k] = d.get(k, []); d[k].append(v) 24.4 ms dos búsquedas y un set

python mediciones/02-05-07-dict-set-orden.py

La diferencia entre defaultdict y setdefault no es estilística: setdefault(k, []) evalúa el [] en cada iteración, aunque la clave ya exista. Con 200 000 pares son 200 000 listas creadas y tiradas. defaultdict sólo llama a la fábrica cuando falta la clave.

try/except es competitivo porque la excepción casi nunca se lanza cuando hay pocas claves. Si el diccionario fuera de un millón de claves únicas, lanzaría un KeyError por elemento y perdería.

Operación Coste
d[k] con clave existente ~30 ns
d[k] = v ~40 ns
k in d ~30 ns
Recorrer el diccionario O(n)

La búsqueda es constante en promedio, no en el peor caso: si todas las claves colisionan, degrada a O(n). Por eso el hash de str está aleatorizado desde 3.3 —evita que un atacante construya colisiones a propósito— y por eso una clase con __hash__ malo puede arruinar un diccionario entero.

a = {"x": 1, "y": 2}
b = {"y": 3, "z": 4}
a | b # {"x": 1, "y": 3, "z": 4} (3.9+)
a |= b # en su sitio
b.keys() - a.keys() # claves que sólo están en b
d = {"a": 1}
d.setdefault("b", []).append(2) # crea si falta
d.get("c", "por defecto") # no crea

Y __missing__ para diccionarios con comportamiento propio:

class PorDefecto(dict):
def __missing__(self, clave):
return f"falta:{clave}"
  • Para pertenencia sola. Si no hay valor asociado, un set ocupa menos (32,8 contra 36,9 por entrada) y expresa mejor la intención.
  • Para datos posicionales. Una lista de tuplas o una dataclass evita claves de texto repetidas en un millón de filas.
  • Cuando el orden importa y cambia. dict conserva el orden de inserción, no lo impone: si necesitas reordenar, ordena al recorrer.

Un informe agrupa 500 000 ventas por (año, mes, región) usando d.setdefault(clave, []).append(venta) y tarda 3 segundos. Propón dos mejoras y estima el ahorro.

Solución

Mejora 1 — cambiar el patrón de agrupación. setdefault construye una lista nueva por cada venta. Con defaultdict(list) el ahorro medido sobre 200 000 pares es del 26 % (18,8 → 13,9 ms). Sobre 3 segundos, unos 0,8 s.

Mejora 2 — no guardar las ventas, agregar. Si el informe sólo necesita el total por grupo, guardar listas de ventas es trabajo y memoria desperdiciados:

from collections import defaultdict
from types import SimpleNamespace
ventas = [
SimpleNamespace(año=2026, mes=11, region="norte", importe=100.0),
SimpleNamespace(año=2026, mes=11, region="norte", importe=50.0),
SimpleNamespace(año=2026, mes=12, region="sur", importe=80.0),
]
totales = defaultdict(float)
for v in ventas:
totales[(v.año, v.mes, v.region)] += v.importe

Eso elimina 500 000 objetos lista y reduce el pico de memoria de cientos de megabytes a unos pocos.

La tercera mejora, si aún hiciera falta: Counter o un dict con clave entera calculada una vez, en lugar de una tupla de tres elementos hasheada en cada acceso.

Comprobación con datos de ejemplo:

for clave, total in sorted(totales.items()):
print(clave, "->", total)
assert totales[(2026, 11, "norte")] == 150.0, "100 + 50"
  • Ramalho, L. Fluent Python, 2ª ed. Capítulo 3: Dictionaries and Sets.
  • CPython 3.13: Objects/dictobject.c (dictresize, tabla combinada).
  • Mediciones: mediciones/02-05-07-dict-set-orden.py.
  • 06 · set y tablas hash: la misma tabla sin valores.
  • 09 · Hashabilidad (Parte I): qué puede entrar como clave.
  • 11 · Elección por coste: cuándo el dict es caro y qué lo sustituye.