Los bucles en Python for y while son la herramienta que le da a tu código la capacidad de repetirse. Sin bucles tendrías que escribir la misma instrucción cien veces para hacer algo cien veces. Con bucles lo haces en tres líneas. Es uno de los conceptos más importantes de FP1 y también uno de los que más confunden al principio, especialmente saber cuándo usar for y cuándo usar while, y entender break, continue y los bucles anidados.

En este artículo lo vemos todo.

Tabla de Contenidos

¿Qué es un bucle?

Un bucle es una estructura que repite un bloque de código varias veces. Igual que con los condicionales, la indentación y los dos puntos son obligatorios.

Hay dos tipos en Python: for y while. La diferencia fundamental es esta:

for — cuando sabes de antemano cuántas veces vas a repetir
while — cuando no sabes cuántas veces vas a repetir y dependes de una condición

El bucle for

El for en Python recorre una secuencia, una lista, un rango de números, un texto… y ejecuta el bloque una vez por cada elemento:

# Recorrer una lista de notas
notas = [7.5, 8.0, 6.5, 9.0, 5.5]

for nota in notas:
    print(nota)
```

Resultado:
```
7.5
8.0
6.5
9.0
5.5

La variable nota toma el valor de cada elemento de la lista en cada iteración. Puedes llamarla como quieras ( nota, n, elemento ) pero usa nombres descriptivos para que el código sea legible.

El bucle for con range()

range() genera una secuencia de números y es la forma más común de usar for cuando necesitas repetir algo un número fijo de veces:

# range(n) genera números del 0 al n-1
for i in range(5):
    print(i)
# → 0, 1, 2, 3, 4

# range(inicio, fin) genera del inicio al fin-1
for i in range(1, 6):
    print(i)
# → 1, 2, 3, 4, 5

# range(inicio, fin, paso) con saltos
for i in range(0, 11, 2):
    print(i)
# → 0, 2, 4, 6, 8, 10

El detalle que más confunde: range(5) va del 0 al 4, no al 5. El número final no se incluye. Así que si quieres del 1 al 10 usas range(1, 11).

El bucle for para generar tablas

Un uso clásico en FP1, la tabla de multiplicar:

numero = 7

print(f"Tabla del {numero}:")
for i in range(1, 11):
    resultado = numero * i
    print(f"{numero} x {i} = {resultado}")
```

Resultado:
```
Tabla del 7:
7 x 1 = 7
7 x 2 = 14
...
7 x 10 = 70

El bucle while

El while repite el bloque mientras una condición sea True. A diferencia del for, no recorre una secuencia, simplemente sigue hasta que la condición falla:

# Cuenta atrás
contador = 5

while contador > 0:
    print(contador)
    contador -= 1    # IMPORTANTE: actualizar el contador

print("¡Despegue!")
```

Resultado:
```
5
4
3
2
1
¡Despegue!

El error más peligroso con while — el bucle infinito

Si olvidas actualizar la variable de la condición dentro del while, el bucle nunca termina y el programa se cuelga:

# PELIGRO — bucle infinito
contador = 5
while contador > 0:
    print(contador)
    # Falta contador -= 1 → nunca llega a 0 → bucle infinito

Si te pasa esto en VS Code pulsa Ctrl + C en la terminal para detenerlo. La regla de oro: siempre que uses while asegúrate de que la condición eventualmente se vuelve False.

¿Cuándo usar for y cuándo usar while?

Esta es la pregunta que más confunde. La respuesta práctica:

# USA for cuando sabes cuántas veces repites
for i in range(10):          # exactamente 10 veces
    print(i)

for nota in lista_notas:     # una vez por nota
    print(nota)

# USA while cuando no sabes cuántas veces repites
intentos = 0
while not adivinado:         # hasta que adivine
    intentos += 1
    ...

while respuesta != "salir":  # hasta que el usuario decida salir
    ...

En el juego de adivinar el número que hiciste en los ejercicios de condicionales usamos while porque no sabíamos cuántos intentos necesitaría el jugador. Si hubiéramos sabido que eran exactamente 5 intentos, habríamos usado for.

break — salir del bucle antes de tiempo

