Los bucles en Python ejercicios con solución son el último paso para dominar for y while. Ya viste la teoría y practicaste con programas reales. Ahora toca resolver por tu cuenta.

En este artículo encontrarás cuatro ejercicios en tres niveles: básico, intermedio y desafío final, con especial atención al error del bucle infinito por olvidar actualizar el contador en while.

Como siempre: intenta resolverlo, usa la pista si llevas más de 10 minutos atascado, compara con la solución comentada al final y entra a pythontutor.com para ver que es lo que está ocurriendo

Cómo usar este artículo

Lee el enunciado → intenta resolverlo en VS Code → si no avanzas, lee la pista → compara tu solución. No saltes a las soluciones directamente.

---

Nivel Básico

Bucles en Python ejercicios — Ejercicio 1: FizzBuzz

FizzBuzz es el ejercicio de programación más famoso del mundo, aparece en entrevistas de trabajo reales como filtro básico. La regla es simple: escribe un programa que muestre los números del 1 al 100, pero:

• Si el número es divisible por 3, muestra Fizz
• Si es divisible por 5, muestra Buzz
• Si es divisible por 3 y por 5, muestra FizzBuzz
• Si no es divisible por ninguno, muestra el número

La salida debe ser:

1
2
Fizz
4
Buzz
Fizz
7
8
Fizz
Buzz
11
Fizz
13
14
FizzBuzz
...

💡 Pista: Usa for con range(1, 101), sabemos exactamente que son 100 números. El truco está en el orden de los if/elif, comprueba primero si es divisible por 3 Y por 5 a la vez (usando and), luego por 3 solo, luego por 5 solo. Si lo haces al revés obtendrás resultados incorrectos. Usa % para comprobar divisibilidad.

---

Bucles en Python ejercicios — Ejercicio 2: Calculadora de interés compuesto

Escribe un programa que calcule cómo crece una inversión con interés compuesto año a año. Pide el capital inicial, el tipo de interés anual (%) y el número de años. Muestra el balance al final de cada año y el total ganado.

La fórmula del interés compuesto es: capital = capital × (1 + tasa/100)

La salida debe ser:

Capital inicial (€): 1000
Interés anual (%): 5
Número de años: 5

--- Evolución de la inversión ---
Año 1:  1050.0 €  (+50.0 €)
Año 2:  1102.5 €  (+52.5 €)
Año 3:  1157.63 € (+55.13 €)
Año 4:  1215.51 € (+57.88 €)
Año 5:  1276.28 € (+60.77 €)

Capital final:   1276.28 €
Total ganado:    276.28 €
Rentabilidad:    27.63%

💡 Pista: Usa for con range(1, años + 1), sabemos cuántos años son. Guarda el capital anterior antes de actualizarlo para calcular la ganancia de ese año. El error del bucle infinito no aplica aquí porque usas for, pero recuerda que si usaras while necesitarías incrementar el contador de año en cada iteración, olvidarlo lo convierte en bucle infinito.

---

Nivel Intermedio

Bucles en Python ejercicios — Ejercicio 3: Generador de números primos

Escribe un programa que pida un número n y muestre todos los números primos desde 2 hasta n. Un número es primo si solo es divisible por 1 y por sí mismo.

La salida con n=30 debe ser:

Hasta qué número buscar primos: 30

Números primos hasta 30:
2, 3, 5, 7, 11, 13, 17, 19, 23, 29

Total de primos encontrados: 10

💡 Pistas:

• Necesitas dos bucles anidados, el exterior recorre cada número del 2 al n, el interior comprueba si ese número tiene divisores
• Para comprobar si un número es primo, divídelo entre todos los números del 2 hasta su raíz cuadrada. Si ninguno divide exactamente (% == 0), es primo
• Usa break cuando encuentres un divisor, no necesitas seguir buscando
• Usa una variable booleana es_primo = True que cambia a False si encuentras un divisor
• El error del bucle infinito aquí viene del bucle interior si usas while sin actualizar el divisor, por eso en este caso for es más seguro

---

Desafío Final

Bucles en Python ejercicios — Ejercicio 4: Simulador de ahorro mensual

Este ejercicio mezcla todo. Escribe un programa que simule cuánto tiempo necesitas para alcanzar un objetivo de ahorro. Pide el objetivo de ahorro, el ahorro mensual y el interés anual. Calcula mes a mes hasta alcanzar el objetivo.

Objetivo de ahorro (€): 10000
Ahorro mensual (€): 300
Interés anual (%): 4

--- Simulación de ahorro ---
Mes 1:   300.0 €
Mes 2:   601.0 €
Mes 3:   903.0 €
...
Mes 28:  9876.43 €
Mes 29:  10179.43 €  ← objetivo alcanzado

¡Objetivo alcanzado en 29 meses (2 años y 1 mes)!
Capital ahorrado:   10179.43 €
Total aportado:     8700.0 €
Intereses ganados:  1479.43 €

💡 Pistas:

