Python · Lección 16 de 27

While (bucle condicional)

El bucle while repite un bloque de código mientras una condición sea verdadera. Es la herramienta ideal cuando no sabés de antemano cuántas veces necesitás repetir algo: simulaciones mes a mes, validación de datos, reintentos hasta éxito.

80–100 min Prerrequisitos: 06 Condicionales, 08 Listas

Concepto teórico

¿Qué es un bucle while?

Un bucle while ejecuta un bloque de código repetidamente mientras una condición sea True. Cuando la condición se vuelve False, el bucle se detiene y la ejecución continúa con la siguiente línea después del while.

while condición:
    # este bloque se repite mientras condición sea True
    hacer_algo()
    # IMPORTANTE: algo dentro del bloque debe eventualmente
    # hacer que la condición sea False, o el loop es infinito

El flujo es: (1) evaluar condición → (2) si es True, ejecutar el bloque → (3) volver a (1) → (4) si es False, salir del while.

Diferencia con if: un if evalúa la condición UNA vez. Un while la evalúa MUCHAS veces, ejecutando el bloque en cada iteración. El while es como un if que se repite automáticamente hasta que la condición cambie.

El peligro del loop infinito

Si nada dentro del bloque modifica la condición para que eventualmente sea False, el bucle corre para siempre. Esto se llama loop infinito y es el error más grave que podés cometer con while:

# ❌ LOOP INFINITO — la condición nunca cambia
x = 10
while x > 0:
    print(x)    # imprime 10 para siempre
    # falta: x -= 1

# ✅ CORRECTO — la variable se modifica en cada iteración
x = 10
while x > 0:
    print(x)
    x -= 1      # eventualmente x llega a 0 → condición False

Regla de supervivencia: antes de escribir un while, preguntate: "¿qué línea dentro del bloque va a hacer que la condición cambie?". Si no tenés respuesta clara, vas a crear un loop infinito. Si te pasa en Pyodide (este editor), recargá la página.

break y continue

break — sale del bucle inmediatamente, sin importar si la condición sigue siendo True. Es como un "basta, salgo ya".

continue — salta el resto de la iteración actual y vuelve al inicio del while para evaluar la condición de nuevo. Es como un "salteo esta vuelta".

El patrón while True: ... break es muy común cuando la condición de salida está en el medio del bloque (no al inicio):

while True:
    dato = obtener_dato()
    if dato == "salir":
        break           # sale del while
    if dato == "":
        continue        # vuelve a pedir dato
    procesar(dato)

Contadores y acumuladores

Dos patrones fundamentales que usás constantemente con while (y también con for):

Contador: una variable que cuenta cuántas veces pasó algo. Empieza en 0 y se incrementa con += 1.
Acumulador: una variable que acumula un total. Empieza en 0 y se incrementa con el valor de cada iteración (+= monto).

Analogía bancaria: un cajero automático usa while internamente: while intentos < 3 and not pin_correcto: → le pide el PIN al usuario, cuenta los intentos, y si falla 3 veces o acertó, sale del loop. El contador (intentos) controla el límite y la condición booleana (pin_correcto) controla el éxito.

¿Cuándo while vs for?

Usá while cuando…	Usá for cuando…
No sabés cuántas repeticiones necesitás	Sabés exactamente cuántas (o recorrés una colección)
La condición de salida es compleja	Iterás sobre una lista, rango, diccionario
Simulaciones hasta que se cumpla una meta	Procesás cada elemento de un dataset
Reintentos con límite	Conteos y acumulaciones sobre datos conocidos
Input validation loops	Recorridos de principio a fin

En análisis de datos: while es ideal para simulaciones: "¿cuántos meses necesito para duplicar mi inversión al 5% mensual?" No sabés la respuesta antes de ejecutar — el while va calculando mes a mes hasta que la condición se cumpla.

Tip profesional: en Python, el 80% de las iteraciones se hacen con for (recorrer datos). El while se reserva para los casos donde la cantidad de repeticiones depende de una condición dinámica. Si te encontrás usando while para recorrer una lista con un índice manual, probablemente deberías usar for.

Ejemplos explicados paso a paso

