Lección 16 de 47 · Colecciones en acción y matrices✦ WebMCP implementado
Adiós for anidados: comprehensions, itertools y Counter
10 min de lectura4 retos
Un for dentro de otro for es lo primero que se te ocurre cuando tienes que cruzar dos colecciones. Funciona, pero con datos grandes se vuelve lentísimo y, además, se lee fatal. En esta lección ves por qué, cuántas operaciones cuesta de verdad y qué usar en su lugar: comprensiones, zip, itertools, diccionarios como índice, conjuntos y Counter.
¿De dónde vienen los nombres?
itertools = iterator tools (herramientas de iteradores)
Un módulo de la biblioteca estándar con piezas para recorrer cosas: combinar, encadenar, repetir… sin escribir bucles.
product = producto cartesiano (de René Descartes, que lo usó en matemáticas)
Todas las parejas posibles entre dos grupos: cada camiseta con cada pantalón.
Counter = inglés counter (contador)
Un diccionario que cuenta cuántas veces sale cada cosa. Es el array_count_values de PHP, con más trucos.
defaultdict = default (por defecto) + dict
Un diccionario que, si pides una clave que no existe, la crea con un valor por defecto en vez de dar error.
comprensión (comprehension) = inglés comprehension, del latín comprehendere (abarcar, incluir)
Una expresión que abarca de golpe todo lo que quieres construir: [x for x in …].
En 4 ideas
1/4
Un for dentro de otro hace n × m pasos: con 1.000 y 1.000 elementos son un millón de comprobaciones. En PHP es el foreach dentro de foreach con un in_array dentro, el patrón más lento de cualquier código.
Casi siempre se evita con otra estructura: un set para «¿está?» (el isset($a[$x]) de PHP), un dict indexado por id (el array_column($a, null, "id")) o un Counter para contar (el array_count_values).
Para recorrer sin anidar hay herramientas: comprensiones con dos for, zip (en paralelo), itertools.product (todas las parejas) y chain.from_iterable (aplanar).
Un doble bucle no es un pecado si de verdad necesitas todas las parejas. El problema es usarlo para buscar: ahí hay siempre una forma más barata.
1 · El problema: un bucle dentro de otro
Tienes las etiquetas de dos tareas y quieres saber cuáles tienen en común. Lo más directo: coger cada etiqueta de la primera y compararla con todas las de la segunda.
Pythonmain.py
primera = ["casa", "compras", "urgente"]
segunda = ["dinero", "casa", "urgente"]
comunes = []
for etiqueta in primera:
for otra in segunda:
if etiqueta == otra:
comunes.append(etiqueta)
print(comunes)
Con 3 etiquetas no pasa nada. Pero esto es un patrón que crece mal, y se parece a lo que hace un in_array dentro de un foreach en PHP. Mira cuántos pasos da con más datos:
Pythonmain.py
primera = [f"etiqueta-{i}"for i inrange(300)]
segunda = [f"etiqueta-{i}"for i inrange(150, 450)]
# Con dos bucles anidados.
pasos_anidados = 0
comunes = []
for x in primera:
for y in segunda:
pasos_anidados += 1if x == y:
comunes.append(x)
# Con un conjunto: se construye una vez y cada "in" va directo.
pasos_con_set = 0
en_segunda = set(segunda)
pasos_con_set += len(segunda)
comunes_set = []
for x in primera:
pasos_con_set += 1if x in en_segunda:
comunes_set.append(x)
print("Anidados:", pasos_anidados, "pasos")
print("Con set:", pasos_con_set, "pasos")
print("Mismo resultado:", comunes == comunes_set, len(comunes))
¿Por qué? · En PHP no existe
¿Por qué crece tan mal? La cuenta del patio del colegio
Imagina 30 niños que se saludan todos con todos: cada niño da la mano a los otros 29. Son unos 900 saludos. Con 300 niños, 90.000. Con 3.000, 9 millones. El trabajo no crece al ritmo de los niños, crece como niños × niños.
Con un set hacemos algo distinto: apuntamos a todos en una lista de invitados (30 pasos) y, para cada niño, miramos una sola vez si está en la lista (30 pasos más). Son 60 pasos, no 900. Con 3.000 niños son 6.000, no 9 millones.
A esto los programadores lo llaman coste cuadrático (n × m) frente a coste lineal (n + m). Importa porque tus datos van a crecer: una app de tareas con 100 tareas va bien con cualquier cosa y con 100.000 se cae con el bucle anidado.
2 · El otro problema: se lee mal
Además del coste, el anidado esconde lo que hace. Con tres niveles el código se va hacia la derecha (la «flecha») y, para entender una línea, hay que tener en la cabeza todos los bucles que la rodean:
Pythonmain.py
tareas = ["pan", "banco", "python"]
dias = ["lunes", "martes"]
franjas = ["mañana", "tarde"]
plan = []
for tarea in tareas:
for dia in dias:
for franja in franjas:
if tarea != "banco"or franja == "mañana":
plan.append((tarea, dia, franja))
print(len(plan))
El break solo sale del bucle de dentro: quien viene de PHP cree que sale de todos (en PHP puedes escribir break 2; Python no tiene eso) y deja un fallo silencioso.
Las variables se pisan con facilidad (i dentro de i) y se llega a nombres como x2 y j3.
Para probarlo hay que ejecutar todo: no puedes comprobar una parte por separado.
Se oculta la intención: ¿es «todas las parejas»? ¿«buscar»? ¿«comparar uno con otro»? Hay que leer el cuerpo para saberlo.
¿Por qué? · En PHP no existe
¿Por qué Python se empeña en que no anides?
Porque en Python la indentación es la sintaxis (lección 1): cada nivel más hacia la derecha cuesta un poco de legibilidad y a los cuatro o cinco niveles el código se sale de la pantalla. Es una presión de diseño deliberada: el lenguaje te hace notar el problema antes de que se convierta en un fallo.
Y al contrario de PHP, en Python hay herramientas hechas para casi cada motivo por el que anidarías (las de abajo), de modo que normalmente no hace falta.
3 · Comprensiones: los dos for en una línea
Una comprensión puede tener más de un for, y se leen en el mismo orden que si los escribieras anidados: primero el de fuera, después el de dentro. Es lo ideal para aplanar una lista de listas.
Pythonmain.py
por_dia = [["pan", "leche"], ["banco"], ["python", "deporte", "ducha"]]
# Con bucles: el de fuera, luego el de dentro.
todas = []
for dia in por_dia:
for tarea in dia:
todas.append(tarea)
print(todas)
# Con comprensión: LOS MISMOS for, en el MISMO orden, con el resultado delante.# En PHP: array_merge(...$porDia)print([tarea for dia in por_dia for tarea in dia])
# Con una condición al final.print([tarea for dia in por_dia for tarea in dia iflen(tarea) > 4])
# Otra forma de aplanar: itertools.chain.from_iterable (perezosa).from itertools import chain
print(list(chain.from_iterable(por_dia)))
4 · zip: recorrer en paralelo, sin anidar
A veces el doble for no es para cruzar, sino para recorrer dos listas a la vez con un contador. Eso es zip, de la lección anterior: una sola vuelta, sin índices.
Pythonmain.py
titulos = ["Comprar pan", "Llamar al banco", "Repasar Python"]
horas = [1, 2, 4]
# MAL (estilo PHP): el índice, y un for que busca lo que ya sabe.for i inrange(len(titulos)):
print(titulos[i], horas[i])
# BIEN: zip.for titulo, h inzip(titulos, horas, strict=True):
print(titulo, h)
5 · itertools.product: todas las parejas, sin anidar
Cuando de verdad necesitas todas las parejas (cada camiseta con cada pantalón), itertools.product las produce con un solo for. Quita la flecha del código sin cambiar el trabajo: son las mismas n × m parejas, pero escritas en una línea que dice lo que hace.
Pythonmain.py
from itertools import combinations, product
tareas = ["pan", "banco", "python"]
dias = ["lunes", "martes"]
franjas = ["mañana", "tarde"]
# En PHP: tres foreach anidados.for tarea, dia, franja inproduct(tareas, dias, franjas):
if tarea != "banco"or franja == "mañana":
print(tarea, dia, franja)
# repeat=N: el mismo grupo N veces (todas las secuencias de 2 horas del día).print(len(list(product(range(3), repeat=2))))
# combinations: parejas SIN repetir ni importar el orden (A-B, pero no B-A).print(list(combinations(["pan", "banco", "python"], 2)))
¿Por qué? · En PHP no existe
¿Por qué product es mejor si hace lo mismo?
Porque dice lo que quiere: «todas las combinaciones». Con tres for anidados, el lector tiene que deducirlo. Además es perezoso (no crea todas las parejas en memoria de golpe) y, al ser una sola línea de for, un break o un returnsale de todo de una vez.
Atención: productno es más barato. Si necesitas las 1.000 × 1.000 parejas, son un millón. Lo que quita es el ruido, no el trabajo. Para ahorrar trabajo, hay que evitar mirar parejas (siguientes secciones).
6 · Un diccionario como índice: adiós a buscar
El motivo número uno de un doble bucle es buscar: «para cada tarea, busca a su usuario en la lista de usuarios». El remedio es construir una vez un diccionario que dé el usuario a partir de su id.
Pythonmain.py
usuarios = [{"id": 1, "nombre": "Ana"}, {"id": 2, "nombre": "Luis"}]
tareas = [
{"titulo": "Comprar pan", "usuario_id": 2},
{"titulo": "Llamar al banco", "usuario_id": 1},
{"titulo": "Repasar Python", "usuario_id": 2},
]
# MAL: para cada tarea, recorre los usuarios hasta dar con el suyo.for tarea in tareas:
for usuario in usuarios:
if usuario["id"] == tarea["usuario_id"]:
print(tarea["titulo"], "->", usuario["nombre"])
# BIEN: un índice, construido una vez.# En PHP: $porId = array_column($usuarios, "nombre", "id");
nombre_por_id = {u["id"]: u["nombre"] for u in usuarios}
for tarea in tareas:
print(tarea["titulo"], "->", nombre_por_id[tarea["usuario_id"]])
usuarios = [{"id": 1, "nombre": "Ana"}, {"id": 2, "nombre": "Luis"}]
tareas = [{"titulo": "Comprar pan", "usuario_id": 2}, {"titulo": "Llamar al banco", "usuario_id": 1}]
nombre_por_id = {u["id"]: u["nombre"] for u in usuarios}
for tarea in tareas:
print(tarea["titulo"], "->", nombre_por_id.get(tarea["usuario_id"], "sin asignar"))
7 · Conjuntos: la pertenencia al instante
El segundo motivo para anidar es comprobar si algo está en otra lista: if x in lista es un bucle escondido. Lo ves en la lista de abajo: son dos bucles aunque solo escribas uno.
Pythonmain.py
ids_hechas = [2, 4, 6, 8, 10]
ids_todas = list(range(1, 11))
# Un bucle y un "in" sobre una lista: en realidad son dos bucles.
pendientes_lenta = [i for i in ids_todas if i notin ids_hechas]
# Con un set, el "in" es instantáneo.
hechas = set(ids_hechas)
pendientes = [i for i in ids_todas if i notin hechas]
print(pendientes_lenta == pendientes, pendientes)
# Y para comparar dos grupos enteros, operaciones de conjuntos.
tareas_ana = {"pan", "banco", "python"}
tareas_luis = {"python", "deporte"}
print(sorted(tareas_ana & tareas_luis))
print(sorted(tareas_ana - tareas_luis))
8 · Counter y defaultdict: contar y agrupar sin buscar
El tercer motivo: contar y agrupar. «Cuántas veces sale cada etiqueta» tentaba a hacer un bucle por cada etiqueta recorriendo todas las tareas. Counter lo hace de una pasada; defaultdict agrupa sin comprobar si la clave existe.
Pythonmain.py
from collections importCounter, defaultdict
etiquetas = ["casa", "dinero", "casa", "estudio", "casa", "dinero"]
# En PHP: array_count_values($etiquetas)
cuenta = Counter(etiquetas)
print(cuenta)
print(cuenta.most_common(2))
print(cuenta["casa"], cuenta["no-existe"])
# defaultdict(list): si la clave no existe, crea una lista vacía.
tareas = [
{"titulo": "Comprar pan", "prioridad": 2},
{"titulo": "Llamar al banco", "prioridad": 3},
{"titulo": "Repasar Python", "prioridad": 2},
]
por_prioridad = defaultdict(list)
for tarea in tareas:
por_prioridad[tarea["prioridad"]].append(tarea["titulo"])
print(dict(por_prioridad))
# Counter se puede sumar y restar: útil para combinar agendas.print(Counter(pan=1, python=2) + Counter(python=3, deporte=1))
¿Por qué? · En PHP no existe
¿Por qué Counter y defaultdict si ya hay diccionarios?
En PHP, contar con un array obliga a escribir una y otra vez: $c[$x] = ($c[$x] ?? 0) + 1;. Con un dict de Python, c[x] += 1 lanza KeyError si x no existía. Counter arregla eso (una clave que no existe vale 0) y defaultdict hace lo mismo para listas, sets o lo que quieras.
Resultado: el bucle de «buscar si existe y si no, crear» desaparece, y con él uno de los motivos del doble bucle.
9 · Cuándo SÍ está bien anidar
«Evitar» no es «prohibir». Un doble bucle es la respuesta correcta cuando:
De verdad necesitas todas las parejas (el producto cartesiano): una tabla de multiplicar, el horario de todas las tareas en todos los días. Aquí product solo lo escribe más limpio.
Las colecciones son pequeñas y no van a crecer: un doble bucle sobre 5 × 5 es más claro que un índice.
Recorres una matriz (filas y columnas): lo verás en la lección 16, y NumPy te dará aún otra forma de no escribirlo.
#
Lo que haces dentro del doble bucle
Úsalo en su lugar
1
Buscar un elemento (if a == b)
dict indexado, o set
2
Comprobar pertenencia (if x in lista)
set
3
Contar o agrupar
Counter / defaultdict
4
Recorrer dos listas a la vez
zip
5
Aplanar una lista de listas
Comprensión con dos for o chain.from_iterable
6
Todas las parejas
itertools.product / combinations
La pregunta que te vas a hacer
Vale, pero… ¿cómo sé cuánto tarda mi código en la práctica?
Mídelo, no lo supongas: el módulo timeit ejecuta un trozo de código muchas veces y te da el tiempo. Para saber qué coste tiene cada operación de las colecciones (in en lista frente a in en set, por ejemplo), la documentación de Python lo publica en una tabla.
Usa Counter para contar las etiquetas e imprime la más común con su número de apariciones: [('casa', 3)]. Es el array_count_values() + arsort() de PHP.
Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.
Pythonmain.py · editable
Pista.Counter(etiquetas) cuenta de una pasada; después .most_common(1) te da la más repetida.
Reto 2 de 4 · ✓ Resuelto
Etiquetas en común, sin doble bucle
Escribe comunes(a, b): devuelve una lista ordenada con los elementos que están en ay en b, sin repetidos y sin bucles anidados (usa conjuntos). Es el array_intersect de PHP.
Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.
Pythonmain.py · editable
Pista. Convierte los dos en set y usa & (intersección). sorted(...) lo devuelve como lista ordenada.
Reto 3 de 4 · ✓ Resuelto
El horario completo
Escribe horario(tareas, dias): devuelve la lista de todas las parejas(tarea, dia) como tuplas, en este orden: primero todos los días de la primera tarea, luego los de la segunda… Un solo for (o ninguno): usa itertools.product. Es el doble foreach de PHP.
Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.
Pythonmain.py · editable
Pista.product(tareas, dias) devuelve las parejas ya como tuplas; pásalo por list(...).
Reto 4 de 4 · ✓ Resuelto
Cada tarea con su responsable
Escribe con_responsable(tareas, usuarios): cada tarea tiene titulo y usuario_id; cada usuario, id y nombre. Devuelve una lista de textos "Comprar pan (Luis)", en el orden de las tareas; si el usuario no existe, "Comprar pan (sin asignar)". Hazlo sin buscar con un bucle dentro de otro: construye un diccionario por id.
Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.
Pythonmain.py · editable
Pista. Primero {u["id"]: u["nombre"] for u in usuarios}; luego, por cada tarea, .get(t["usuario_id"], "sin asignar").
Resumen
Lo que te llevas de esta lección
Doble for = n × m pasos: 1.000 × 1.000 es un millón. Con un set o un dict son 1.000 + 1.000 (en PHP, foreach + in_array frente a isset).
Buscar → dict indexado por id (en PHP, array_column($a, null, "id")). «¿Está?» → set (en PHP, isset($a[$x])).
Contar y agrupar → Counter y defaultdict (en PHP, array_count_values y el $g[$k][] = …).
Recorrer sin anidar: zip en paralelo, product para todas las parejas, comprensión con dos for para aplanar (en PHP, array_map(null, …), array_merge(...$a)).
Un doble bucle no es malo si de verdad necesitas todas las parejas: el error es usarlo para buscar.
Para recordarlo: «Buscas, Dict · Preguntas, Set · Cuentas, Counter»
BBuscas → dict indexado por id
PPreguntas «¿está?» → set
CCuentas o agrupas → Counter / defaultdict
Cada vez que escribas un for dentro de un for, pregúntate: ¿estoy buscando, preguntando o contando? Si sí, hay una estructura que lo hace de una pasada.