• Usa while, no sabes cuántos meses necesitas de antemano
• En cada mes: primero añade el ahorro mensual, luego aplica el interés mensual (tasa_anual / 12 / 100)
• El error del bucle infinito más probable aquí: si el ahorro mensual es 0 o negativo el balance nunca crece y el while nunca termina. Añade una validación antes del bucle: if ahorro_mensual <= 0: print("Error") exit()
• Para convertir meses a años y meses usa // y %: años = meses // 12, meses_resto = meses % 12
• Muestra solo los últimos 5 meses si el total supera 12 — si no la salida se hace enorme

---

Soluciones Comentadas

Solución Ejercicio 1 — FizzBuzz:

# FizzBuzz
for i in range(1, 101):
    if i % 3 == 0 and i % 5 == 0:
        print("FizzBuzz")
    elif i % 3 == 0:
        print("Fizz")
    elif i % 5 == 0:
        print("Buzz")
    else:
        print(i)

La clave está en comprobar primero % 3 == 0 and % 5 == 0, si lo pones después de los elif individuales nunca llegará ahí porque el 15 ya habrá caído en el elif del 3 o del 5.

Solución Ejercicio 2 — Interés compuesto:

# Calculadora de interés compuesto
capital_inicial = float(input("Capital inicial (€): "))
interes = float(input("Interés anual (%): "))
años = int(input("Número de años: "))

capital = capital_inicial
print(f"\n--- Evolución de la inversión ---")

for año in range(1, años + 1):
    capital_anterior = capital
    capital = round(capital * (1 + interes / 100), 2)
    ganancia_año = round(capital - capital_anterior, 2)
    print(f"Año {año}:  {capital} €  (+{ganancia_año} €)")

total_ganado = round(capital - capital_inicial, 2)
rentabilidad = round((total_ganado / capital_inicial) * 100, 2)

print(f"\nCapital final:   {capital} €")
print(f"Total ganado:    {total_ganado} €")
print(f"Rentabilidad:    {rentabilidad}%")

Solución Ejercicio 3 — Números primos:

# Generador de números primos
import math

n = int(input("Hasta qué número buscar primos: "))
primos = []

for numero in range(2, n + 1):
    es_primo = True

    for divisor in range(2, int(math.sqrt(numero)) + 1):
        if numero % divisor == 0:
            es_primo = False
            break    # encontrado divisor, no hace falta seguir

    if es_primo:
        primos.append(numero)

print(f"\nNúmeros primos hasta {n}:")
print(", ".join(str(p) for p in primos))
print(f"\nTotal de primos encontrados: {len(primos)}")

El break aquí es fundamental para la eficiencia, en cuanto encontramos un divisor sabemos que no es primo y salimos del bucle interior. Sin break seguiría comprobando divisores innecesariamente.

Solución Ejercicio 4 — Simulador de ahorro:

# Simulador de ahorro mensual
objetivo = float(input("Objetivo de ahorro (€): "))
ahorro_mensual = float(input("Ahorro mensual (€): "))
interes_anual = float(input("Interés anual (%): "))

if ahorro_mensual <= 0:
    print("Error: el ahorro mensual debe ser mayor que 0")
else:
    interes_mensual = interes_anual / 12 / 100
    balance = 0
    mes = 0
    total_aportado = 0
    historial = []

    print(f"\n--- Simulación de ahorro ---")

    while balance < objetivo:
        mes += 1
        balance += ahorro_mensual
        balance = round(balance * (1 + interes_mensual), 2)
        total_aportado += ahorro_mensual
        historial.append((mes, balance))

    # Mostrar solo últimos 5 meses si hay muchos
    meses_a_mostrar = historial if len(historial) <= 12 else historial[-5:]
    if len(historial) > 12:
        print(f"... (mostrando últimos 5 meses)")

    for m, b in meses_a_mostrar:
        marca = " ← objetivo alcanzado" if m == mes else ""
        print(f"Mes {m}:  {b} €{marca}")

    años = mes // 12
    meses_resto = mes % 12
    intereses = round(balance - total_aportado, 2)

    print(f"\n¡Objetivo alcanzado en {mes} meses ", end="")
    if años > 0:
        print(f"({años} año/s y {meses_resto} mes/es)!")
    else:
        print(f"({meses_resto} mes/es)!")

    print(f"Capital ahorrado:   {balance} €")
    print(f"Total aportado:     {total_aportado} €")
    print(f"Intereses ganados:  {intereses} €")

---

Chuletario — Bucles en Python

# ============================================
# CHULETARIO — Bucles en Python
# Sergio Learns · sergiolearns.com
# ============================================

# BUCLE FOR — cuando sabes cuántas veces repetir
for elemento in secuencia:
    # bloque

for i in range(n):              # 0 a n-1
for i in range(inicio, fin):    # inicio a fin-1
for i in range(inicio, fin, paso):  # con salto
for i in range(n, 0, -1):      # cuenta atrás

# range() — el fin NUNCA se incluye
range(5)        # 0, 1, 2, 3, 4
range(1, 6)     # 1, 2, 3, 4, 5
range(0, 10, 2) # 0, 2, 4, 6, 8
range(5, 0, -1) # 5, 4, 3, 2, 1

# BUCLE WHILE — cuando no sabes cuántas veces
while condicion:
    # bloque
    # SIEMPRE actualiza la condición aquí
    # si no → bucle infinito → Ctrl+C para parar