Ejemplo 1: Cuenta regresiva y while básico

ejemplo_01_basico.pyPython

# Cuenta regresiva
n = 5
print("Cuenta regresiva:")
while n > 0:
    print(f"  {n}...")
    n -= 1    # CRUCIAL: sin esto, loop infinito
print("¡Despegue! 🚀")

# Acumulador: sumar hasta superar un objetivo
print("\n=== Acumulando hasta $100,000 ===")
total = 0
deposito = 15000
mes = 0
while total < 100000:
    mes += 1
    total += deposito
    print(f"  Mes {mes}: depósito ${deposito:,} → total ${total:,}")
print(f"Llegaste a ${total:,} en {mes} meses")

Hacé clic en ▶ Ejecutar

Ejemplo 2: Simulación de interés compuesto — ¿cuándo duplico mi plata?

ejemplo_02_simulacion.pyPython

# ¿Cuántos meses para duplicar una inversión al 5% mensual?
capital_inicial = 100000
tasa_mensual = 0.05
objetivo = capital_inicial * 2  # duplicar

saldo = capital_inicial
mes = 0

print(f"Capital inicial: ${capital_inicial:,}")
print(f"TEM: {tasa_mensual:.0%}")
print(f"Objetivo: ${objetivo:,}")
print(f"{'─'*35}")

while saldo < objetivo:
    mes += 1
    interes = saldo * tasa_mensual
    saldo += interes
    if mes <= 5 or saldo >= objetivo:  # mostrar solo primeros 5 y último
        print(f"  Mes {mes:>2}: +${interes:>8,.0f} → ${saldo:>12,.2f}")
    elif mes == 6:
        print(f"  ...")

print(f"{'─'*35}")
print(f"Duplicaste en {mes} meses")
print(f"Saldo final: ${saldo:,.2f}")
print(f"Ganancia: ${saldo - capital_inicial:,.2f} ({(saldo/capital_inicial - 1)*100:.1f}%)")

Hacé clic en ▶ Ejecutar

Ejemplo 3: break y continue en acción

ejemplo_03_break_continue.pyPython

# break: buscar el primer cliente con score > 750
clientes = [
    {"nombre": "García", "score": 720},
    {"nombre": "López", "score": 680},
    {"nombre": "Pérez", "score": 810},   # este
    {"nombre": "Sosa", "score": 590},
]

i = 0
encontrado = None
while i < len(clientes):
    if clientes[i]["score"] > 750:
        encontrado = clientes[i]
        break    # encontré, no necesito seguir
    i += 1

if encontrado:
    print(f"Primer premium: {encontrado['nombre']} (score {encontrado['score']})")

# continue: procesar lista saltando inválidos
print("\n=== Procesando montos ===")
montos_crudos = ["$1,500", "N/A", "$3,200", "", "$-500", "$2,800"]
total = 0
errores = 0
i = 0
while i < len(montos_crudos):
    m = montos_crudos[i]
    i += 1      # incrementar ANTES del continue para no quedar en loop

    if not m or m == "N/A":
        errores += 1
        continue   # saltar al siguiente

    valor = float(m.replace("$", "").replace(",", ""))
    if valor < 0:
        errores += 1
        continue   # saltar negativos

    total += valor
    print(f"  ✅ {m} → ${valor:,.0f}")

print(f"\nTotal: ${total:,.0f}, Errores: {errores}")

# while True + break: el patrón más robusto
print("\n=== Adivinar número ===")
import random
secreto = random.randint(1, 10)
intentos = 0
while True:
    intentos += 1
    intento = random.randint(1, 10)  # simulamos input
    if intento == secreto:
        print(f"  ¡Adivinaste ({secreto}) en {intentos} intentos!")
        break
    if intentos >= 20:
        print(f"  Máximo de intentos alcanzado")
        break

Hacé clic en ▶ Ejecutar

Ejemplo 4: Amortización de préstamo (sistema francés simplificado)

ejemplo_04_amortizacion.pyPython

# Simulación de amortización: pago fijo hasta saldar deuda
capital = 500000
tasa_mensual = 0.045   # 4.5% mensual
cuota_fija = 40000

