Comprensiones en Python

Procesas cientos de servidores, alertas o métricas, y lo primero que escribes es lo de siempre: lista vacía, bucle for, condición, .append(). Funciona. Python tiene una forma de hacer lo mismo con menos texto y, en la mayoría de los casos, con mejor rendimiento a nivel de bytecode: las Comprensiones (Comprehensions). No son azúcar sintáctico superficial. Son una abstracción que el intérprete trata de manera diferente.

La mecánica central es simple: construyes una secuencia nueva aplicando transformaciones y filtros sobre una secuencia existente, todo en una sola expresión.

Comprensiones de Listas (List Comprehensions)

La diferencia de velocidad frente a un bucle for equivalente existe porque el intérprete optimiza el bytecode generado para la comprensión, sin overhead de llamadas a .append(). Con listas pequeñas la diferencia es ruido, pero en colecciones de miles de elementos empieza a notarse. Lo que no cambia con el tamaño: la legibilidad. Un for de cuatro líneas que mapea una lista es más difícil de leer de un vistazo que su comprensión equivalente, y eso importa cuando revisas el script a las 2 AM con una alerta activa.

Ejemplo Base: Transformación

Tienes latencias de tu balanceador de carga en segundos y tu sistema de monitoreo las quiere en milisegundos.

# Mapeo tradicional:
latencias_segundos = [0.15, 0.45, 1.2, 0.05]
latencias_ms = [latencia * 1000 for latencia in latencias_segundos]

print(latencias_ms)
# Resultado: [150.0, 450.0, 1200.0, 50.0]

Filtrado Condicional (If)

El filtro va pegado al final, después del for. Si tienes una lista de estados de despliegues y solo te importan los fallidos, no construyes primero la lista completa y luego la filtras: la comprensión hace las dos cosas en un solo paso.

estados = ['success', 'fail', 'success', 'timeout', 'pending']
# Filtramos la lista para extraer únicamente los errores
errores = [estado for estado in estados if estado in ('fail', 'timeout')]

print(f"Alertas a procesar: {errores}")
# Resultado: Alertas a procesar: ['fail', 'timeout']

Comprensiones de Diccionarios (Dictionary Comprehensions)

El caso que más uso en la práctica: dos listas paralelas que necesitan cruzarse en un mapa clave-valor. Suele aparecer cuando parseas la salida de una API o una consulta donde los nombres vienen en una columna y los valores en otra. zip() hace el emparejamiento, la comprensión construye el dict. Directo.

# Imagina que sondeaste estos nodos y tienes sus tiempos de respuesta en milisegundos
nodos = ['web-01', 'web-02', 'db-01']
tiempos_respuesta = [45, 120, 310]

# Construir un diccionario combinando ambas listas usando `zip()`
estado_red = {nodo: latencia for nodo, latencia in zip(nodos, tiempos_respuesta)}

print(estado_red)
# Resultado: {'web-01': 45, 'web-02': 120, 'db-01': 310}

El filtro funciona igual que en listas. Para aislar solo los nodos que superan el umbral de 100ms:

nodos_degradados = {nodo: latencia for nodo, latencia in estado_red.items() if latencia > 100}

print(f"Nodos requiriendo atención: {nodos_degradados}")
# Resultado: Nodos requiriendo atención: {'web-02': 120, 'db-01': 310}

Comprensiones de Conjuntos (Set Comprehensions)

Los conjuntos descartan duplicados por construcción. La comprensión usa llaves {} igual que los diccionarios, sin par clave-valor. El caso de uso más directo que conozco: extraer IPs únicas de un access.log con miles de líneas repetidas sin tener que pasar primero por una list comprehension y luego envolver en set().

# Lista simulada de IPs crudas de un archivo access.log (con duplicados)
ips_log = ["192.168.1.1", "10.0.0.5", "192.168.1.1", "10.0.0.8", "10.0.0.5"]

# Generar un conjunto de IPs únicas
ips_unicas = {ip for ip in ips_log}

print(f"IPs distintas detectadas: {ips_unicas}")
# Resultado: IPs distintas detectadas: {'10.0.0.5', '192.168.1.1', '10.0.0.8'}

Una advertencia que no se dice suficiente: si la expresión dentro de la comprensión necesita más de una condición anidada, o si el lector necesita leerla dos veces para entender qué produce, el for tradicional gana. No por convención, sino porque el código que tarda tres segundos más en escribir pero cero en entender es mejor código. Usa comprensiones cuando la intención sea obvia de un vistazo. Cuando no lo sea, no las uses.