Python: bucle for, recorrer una secuencia elemento a elemento

Nivel: iniciación · Pregunta que responde: ¿Cómo hacemos que Python repita un bloque una vez por cada elemento de una secuencia o por cada número de un intervalo? · Requisitos previos: variables, operadores, estructuras condicionales con if y bucle while.

Del «While» al «For»

Un vigilante llega de noche a una puerta cerrada con un llavero de siete llaves. No necesita preguntarse cuántas vueltas dará su búsqueda: sabe exactamente lo que tiene en la mano. Toma la primera llave y la prueba. Después la segunda. Después la tercera. Para cada llave del llavero, repite el mismo gesto.

Esa es la idea de un bucle for.

En la lección anterior vimos que while repite un bloque mientras una condición siga siendo verdadera. La pregunta era siempre la misma: ¿qué mantiene viva la repetición y qué hará que termine?

Con for la pregunta cambia. Ya no partimos de una condición, sino de algo que recorrer: los caracteres de un texto, una serie de números, los elementos de una colección. El bucle se ejecuta una vez por cada elemento y termina cuando no quedan más.

La instrucción for existe en la mayoría de los lenguajes de programación, pero no siempre funciona igual. En C, el programador define el paso y la condición de parada; en Pascal se recorre una progresión de números. En Python, for recorre los elementos de una secuencia en el orden en que aparecen. Dicho de forma breve: for repite un bloque una vez por cada elemento de lo que recorre.

for repite un bloque una vez por cada elemento de lo que recorre.

La estructura básica de for

La forma general es:

for variable in secuencia:
    instrucciones

Cada parte tiene un papel:

• for y in son palabras reservadas;
• secuencia es lo que vamos a recorrer;
• variable es el nombre que recibirá, en cada vuelta, el elemento que toca;
• los dos puntos y la sangría delimitan el bloque, igual que en if y while.

Python sigue esta secuencia: toma el primer elemento, lo asigna a la variable y ejecuta el bloque. Después toma el siguiente, lo asigna y vuelve a ejecutar el bloque. Así hasta agotar los elementos. Entonces sale del bucle y continúa con la instrucción siguiente.

Hay un detalle importante: la secuencia se evalúa una sola vez, al empezar. El bucle no vuelve a calcularla en cada vuelta: simplemente va pidiendo el elemento siguiente.

Un primer recorrido: una cadena, letra a letra

Ya conocemos las cadenas de texto. Una cadena es una secuencia de caracteres, así que podemos recorrerla con for:

texto = "Hola Mundo"

for caracter in texto:
    print("Carácter:", caracter)

El resultado será:

Carácter: H
Carácter: o
Carácter: l
Carácter: a
Carácter:
Carácter: M
Carácter: u
Carácter: n
Carácter: d
Carácter: o

Diez caracteres, diez vueltas. El espacio entre las dos palabras también es un carácter, y también recibe su vuelta.

Fíjate en lo que no hemos tenido que escribir: ni un contador, ni una condición, ni una actualización. El propio for sabe dónde empieza, qué elemento sigue y cuándo termina.

Qué ocurre en cada vuelta

Igual que con while, cada repetición del bloque se llama iteración. Podemos seguir el recorrido de una palabra corta:

for letra in "Sol":
    print(letra)

La variable la gobierna el for

En cada vuelta, el for asigna a la variable el elemento siguiente. Eso tiene una consecuencia curiosa: si cambiamos la variable dentro del bloque, no alteramos el recorrido.

for letra in "Sol":
    print(letra)
    letra = "X"

Se imprimen S, o y l. El letra = "X" dura solo hasta la vuelta siguiente, cuando el for vuelve a asignar a letra el carácter que le corresponde.

Después del bucle, la variable sigue existiendo

Al terminar, la variable conserva el último valor que tuvo:

for letra in "Sol":
    pass

print(letra)    # l

La instrucción pass no hace nada: solo ocupa el lugar del bloque cuando Python exige que haya una instrucción.

Un for puede no ejecutarse ninguna vez

Si no hay nada que recorrer, el bloque de un for no se ejecuta ninguna vez. En ese caso la variable ni siquiera llega a recibir un valor: si no existía antes, intentar usarla después provoca un NameError.

for letra in "":
    print("Esto no se imprime")

Si no hay nada que recorrer, el bloque de un for no se ejecuta ninguna vez.

range(): cuando lo que recorremos son números

Muchas veces no queremos recorrer un texto, sino una serie de números: del 1 al 10, de 5 en 5, hacia atrás… Para eso existe range().

for i in range(5):
    print("Repetición número", i)

Repetición número 0
Repetición número 1
Repetición número 2
Repetición número 3
Repetición número 4