print(f"Capital: ${capital:,}")
print(f"TEM: {tasa_mensual:.1%}")
print(f"Cuota: ${cuota_fija:,}")
print(f"{'─'*50}")
print(f"{'Mes':>4} {'Interés':>10} {'Capital':>10} {'Saldo':>12}")
print(f"{'─'*50}")

saldo = capital
mes = 0
total_intereses = 0

while saldo > 0:
    mes += 1
    interes = round(saldo * tasa_mensual)
    amort_capital = cuota_fija - interes

    if amort_capital <= 0:
        print(f"\n⚠️ La cuota no cubre el interés. Deuda impagable.")
        break

    if saldo < cuota_fija:
        # Última cuota: pagar solo lo que queda
        cuota_real = saldo + interes
        amort_capital = saldo
        saldo = 0
    else:
        saldo -= amort_capital

    total_intereses += interes
    if mes <= 6 or saldo == 0:
        print(f"  {mes:>2}  ${interes:>9,}  ${amort_capital:>9,}  ${saldo:>11,}")
    elif mes == 7:
        print(f"  ...")

print(f"{'─'*50}")
print(f"Saldaste en {mes} meses")
print(f"Total intereses: ${total_intereses:,}")
print(f"Costo total: ${capital + total_intereses:,}")

Hacé clic en ▶ Ejecutar

Ejemplo 5: while vs for — cuándo usar cada uno

ejemplo_05_while_vs_for.pyPython

# CASO 1: Recorrer lista → FOR (siempre)
saldos = [150000, 320000, 45000, 890000]
print("FOR sobre lista:")
for s in saldos:
    print(f"  ${s:,}")

# ❌ NO hagas esto con while:
# i = 0
# while i < len(saldos):
#     print(saldos[i])
#     i += 1
# Es más largo, más feo y más propenso a bugs

# CASO 2: Repetir N veces → FOR con range
print("\nFOR con range:")
for i in range(5):
    print(f"  Intento {i+1}")

# CASO 3: Repetir hasta condición dinámica → WHILE
print("\nWHILE para simulación:")
saldo = 100000
mes = 0
while saldo < 150000:
    mes += 1
    saldo *= 1.03   # 3% mensual
print(f"  Llegó a ${saldo:,.0f} en {mes} meses")

# CASO 4: Procesar cola de tareas → WHILE
print("\nWHILE para cola:")
cola = ["tarea_A", "tarea_B", "tarea_C"]
while cola:
    tarea = cola.pop(0)
    print(f"  Procesando: {tarea}")
print("  Cola vacía ✅")

Hacé clic en ▶ Ejecutar

Referencia rápida

Patrón	Estructura	Uso
While básico	`while cond: bloque`	Repetir mientras se cumpla
Contador	`n=0; while cond: n+=1`	Contar iteraciones
Acumulador	`total=0; while: total+=v`	Sumar valores
while True + break	`while True: if x: break`	Condición en medio del bloque
Sentinel loop	`while dato != fin:`	Procesar hasta valor especial
Retry con límite	`while intentos < max:`	Reintentos con tope

Keyword	Qué hace	Cuándo usar
`break`	Sale del while inmediatamente	Encontraste lo que buscabas / error fatal
`continue`	Salta al inicio del while	Este dato es inválido, seguí con el próximo
`else` (en while)	Se ejecuta si NO hubo break	Verificar si el loop terminó normalmente

Ejercicios

Nivel 1 · Básico

Ejercicio 1: Cuenta regresiva desde 10

Imprimí los números del 10 al 1 con while y después ¡Despegue!. Debe incluir ¡Despegue!.

ejercicio_01.pyDebe incluir "¡Despegue!"

n = 10

# Cuenta regresiva:

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 2: Sumar hasta superar un objetivo

Empezá con total = 0. Sumá 25000 por iteración hasta superar $100,000. Imprimí cuántas iteraciones necesitaste. Debe incluir 5.

ejercicio_02.pyDebe incluir "5"

total = 0
deposito = 25000
iteraciones = 0

# Acumulá hasta > 100000:

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 3: Dividir hasta que sea menor que 1

