Comprensiones de listas y expresiones de dict / set / generator — Construye colecciones en una línea

En el artículo anterior sobre all() / any(), viste cómo evaluar una colección entera de una sola vez. Esta vez darás un paso más y verás la sintaxis poderosa para construir la propia colección en una sola línea — las comprensiones.

Empezaremos con las comprensiones de lista, añadiremos el filtrado con if, veremos las variantes de dict y set, y terminaremos con la expresión generadora que ahorra memoria.

Fundamentos de la comprensión de lista — Mete un bucle for en una línea

Python tiene una sintaxis de una línea para construir listas: [expresión for variable in iterable]. Esto se llama comprensión de lista.

Es un atajo para el patrón del bucle for que comienza con una lista vacía y llama a append() repetidamente, y brilla cuando quieres aplicar la misma transformación a cada elemento y producir una nueva lista.

# Usando un bucle for
result = []
for price in [100, 250, 480]:
    result.append(int(price * 1.1))
print(result)   # [110, 275, 528]

# Lo mismo como comprensión de lista
prices = [100, 250, 480]
tax_included = [int(p * 1.1) for p in prices]
print(tax_included)   # [110, 275, 528]

# Recopilando longitudes de cadena también en una línea
names = ["Alice", "Bob", "Charlotte"]
lengths = [len(n) for n in names]
print(lengths)   # [5, 3, 9]

Construye una nueva lista de precios de productos con el 10% de impuesto añadido, usando una comprensión de lista.

① Declara prices = [100, 250, 480, 1200].

② Usa la comprensión de lista [int(p * 1.1) for p in prices] para construir la lista con impuestos incluidos y asígnala a tax_included.

③ Imprime el resultado con print(tax_included).

(Cuando la respuesta sea correcta, aparecerá la explicación.)

Filtrar con if — Comprensiones condicionales

Añade if condición después de for y solo los elementos que satisfacen la condición terminan en la nueva lista. La forma es [expresión for variable in iterable if condición].

Escribir la transformación y el filtro en la misma línea es lo que hace concisas a las comprensiones de lista — extraer «solo los elementos que coinciden» se convierte en una línea corta y legible.

# Extrae solo los elementos >= 200
prices = [80, 250, 120, 480, 95]
premium = [p for p in prices if p >= 200]
print(premium)         # [250, 480]

# Filtra y transforma al mismo tiempo
discounted = [int(p * 0.9) for p in prices if p >= 200]
print(discounted)      # [225, 432]   ← 10% de descuento, solo elementos >= 200

# Filtrar y transformar sobre cadenas
names = ["Alice", "Bob", "Charlotte", "Ed"]
long_names = [n.upper() for n in names if len(n) >= 5]
print(long_names)      # ['ALICE', 'CHARLOTTE']

A partir de los datos de inventario, extrae los nombres de productos con stock 1 o más.

① Declara stocks = [("manzana", 12), ("banana", 0), ("naranja", 5), ("uva", 0), ("kiwi", 3)].

② Usa [name for name, count in stocks if count > 0] para construir la lista de nombres de productos en stock y asígnala a available (el desempaquetado de tuplas te permite enlazar name y count al mismo tiempo).

③ Imprime el resultado con print(available).

Comprensiones de dict y comprensiones de set

Cambia los corchetes [ ] de una comprensión de lista por llaves { } y obtienes una comprensión de conjunto.

Da un paso más con {clave: valor for ...} y los dos puntos lo convierten en una comprensión de diccionario. La sintaxis for ... in ... es idéntica — solo cambia la forma de la colección de salida, y esa flexibilidad es lo que hace tan útiles a las comprensiones.

# Comprensión de dict: construye una búsqueda nombre → precio
pairs = [("manzana", 120), ("naranja", 80), ("banana", 60)]
price_lookup = {name: price for name, price in pairs}
print(price_lookup)
# {'manzana': 120, 'naranja': 80, 'banana': 60}

# Reconstruye un dict con precios con impuestos incluidos
tax_included = {name: int(price * 1.1) for name, price in pairs}
print(tax_included)
# {'manzana': 132, 'naranja': 88, 'banana': 66}

# Comprensión de set: extrae etiquetas únicas (sin duplicados)
tags = ["sale", "new", "sale", "limited", "new"]
unique = {t for t in tags}
print(unique)   # {'sale', 'new', 'limited'} (el orden depende de la implementación)

Combina zip() con comprensiones de dict

Cuando tienes dos listas paralelas como names y prices y quieres un dict, {n: p for n, p in zip(names, prices)} encaja perfectamente. zip() recorre las listas al unísono para que puedas construir las claves y los valores al mismo tiempo.

A partir de una lista de tuplas (nombre, precio), construye un dict producto → precio con impuestos en una línea.

① Declara pairs = [("manzana", 120), ("naranja", 80), ("banana", 60), ("kiwi", 200)].

② Usa la comprensión de dict {name: int(price * 1.1) for name, price in pairs} para construir la búsqueda con impuestos y asígnala a tax_lookup.

③ Imprime el resultado con print(tax_lookup).

Expresiones generadoras — Cambia los corchetes por paréntesis

Cambia los corchetes [ ] de una comprensión de lista por paréntesis ( ) y tienes una expresión generadora. A diferencia de una lista, no materializa todos los elementos en memoria — calcula solo lo que necesitas, cuando lo necesitas (evaluación perezosa).

Puedes pasarla directamente a sum() / max() / min() / any(), lo que mantiene bajo el uso de memoria al agregar grandes cantidades de datos. La explicación detallada está en el artículo sobre funciones generadoras más adelante.

# Los paréntesis crean una expresión generadora
prices = [100, 250, 480, 1200]
gen = (int(p * 1.1) for p in prices)
print(type(gen))   # <class 'generator'>

# Pásala directamente a sum() (los paréntesis externos pueden omitirse)
total_tax = sum(int(p * 1.1) for p in prices)
print(total_tax)   # 2233

# El mismo truco con max() / min()
max_tax = max(int(p * 1.1) for p in prices)
print(max_tax)     # 1320

Elige según el caso de uso: ¿«todo a la vez» o «uno a la vez»?

Si quieres toda la cosa como una lista en la mano, usa [ ] (comprensión de lista). Si solo estás pasándolo a sum() / max() para agregar, ( ) (expresión generadora) es la elección más amigable con la memoria. A escala de un millón de elementos la diferencia es dramática — la expresión generadora usa solo unos pocos cientos de bytes.

Para una lista de precios de productos, calcula el precio total con impuestos combinando una expresión generadora con sum().

① Declara prices = [100, 250, 480, 1200].

② Calcula el total con impuestos con sum(int(p * 1.1) for p in prices) y asígnalo a total (puedes meter la expresión generadora directamente entre los paréntesis de sum()).

③ Imprime el resultado con print(total).