Cinco vueltas, con los valores de 0 a 4. Parece extraño que no llegue a 5, pero es la regla más importante de range(): el valor final nunca se incluye. range(5) genera exactamente cinco números, empezando en cero.

Inicio, fin y paso

range() admite hasta tres valores:

range(inicio, fin, paso)

• inicio: primer valor de la serie, incluido. Si no se indica, vale 0.
• fin: valor en el que la serie se detiene, sin incluirlo.
• paso: cuánto aumenta (o disminuye) cada número respecto al anterior. Si no se indica, vale 1.

for i in range(2, 10, 2):    # empieza en 2, se detiene antes de 10, de 2 en 2
    print(i)

Se imprimen 2, 4, 6 y 8. El último valor no es 9: el siguiente número de la serie sería 10, y ese ya queda fuera.

Contar hacia atrás

El paso puede ser negativo. Para que genere números, el inicio tiene que ser mayor que el fin:

for i in range(10, 0, -1):
    print(i)

Se imprimen los números del 10 al 1. El 0 es el fin y, como siempre, no se incluye. Para llegar hasta cero habría que escribir range(10, -1, -1).

Cuando el intervalo está vacío

Si el inicio y el fin no son compatibles con el sentido del paso, range() no genera ningún número y el bucle da cero vueltas:

for i in range(5, 2):
    print(i)    # no se ejecuta

De 5 no se puede llegar a 2 sumando 1. Y un paso 0 no tiene sentido —nunca se avanzaría—, así que Python lo rechaza con un ValueError.

range() no guarda todos los números

Si imprimimos un range, el resultado sorprende:

print(range(10))    # range(0, 10)

Python no ha escrito los diez números. Un range no guarda todos los valores: los va entregando a medida que el for se los pide. Así ahorra espacio, porque no necesita tenerlos todos a la vez.

Funciones como sum(), que suma todos los valores que recibe, también saben recorrerlo:

print(sum(range(4)))    # 0 + 1 + 2 + 3 = 6

Compruébalo tú mismo: ¿qué números genera?

Antes de mover los controles, intenta predecir el resultado de range(1, 10, 3), range(10, 1, -3) y range(3, 3). Después comprueba si el último número es el que esperabas.

Contadores y acumuladores con for

En la lección de while vimos dos ideas que siguen siendo útiles: el contador, que registra cuántas veces ocurre algo, y el acumulador, que conserva un total que se construye vuelta a vuelta.

Con for, la variable del bucle ya hace parte del trabajo. Por ejemplo, sumar los números del 1 al 100:

total = 0

for numero in range(1, 101):
    total += numero

print("Suma:", total)    # Suma: 5050

Dos detalles: range(1, 101) llega hasta 100 porque el 101 no se incluye; y total empieza en 0, el valor neutro de la suma.

Esta suma aparece en un relato muy conocido: un maestro manda a sus alumnos sumar los números del 1 al 100 para tenerlos ocupados y el pequeño Carl Friedrich Gauss da la respuesta en segundos. Conviene contarlo con prudencia. El divulgador científico Brian Hayes rastreó la historia en 2006: la fuente más antigua, de 1856, no menciona los números del 1 al 100; esa versión aparece por primera vez en 1938, sin documento que la respalde. Es, sobre todo, una leyenda.

Nuestro programa no necesita ningún truco: hace las cien sumas, una por vuelta.

También podemos contar solo los elementos que cumplan una condición. Por ejemplo, cuántas vocales tiene una frase:

frase = "el bucle for recorre"
vocales = 0

for letra in frase:
    if letra in "aeiou":
        vocales += 1

print("Vocales:", vocales)    # Vocales: 7

Aquí in cumple otra función: dentro del if comprueba si letra aparece en la cadena "aeiou". Es la misma palabra, pero en el for significa «recorre» y en la condición significa «está contenido en». Este ejemplo solo reconoce vocales minúsculas y sin tilde: "á" o "E" no se contarían.

¿Sabías que…? print() sin salto de línea

Por defecto, cada print() termina con un salto de línea: el texto siguiente aparece en la línea de abajo. Ese final está controlado por el parámetro end, que vale "\n" si no lo cambiamos.

Podemos sustituirlo por otra cosa:

print("Hola", end="")
print("Mundo")    # HolaMundo

Dentro de un bucle es muy útil para escribir todos los valores en una sola línea:

for i in range(5):
    print(i, end=" - ")

0 - 1 - 2 - 3 - 4 -

Observa que el separador también aparece después del último número. Evitarlo es un buen ejercicio de lógica.

Un adelanto: recorrer listas y diccionarios