Empezá con n = 1024. Dividilo por 2 en cada iteración hasta que sea menor que 1. Contá cuántas divisiones hiciste. Debe incluir 11.

ejercicio_03.pyDebe incluir "11"

n = 1024
divisiones = 0

# Dividí por 2 hasta < 1:

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 4: ¿Cuántos meses para duplicar inversión?

Capital $200,000 al 4% mensual compuesto. ¿Cuántos meses para duplicar? Debe incluir 18.

ejercicio_04.pyDebe incluir "18"

capital = 200000
tasa = 0.04
objetivo = capital * 2
saldo = capital
mes = 0

# Simulá hasta duplicar:

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 5: Procesar cola con while + pop

Dada tareas = ["Limpiar datos","Calcular métricas","Generar reporte","Enviar email"], procesá cada una con while tareas: y .pop(0). Debe incluir Generar reporte.

ejercicio_05.pyDebe incluir "Generar reporte"

tareas = ["Limpiar datos", "Calcular métricas", "Generar reporte", "Enviar email"]

# Procesá la cola:

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 6: break para buscar primer match

Dada una lista de scores, encontrá el primero que supere 750 usando while + break. Debe incluir 810.

ejercicio_06.pyDebe incluir "810"

scores = [650, 720, 590, 810, 680, 900]

# Encontrá el primero > 750:
i = 0

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 7: Simulación de ahorro mensual

Ahorrás $50,000/mes con rendimiento de 3% mensual sobre el acumulado. ¿Cuántos meses para llegar a $1,000,000? Imprimí cada mes. Debe incluir Objetivo alcanzado.

ejercicio_07.pyDebe incluir "Objetivo alcanzado"

ahorro_mensual = 50000
tasa = 0.03
objetivo = 1000000
saldo = 0
mes = 0

# Simulá:

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 8: Amortización de deuda

Deuda de $300,000 al 5% mensual. Pagás $25,000/mes. ¿En cuántos meses saldás? Si la cuota no cubre el interés, imprimí Deuda impagable. Debe incluir meses.

ejercicio_08.pyDebe incluir "meses"

deuda = 300000
tasa = 0.05
cuota = 25000
mes = 0

# Simulá amortización:

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 9: Fibonacci hasta superar un valor

Generá la secuencia de Fibonacci (0, 1, 1, 2, 3, 5, 8, 13...) hasta superar 1000. Imprimí la secuencia. Debe incluir 1597.

ejercicio_09.pyDebe incluir "1597"

a, b = 0, 1
secuencia = []

# Generá Fibonacci hasta > 1000:

Hacé clic en ▶ Ejecutar

Nivel 4 · Desafío

Ejercicio 10: Simulación bancaria completa

Simulá 24 meses de una cuenta: saldo inicial $500,000. Cada mes: sumá sueldo $350,000, restá gastos $280,000, aplicá rendimiento 0.2% sobre saldo positivo. Si el saldo baja de 0, imprimí alerta y break. Al final imprimí un resumen con saldo final y meses transcurridos. Debe incluir RESUMEN.

ejercicio_10_desafio.pyDebe incluir "RESUMEN"

saldo = 500000
sueldo = 350000
gastos = 280000
rendimiento = 0.002
mes = 0

# Simulá 24 meses:
while mes < 24:
    pass  # reemplazá

print(f"\n=== RESUMEN ===")

Hacé clic en ▶ Ejecutar

Resumen y conexión

while condición: repite mientras la condición sea True. Algo dentro del bloque DEBE cambiar la condición.
Si nada cambia la condición → loop infinito (el bug más grave de while).
break sale del while inmediatamente. continue salta a la siguiente iteración.
El patrón while True: ... break es ideal cuando la condición de salida está en medio del bloque.
Contadores (n += 1) y acumuladores (total += valor) son los patrones más usados.
Usá while para simulaciones y condiciones dinámicas. Usá for para recorrer datos.

En la siguiente lección (17 · For) vas a dominar el bucle más usado de Python: for con range, listas, diccionarios, enumerate, zip, break/continue, y comprensiones — la herramienta que usás el 80% del tiempo.

Recursos: Python docs — while

Hecho con ❤️ por Rodri Gonzalez