# BREAK — sale del bucle completamente
for i in range(100):
    if condicion:
        break    # sale aunque queden iteraciones

# CONTINUE — salta esta iteración
for i in range(10):
    if condicion:
        continue    # va a la siguiente iteración
    print(i)        # esto no se ejecuta si continue

# BREAK vs CONTINUE
# break   → sale del bucle
# continue → salta al siguiente elemento

# BUCLES ANIDADOS
for i in range(filas):
    for j in range(columnas):
        print(i, j)
# el interior se ejecuta completo por cada i

# PATRÓN ACUMULADOR — el más importante
acumulador = 0       # inicializa ANTES del bucle
for elemento in ...:
    acumulador += elemento    # actualiza DENTRO
resultado = acumulador        # usa DESPUÉS

# USOS TÍPICOS
# Suma de lista
suma = 0
for n in lista:
    suma += n

# Contar elementos que cumplen condición
contador = 0
for n in lista:
    if n > 5:
        contador += 1

# Buscar el máximo
maximo = lista[0]
for n in lista:
    if n > maximo:
        maximo = n

# VALIDAR ENTRADA CON WHILE
valor = float(input("Valor (0-10): "))
while valor < 0 or valor > 10:
    print("Error: fuera de rango")
    valor = float(input("Valor válido: "))

# ERRORES TÍPICOS
# 1. while sin actualizar → bucle infinito → Ctrl+C
# 2. range(n) va de 0 a n-1, no de 1 a n
# 3. break sale del bucle, continue solo salta la iteración
# 4. Acumulador no inicializado antes del bucle → NameError
# 5. Modificar la lista que estás recorriendo → comportamiento inesperado

---

Python loops — put them to the test with these exercises

Python loops exercises with solutions are the final step to mastering for and while. You’ve seen the theory and practised with real programs. Now it’s time to solve on your own. Four exercises across three levels, with special focus on the infinite loop bug, forgetting to update the while counter.

Basic Level

Exercise 1 — FizzBuzz

The most famous programming exercise in the world, asked in real job interviews. Print numbers from 1 to 100, but: multiples of 3 print «Fizz», multiples of 5 print «Buzz», multiples of both print «FizzBuzz».

💡 Hint: Use for range(1, 101). Check % 3 == 0 and % 5 == 0 FIRST — if you check them separately first, 15 will never reach the FizzBuzz branch.

Exercise 2 — Compound interest calculator

Ask for initial capital, annual interest rate and number of years. Show the balance at the end of each year and total earned.

Formula: capital = capital × (1 + rate/100)

💡 Hint: Use for range(1, years + 1). Save the previous balance before updating to calculate that year’s gain. If you used while here, forgetting to increment the year counter = infinite loop.

Intermediate Level

Exercise 3 — Prime number generator

Ask for n and show all prime numbers from 2 to n. A prime is only divisible by 1 and itself.

💡 Hints:

• Two nested loops — outer iterates each number, inner checks divisors
• Only check divisors up to the square root of the number
• Use break when you find a divisor — no need to keep checking
• Use es_primo = True flag that flips to False when a divisor is found

Final Challenge

Exercise 4 — Monthly savings simulator

Simulate how long to reach a savings goal. Ask for the goal, monthly savings and annual interest. Calculate month by month until goal is reached.

💡 Hints:

• Use while — you don’t know how many months in advance
• Each month: add savings first, then apply monthly interest (annual_rate / 12 / 100)
• Most likely infinite loop bug: if monthly savings ≤ 0 the balance never grows. Validate before the loop
• Convert months to years with // and %

(Solutions same as Spanish version above)

Cheat sheet — Python loops

# ============================================
# CHEAT SHEET — Python Loops
# Sergio Learns · sergiolearns.com
# ============================================

# FOR — when you know how many times
for element in sequence:
    # block

for i in range(n):               # 0 to n-1
for i in range(start, end):      # start to end-1
for i in range(start, end, step):
for i in range(n, 0, -1):        # countdown

# range() — end is NEVER included
range(5)         # 0, 1, 2, 3, 4
range(1, 6)      # 1, 2, 3, 4, 5
range(5, 0, -1)  # 5, 4, 3, 2, 1

# WHILE — when you don't know how many times
while condition:
    # block
    # ALWAYS update condition here
    # if not → infinite loop → Ctrl+C to stop

# BREAK — exits loop completely
for i in range(100):
    if condition:
        break

# CONTINUE — skips this iteration
for i in range(10):
    if condition:
        continue
    print(i)    # not executed if continue

# NESTED LOOPS
for i in range(rows):
    for j in range(cols):
        print(i, j)
# inner runs completely for each i

# ACCUMULATOR PATTERN
accumulator = 0          # initialise BEFORE loop
for element in ...:
    accumulator += element    # update INSIDE
result = accumulator          # use AFTER

# COMMON ERRORS
# 1. while without update → infinite loop → Ctrl+C
# 2. range(n) goes 0 to n-1, not 1 to n
# 3. break exits loop, continue only skips iteration
# 4. Accumulator not initialised → NameError