Este apartado es un adelanto. Las listas y los diccionarios tendrán su propia lección más adelante en el curso, donde los veremos en detalle. Aquí solo mostramos lo imprescindible para recorrerlos con for. Si prefieres, puedes saltarlo: el resto del artículo no depende de él.

Una lista: varios valores en orden

Una lista guarda varios valores, en un orden, entre corchetes y separados por comas:

frutas = ["manzana", "pera", "naranja"]

for fruta in frutas:
    print("Me gusta la", fruta)

Me gusta la manzana
Me gusta la pera
Me gusta la naranja

La lógica es idéntica a la de una cadena: una vuelta por elemento, en el orden en que aparecen.

Un diccionario: parejas de clave y valor

Un diccionario asocia claves con valores, entre llaves:

edades = {"Ana": 18, "Luis": 20, "Marta": 22}

for nombre, edad in edades.items():
    print(nombre, "tiene", edad, "años")

Ana tiene 18 años
Luis tiene 20 años
Marta tiene 22 años

edades.items() entrega cada pareja clave–valor, y el for reparte cada pareja en dos variables: nombre y edad. Si recorremos el diccionario directamente —for nombre in edades:— solo obtenemos las claves.

Un diccionario no es, en sentido estricto, una secuencia como una cadena o una lista, pero for también sabe recorrerlo. Desde Python 3.7 está garantizado que lo recorre en el orden en que se insertaron las claves.

Más adelante, en la lección dedicada a listas y diccionarios, veremos cómo crearlos y modificarlos, y qué precauciones hay que tomar al cambiar una colección mientras se recorre.

¿for o while?

Muchos problemas pueden resolverse con los dos. En la lección anterior contábamos cinco intentos con while:

intento = 1

while intento <= 5:
    print("Intento", intento)
    intento += 1

Con for, el mismo programa queda así:

for intento in range(1, 6):
    print("Intento", intento)

Desaparecen la inicialización y la actualización. Y con ellas desaparece también un riesgo: olvidar intento += 1 y quedar atrapados en un bucle infinito.

Una regla práctica:

• usa for cuando sepas qué vas a recorrer: los caracteres de un texto, una serie de números, los elementos de una colección;
• usa while cuando la repetición dependa de una situación que no sabes cuándo cambiará: hasta que el usuario escriba FIN, mientras el dato no sea válido.

usa for cuando sepas qué vas a recorrer

Bucles dentro de bucles

El bloque de un for puede contener cualquier instrucción, incluido otro for. Es lo que llamamos bucles anidados.

for fila in range(1, 4):
    for columna in range(1, 4):
        print(fila * columna, end="\t")
    print()

1   2   3
2   4   6
3   6   9

"\t" es un tabulador: sirve para alinear las columnas.

El bucle exterior da tres vueltas. En cada una de ellas, el bucle interior completa sus tres vueltas. En total, el bloque interior se ejecuta 3 × 3 = 9 veces. El print() vacío, que pertenece solo al bucle exterior, cierra cada fila con un salto de línea.

Una idea de 1843

Esta forma de pensar es más antigua que los ordenadores. En 1843, Ada Lovelace publicó una traducción comentada de un artículo sobre la máquina analítica diseñada por Charles Babbage. En sus notas describe ciclos de operaciones que se repiten, e incluso ciclos «contenidos unos dentro de otros». También explica cómo uno de los datos recibe periódicamente un incremento de una unidad: lo que hoy llamaríamos un contador.

Su ejemplo más famoso, la Nota G, describe paso a paso cómo calcular uno de los llamados números de Bernoulli agrupando operaciones que se repiten. No había Python, ni pantalla, ni siquiera una máquina terminada. Pero la idea de repetir un grupo de operaciones dentro de otro ya estaba ahí.

Controlar el bucle desde dentro

Como en while, podemos intervenir desde el propio bloque: salir antes de tiempo, saltar una vuelta o distinguir si el bucle terminó sin interrupción.

break: salir antes de tiempo

Volvamos al vigilante. Si la tercera llave abre la puerta, no tiene sentido seguir probando las otras cuatro:

correcta = 3

for llave in range(1, 8):
    print("Pruebo la llave", llave)
    if llave == correcta:
        print("¡Abierta!")
        break

print("Fin de la búsqueda")

Pruebo la llave 1
Pruebo la llave 2
Pruebo la llave 3
¡Abierta!
Fin de la búsqueda

break abandona el bucle inmediatamente, aunque queden elementos por recorrer. Si hay bucles anidados, break sale solo del bucle más interno que lo contiene.

continue: saltar lo que queda de una vuelta

continue no termina el bucle: abandona la vuelta actual y pasa al elemento siguiente.