break interrumpe el bucle inmediatamente y sale de él, aunque queden iteraciones por hacer:

# Buscar el primer número divisible por 7
for i in range(1, 100):
    if i % 7 == 0:
        print(f"Primer múltiplo de 7: {i}")
        break    # encontrado, salimos del bucle
```

Resultado:
```
Primer múltiplo de 7: 7

Sin el break el bucle seguiría hasta 100 mostrando todos los múltiplos de 7. Con break sale en cuanto encuentra el primero.

continue — saltar una iteración

continue no sale del bucle, salta al siguiente elemento ignorando el resto del bloque en esa iteración:

# Mostrar solo las notas aprobadas
notas = [7.5, 3.0, 8.0, 4.5, 6.5]

for nota in notas:
    if nota < 5:
        continue    # salta esta nota y va a la siguiente
    print(f"Aprobado: {nota}")
```

Resultado:
```
Aprobado: 7.5
Aprobado: 8.0
Aprobado: 6.5

Las notas 3.0 y 4.5 se saltan, continue hace que el bucle pase directamente a la siguiente iteración sin ejecutar el print.

break vs continue — la diferencia clave

# break — sale del bucle completamente
for i in range(10):
    if i == 5:
        break       # para aquí, no llega al 6, 7, 8, 9
    print(i)
# → 0, 1, 2, 3, 4

# continue — salta esa iteración pero sigue
for i in range(10):
    if i == 5:
        continue    # salta el 5 pero sigue con 6, 7, 8, 9
    print(i)
# → 0, 1, 2, 3, 4, 6, 7, 8, 9

Bucles anidados — un bucle dentro de otro

Los bucles anidados son dos bucles donde el interior se ejecuta completo por cada iteración del exterior. Son el concepto más difícil de los bucles pero muy usado en FP1 para tablas, matrices y patrones:

# Tabla de multiplicar del 1 al 3
for i in range(1, 4):           # bucle exterior: i = 1, 2, 3
    for j in range(1, 11):      # bucle interior: j = 1 al 10
        print(f"{i} x {j} = {i*j}")
    print()                     # línea en blanco entre tablas

Por cada valor de i (1, 2, 3) el bucle interior recorre todos los valores de j (1 al 10). Total de iteraciones: 3 × 10 = 30.

Patrón de estrella con bucles anidados

# Triángulo de asteriscos
filas = 5

for i in range(1, filas + 1):
    for j in range(i):
        print("*", end="")
    print()    # salto de línea al final de cada fila
```

Resultado:
```
*
**
***
****
*****

El end="" en el print() interior evita el salto de línea automático — imprime los asteriscos seguidos en la misma línea.

El acumulador — patrón esencial con bucles

El acumulador es un patrón que aparece en casi todos los ejercicios de bucles, una variable que se va actualizando en cada iteración:

# Calcular la media de una lista de notas
notas = [7.5, 8.0, 6.5, 9.0, 5.5]
suma = 0          # acumulador inicializado a 0

for nota in notas:
    suma += nota  # suma += nota equivale a suma = suma + nota

media = suma / len(notas)
print(f"Media: {media}")    # → 7.3

Regla de oro: inicializa el acumulador antes del bucle, actualízalo dentro, úsalo después.

Validar entradas con while — patrón muy útil

Uno de los usos más prácticos del while es forzar al usuario a introducir un valor válido:

# Pedir una nota válida entre 0 y 10
nota = float(input("Introduce una nota (0-10): "))

while nota < 0 or nota > 10:
    print("Error: la nota debe estar entre 0 y 10")
    nota = float(input("Introduce una nota válida: "))

print(f"Nota registrada: {nota}")

El while sigue pidiendo la nota hasta que el usuario introduce un valor dentro del rango. Esto es lo que en FP1 llaman validación de entrada y lo verás en muchos ejercicios.

Visualízalo con Python Tutor

Los bucles son el concepto donde pythontutor.com más ayuda. Copia esto y ejecútalo paso a paso:

notas = [7.5, 8.0, 6.5]
suma = 0

for nota in notas:
    suma += nota

media = suma / len(notas)
print(media)

