Elegir la Estructura de Datos Correcta

Elige contenedores según cómo lees, actualizas y recorres los datos, no por costumbre. La estructura incorrecta cuesta claridad y rendimiento asintótico; la correcta hace que el código sea más corto y rápido sin micro-optimización.

Receta

Haz cuatro preguntas antes de codificar:

1. ¿Necesito pertenencia rápida por valor o clave?
2. ¿Se debe preservar el orden o poder ordenar?
3. ¿Se permiten duplicados?
4. ¿Son los datos tabulares (millones de filas, operaciones de columna)?

Mapea las respuestas a dict, set, list, deque, heapq o bibliotecas de dataframes.

Cuándo recurrir a esto:

• Diseñar el modelo en memoria de un nuevo módulo
• Refactorizar listas anidadas en estructuras más claras
• Revisiones de rendimiento que muestran escaneos O(n) en rutas críticas
• Discusiones de arquitectura antes de la elección de persistencia

Ejemplo de Trabajo

from collections import defaultdict, deque
import heapq
 
# Patrón: indexar usuarios por id -> dict
users_by_id: dict[int, dict] = {1: {"name": "Ada"}, 2: {"name": "Linus"}}
 
# Patrón: eliminar duplicados de etiquetas -> set
tags = set(["py", "ml", "py"])
 
# Patrón: cola de trabajos FIFO -> deque
jobs: deque[str] = deque(["a", "b"])
 
# Patrón: planificación por prioridad -> heapq
heap: list[tuple[int, str]] = []
heapq.heappush(heap, (2, "low"))
heapq.heappush(heap, (1, "high"))
 
# Patrón: agrupar filas -> defaultdict
by_role: defaultdict[str, list[str]] = defaultdict(list)
for name, role in [("Ada", "admin"), ("Linus", "dev")]:
    by_role[role].append(name)

Lo que esto demuestra:

• Dict para búsqueda por clave
• Set para unicidad y pertenencia
• Deque para FIFO sin penalización de pop(0)
• Heap para ordenación por prioridad
• defaultdict para agrupar sin código repetitivo

Análisis Profundo

Tabla de Decisiones

Cómo Funciona

• La asintótica importa a escala - Los escaneos O(n) perjudican a 10^6 elementos, están bien a 50.
• Las constantes importan a n pequeño - La sobrecarga de Dict puede perder frente al escaneo de lista para colecciones muy pequeñas.
• La inmutabilidad señala la intención - Tuple/frozenset documentan la estabilidad y permiten el hash.
• La composición supera al "talla única" - Grafo como dict[nodo, set[vecino]] combina dict + set.
• Límite de persistencia - La elección en memoria difiere de la decisión SQL/Redis.

Notas de Python

# olor: búsqueda lineal repetida
if item in big_list:  # O(n) cada vez
 
# arreglo: construir set una vez
seen = set(big_list)
if item in seen:  # O(1) en promedio

Trampas

• list como set - if x in items en una lista grande en un bucle → O(n²). Arreglo: Preconstruir set(items).
• dict cuando una lista de pares es suficiente - Los registros de dos elementos a veces son mejores como tuplas en una lista. Arreglo: Simplificar hasta que se necesite búsqueda por clave.
• pandas para 20 filas - Pesada importación y sobrecarga de API. Arreglo: Diccionario/lista simple hasta cientos de filas o operaciones de columna.
• OrderedDict por defecto - Innecesario ya que dict está ordenado. Arreglo: Diccionario simple a menos que move_to_end.
• Heap prematuro - Cinco elementos ordenados una vez → sorted. Arreglo: heap cuando k << n o en streaming.

Alternativas

Preguntas Frecuentes

Relacionados

• Conceptos Básicos de Estructuras de Datos - Resumen de Big-O
• Módulo collections - contenedores especializados
• Inmutabilidad y Hashabilidad - restricciones clave
• heapq y Colas de Prioridad - planificación

Versiones de Stack: Esta página fue escrita para Python 3.14.0 (estable 3.14, mantenimiento 3.13), FastAPI 0.115+, Django 5.2, Flask 3.1, Pydantic 2, PyTorch 2.6+, pandas 2.2+, Polars 1.x, ruff 0.9+, y uv 0.6+.