for i in range(1, 7):
    if i % 3 == 0:
        continue
    print("Lectura válida:", i)

Se imprimen 1, 2, 4 y 5: las vueltas de 3 y 6 se saltan.

En el while vimos que un continue mal colocado podía saltarse la actualización y dejar el bucle atrapado. Con for ese riesgo no existe: el avance lo hace el propio for, no una instrucción del bloque.

for … else: terminar sin break

Un for puede llevar un else. Igual que en while, el else de un for se ejecuta si el bucle termina sin break: después de la última vuelta, o directamente si no había nada que recorrer.

Si ninguna llave abre la puerta, el vigilante debería saberlo:

correcta = 9

for llave in range(1, 8):
    if llave == correcta:
        print("Abierta con la llave", llave)
        break
else:
    print("Ninguna llave abre esta puerta")

Como la llave 9 no está en el llavero, el bucle recorre las siete sin encontrar un break y se ejecuta el else.

Un caso clásico es comprobar si un número es primo: se prueban sus posibles divisores y, si ninguno divide al número, el else lo declara primo.

n = 13    # el método vale para números mayores que 1

for divisor in range(2, n):
    if n % divisor == 0:
        print(n, "no es primo:", divisor, "lo divide")
        break
else:
    print(n, "es primo")

Fíjate en la sangría: el else está alineado con el for, no con el if. Pertenece al bucle.

el else de un for se ejecuta si el bucle termina sin break

Compruébalo tú mismo: predice la salida

Este programa combina las tres herramientas. Antes de ejecutarlo, intenta escribir en un papel qué mostrará:

for i in range(10):
    if i == 5:
        break
    if i % 2 == 0:
        continue
    print(i)
else:
    print("Bucle terminado")

La salida es 1 y 3. Los pares se saltan con continue; al llegar a 5, break corta el bucle. Y como ha habido un break, «Bucle terminado» no aparece nunca: el else solo se ejecutaría si el bucle llegase al final por sí mismo.

Errores habituales

Esperar que range() incluya el final

range(1, 10) llega hasta 9. Si necesitas el 10, el fin debe ser 11. Cuando un resultado se queda corto en uno, revisa primero el range.

Creer que el «fin» siempre es el último valor menos uno

Con paso 1 siempre es así; con otros pasos, depende. range(2, 10, 2) termina en 8, y range(10, 0, -1) termina en 1. La regla general es otra: el fin marca dónde se detiene la serie y nunca se incluye.

Intentar controlar el recorrido cambiando la variable

Escribir i = 5 dentro de for i in range(10): no hace saltar el bucle hasta el 5. En la vuelta siguiente, el for asigna a i el valor que le toca. Si necesitas saltar valores, ajusta el range o usa continue.

Usar un paso 0

range(1, 5, 0) no da cero vueltas ni vueltas infinitas: provoca un ValueError, porque un paso nulo no avanzaría nunca.

Colocar mal el else

Si el else queda alineado con el if, pertenece al if y se ejecutará en cada vuelta en que la condición sea falsa. Para que pertenezca al bucle, debe estar a la altura del for.

Olvidar los dos puntos o romper la sangría

Como en if y while, la cabecera termina en : y las instrucciones del bloque llevan sangría. Lo que queda sin sangría ya no pertenece al bucle.

Ideas esenciales

El recorrido

• for repite un bloque una vez por cada elemento de lo que recorre, en orden.
• No necesita contador ni condición: el propio for avanza y sabe cuándo termina.
• La secuencia se evalúa una sola vez, al empezar.
• Si no hay nada que recorrer, el bloque se ejecuta cero veces.
• Cambiar la variable dentro del bloque no altera el recorrido; al terminar, la variable conserva el último valor.

range()

• range(inicio, fin, paso): inicio incluido (0 por defecto), fin nunca incluido, paso 1 por defecto.
• El paso puede ser negativo para contar hacia atrás; un paso 0 provoca un error.
• Un range no guarda todos los números: los entrega a medida que se le piden.

Controlar el bucle

• break sale del bucle más interno.
• continue salta al elemento siguiente; en for no puede dejar el bucle atrapado.
• El else de un for se ejecuta si el bucle termina sin break.

Elegir

• for cuando sabes qué vas a recorrer; while cuando la repetición depende de una situación.

Una última idea

Cuando escribas un for, empieza con dos preguntas:

¿Qué estoy recorriendo? · ¿Qué valor tendrá la variable en cada vuelta?

Si sabes responderlas, el resto del bucle suele escribirse solo. Del llavero del vigilante a los ciclos de Ada Lovelace, la idea es la misma: no decidir cuántas veces repetir, sino dejar que lo que recorremos marque el ritmo.