Observa cómo nota cambia en cada iteración y cómo suma se acumula. Es la forma más visual de entender qué hace el bucle en cada paso.

Resumen rápido

for — cuando sabes cuántas veces repetir. Recorre secuencias y rangos
while — cuando no sabes cuántas veces. Depende de una condición
range(inicio, fin, paso) — el fin no se incluye nunca
break — sale del bucle completamente
continue — salta la iteración actual y va a la siguiente
Bucles anidados — el interior se ejecuta completo por cada iteración del exterior
Acumulador — inicializa antes, actualiza dentro, usa después
while sin actualizar la condición → bucle infinito → Ctrl+C para parar

En el próximo artículo practicamos los bucles en Python con programas reales en VS Code.

Loops in Python — for and while without beating around the bush

Python loops for and while give your code the ability to repeat itself. Without loops you’d write the same instruction a hundred times to do something a hundred times. With loops, three lines.

This article covers everything, including when to use for vs while, break, continue and nested loops, which were the hardest parts for me in first year.

What is a loop?

A structure that repeats a block of code multiple times. Like conditionals, indentation and colons are mandatory.

Two types: for and while. The key difference:

for — when you know in advance how many times to repeat
while — when you don’t know and depend on a condition

The for loop

grades = [7.5, 8.0, 6.5, 9.0, 5.5]

for grade in grades:
    print(grade)

for with range()

range(5)         # 0 to 4 (5 not included)
range(1, 6)      # 1 to 5
range(0, 11, 2)  # 0, 2, 4, 6, 8, 10

Key detail: the end value is never included. range(1, 11) goes from 1 to 10.

Multiplication table with for:

number = 7
for i in range(1, 11):
    print(f"{number} x {i} = {number * i}")

The while loop

counter = 5
while counter > 0:
    print(counter)
    counter -= 1    # IMPORTANT: always update the condition variable
print("Liftoff!")

The most dangerous while mistake — infinite loop

Forgetting to update the condition variable makes the loop run forever. Press Ctrl+C to stop it. Golden rule: always make sure the condition eventually becomes False.

When to use for vs while

# USE for — when you know how many times
for i in range(10):        # exactly 10 times
for grade in grade_list:   # once per grade

# USE while — when you don't know
while not guessed:         # until player guesses
while answer != "quit":    # until user decides to stop

break — exit the loop early

for i in range(1, 100):
    if i % 7 == 0:
        print(f"First multiple of 7: {i}")
        break

continue — skip one iteration

grades = [7.5, 3.0, 8.0, 4.5, 6.5]

for grade in grades:
    if grade < 5:
        continue    # skip failing grades
    print(f"Passed: {grade}")

break vs continue

# break — exits loop completely
for i in range(10):
    if i == 5:
        break
# → 0, 1, 2, 3, 4

# continue — skips that iteration, loop continues
for i in range(10):
    if i == 5:
        continue
# → 0, 1, 2, 3, 4, 6, 7, 8, 9

Nested loops

# Multiplication tables 1 to 3
for i in range(1, 4):
    for j in range(1, 11):
        print(f"{i} x {j} = {i*j}")
    print()

For each value of i, the inner loop runs completely through all values of j. Total iterations: 3 × 10 = 30.

Star pattern

rows = 5
for i in range(1, rows + 1):
    for j in range(i):
        print("*", end="")
    print()

The accumulator pattern

grades = [7.5, 8.0, 6.5, 9.0, 5.5]
total = 0

for grade in grades:
    total += grade

average = total / len(grades)
print(f"Average: {average}")

Golden rule: initialise before the loop, update inside, use after.

Input validation with while

grade = float(input("Enter a grade (0-10): "))

while grade < 0 or grade > 10:
    print("Error: grade must be between 0 and 10")
    grade = float(input("Enter a valid grade: "))

print(f"Grade recorded: {grade}")

Quick summary

for — known repetitions. Iterates over sequences and ranges
while — condition-based. Unknown repetitions
range(start, stop, step) — stop is never included
break — exits loop completely
continue — skips current iteration
Nested loops — inner runs completely for each outer iteration
Accumulator — initialise before, update inside, use after
while without updating condition → infinite loop → Ctrl+C