Mis apuntes · Aprende Python desde PHP

Se guardan solos en este navegador mientras escribes. Puedes usar Markdown. Al descargarlos, la primera línea es tu enlace personal al curso.

Lección 16 de 47 · Colecciones en acción y matrices ✦ WebMCP implementado

Adiós for anidados: comprehensions, itertools y Counter

10 min de lectura 4 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.

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 in range(300)]
segunda = [f"etiqueta-{i}" for i in range(150, 450)]

# Con dos bucles anidados.
pasos_anidados = 0
comunes = []
for x in primera:
    for y in segunda:
        pasos_anidados += 1
        if 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 += 1
    if 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 if len(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 in range(len(titulos)):
    print(titulos[i], horas[i])

# BIEN: zip.
for titulo, h in zip(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 in product(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 return sale de todo de una vez.

Atención: product no 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"]])
PHP 8.5index.php
<?php
declare(strict_types=1);

$usuarios = [["id" => 1, "nombre" => "Ana"], ["id" => 2, "nombre" => "Luis"]];
$tareas = [["titulo" => "Comprar pan", "usuario_id" => 2], ["titulo" => "Llamar al banco", "usuario_id" => 1]];

$nombrePorId = array_column($usuarios, "nombre", "id");
foreach ($tareas as $tarea) {
    echo $tarea["titulo"] . " -> " . ($nombrePorId[$tarea["usuario_id"]] ?? "sin asignar") . PHP_EOL;
}
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}]

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 not in ids_hechas]

# Con un set, el "in" es instantáneo.
hechas = set(ids_hechas)
pendientes = [i for i in ids_todas if i not in 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 import Counter, 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:

  1. 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.
  2. Las colecciones son pequeñas y no van a crecer: un doble bucle sobre 5 × 5 es más claro que un índice.
  3. 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
1Buscar un elemento (if a == b)dict indexado, o set
2Comprobar pertenencia (if x in lista)set
3Contar o agruparCounter / defaultdict
4Recorrer dos listas a la vezzip
5Aplanar una lista de listasComprensión con dos for o chain.from_iterable
6Todas las parejasitertools.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.

Hora de practicar

Retos · 0/4 resueltos

Reto 1 de 4

La etiqueta más repetida

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

Resumen

Lo que te llevas de esta lección

  1. 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).
  2. Buscar → dict indexado por id (en PHP, array_column($a, null, "id")). «¿Está?» → set (en PHP, isset($a[$x])).
  3. Contar y agrupar → Counter y defaultdict (en PHP, array_count_values y el $g[$k][] = …).
  4. 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)).
  5. 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.