¿Qué es la iteración?

Un programa que envía un correo de recordatorio a 10.000 usuarios no contiene 10.000 copias del código de envío. Contiene ese código una sola vez, dentro de un bucle, y el bucle lo ejecuta una vez por usuario. Cada ejecución es una iteración, y el bucle en su conjunto es la forma en que el programa itera sobre sus usuarios.

Cómo funciona la iteración, paso a paso

Todo bucle sigue el mismo ciclo:

1. Comprobar. Evalúa la condición del bucle, que es un booleano: ¿queda otro elemento, o el contador sigue por debajo del límite?
2. Ejecutar. Si la respuesta es verdadera, ejecuta una vez el cuerpo del bucle.
3. Actualizar. Pasa al siguiente elemento o cambia el contador.
4. Repetir. Vuelve al paso 1. Cuando la comprobación da falso, el programa sigue con el código que hay después del bucle.

Aquí el cuerpo se ejecuta cinco veces, y cada iteración suma el siguiente número a un total acumulado:

total = 0

for n in range(1, 6):
    total = total + n
    print("iteration", n, "total is now", total)

print("Done:", total)

iteration 1 total is now 1
iteration 2 total is now 3
iteration 3 total is now 6
iteration 4 total is now 10
iteration 5 total is now 15
Done: 15

La variable total vive fuera del bucle, así que conserva su valor de una iteración a la siguiente. Ese patrón, una variable asignada antes del bucle y actualizada dentro de él, se llama acumulador, y aparece en casi todos los bucles que calculan algo.

Bucles que cuentan y bucles con condición

Hay dos tipos de iteración. La iteración definida se ejecuta un número conocido de veces: una vez por cada elemento de una lista, o una vez por cada número del 1 al 5. El bucle for de Python está hecho para esto, a menudo junto con range().

La iteración indefinida se repite hasta que ocurre algo, y el número de pasadas no se conoce de antemano. Un bucle while encaja en este caso:

balance = 100
years = 0

while balance < 200:
    balance = balance * 1.10
    years = years + 1

print(years, "years, balance", round(balance, 2))

8 years, balance 214.36

Un dinero que crece un 10 % al año tarda 8 años en duplicarse. El programa lo averiguó iterando, no resolviendo una ecuación. Las guías de bucles for y bucles while cubren los dos en Python.

Iterar sobre una colección

La mayoría de los bucles recorren una colección: los elementos de un array, los caracteres de un string, las líneas de un archivo. El bucle for de Python te da cada elemento directamente, y enumerate() añade su posición:

fruits = ["apple", "banana", "cherry"]

for index, fruit in enumerate(fruits):
    print(index, fruit)

0 apple
1 banana
2 cherry

Por debajo, for pide a la colección un iterador con iter() y después llama a next() sobre él una vez por iteración. Puedes hacer tú mismo esas mismas llamadas:

colors = ["red", "green", "blue"]

it = iter(colors)
print(next(it))
print(next(it))
print(next(it))
print(next(it, "no more items"))

red
green
blue
no more items

Sin el valor por defecto, el cuarto next() lanza StopIteration. Esa excepción es la señal que usa un bucle for para saber que la colección se ha terminado.

Otros lenguajes escriben la misma idea de otra forma. C cuenta con un índice, mientras que Java y JavaScript también tienen un bucle que te da cada elemento:

for (int i = 0; i < 3; i++) {
    printf("%s\n", colors[i]);
}

for (String color : colors) {
    System.out.println(color);
}

for (const color of colors) {
    console.log(color);
}

Iteración vs recursión

La recursión es la otra forma de repetir trabajo: una función se llama a sí misma con una versión más pequeña del problema hasta llegar a un caso que puede responder directamente. Todo lo que se escribe con una se puede escribir con la otra, pero se comportan de forma distinta:

La fila de la memoria importa en la práctica. Python permite unas 1.000 llamadas anidadas por defecto, así que una suma recursiva de 5.000 números falla donde un bucle no tiene ningún problema:

def sum_loop(n):
    total = 0
    for k in range(1, n + 1):
        total = total + k
    return total

def sum_recursive(n):
    if n == 0:
        return 0
    return n + sum_recursive(n - 1)

print(sum_loop(100), sum_recursive(100))
print(sum_loop(5000))

try:
    print(sum_recursive(5000))
except RecursionError:
    print("sum_recursive(5000) failed: RecursionError")

5050 5050
12502500
sum_recursive(5000) failed: RecursionError

La visualización de la recursión muestra paso a paso cómo crece y se reduce la pila de llamadas.

Errores comunes

El bucle infinito. Un bucle while cuya condición nunca se vuelve falsa se ejecuta hasta que detienes el programa. La causa habitual es olvidar el paso de actualización, por ejemplo omitir count = count - 1.

Pasarse por uno. range(1, 5) da 1, 2, 3 y 4, no 5, porque el valor final queda excluido. Un bucle que se ejecuta una vez de más o de menos sigue funcionando sin error y da una respuesta equivocada, lo que es un error lógico.

Cambiar una lista mientras la recorres. Quitar elementos de la lista sobre la que estás iterando hace que el bucle se salte elementos:

numbers = [1, 2, 2, 3]

for n in numbers:
    if n == 2:
        numbers.remove(n)

print(numbers)

[1, 2, 3]

Un 2 sobrevivió, porque al quitar el primer 2 el segundo se desplazó a una posición que el bucle ya había pasado. Construye una lista nueva en su lugar: numbers = [n for n in numbers if n != 2].

Qué leer después

Los bucles recorren colecciones, así que qué es un array es la página que mejor la acompaña, y qué es un booleano explica las comprobaciones de verdadero o falso que deciden cuándo se detiene un bucle. Cuando un bucle da un resultado equivocado sin ningún mensaje de error, lee qué es un error lógico. Para practicar escribiendo bucles, empieza el curso de Python o prueba los ejemplos de arriba en el playground de Python.