Bucle while en Python: guía completa con ejemplos reales

El for itera sobre una secuencia conocida. El while repite mientras se cumpla una condición — sin saber cuántas veces. Es la herramienta para cuando el número de iteraciones depende de algo que solo sabrás en tiempo de ejecución: la entrada del usuario, el resultado de un cálculo, el estado de una conexión. Más flexible que el for, pero también más peligroso si olvidas actualizar la condición.

🔄 for vs while: cuándo usar cada uno

La diferencia fundamental es si conoces de antemano el conjunto de elementos a iterar:

# Usa for cuando sabes lo que vas a iterar:
for fruta in ["manzana", "pera", "naranja"]:   # lista conocida
    print(fruta)

for i in range(10):                             # rango conocido
    procesar(i)

for clave, valor in diccionario.items():        # colección conocida
    print(clave, valor)

# Usa while cuando no sabes cuántas iteraciones necesitarás:
while not conexion.establecida():               # condición dinámica
    intentar_conectar()

while saldo > 0:                                # depende del estado
    saldo -= cobrar_cuota()

while True:                                     # hasta que algo externo lo detenga
    respuesta = esperar_peticion()
    procesar(respuesta)

🦴 Anatomía del bucle while

El while tiene tres partes obligatorias y una opcional: la condición, el bloque de código, la actualización de la variable de control, y el else.

# Anatomía completa:
#
#   while :       ← se evalúa ANTES de cada iteración
#                    ← se ejecuta si la condición es True
#                ← CRUCIAL: modifica lo que afecta a la condición
#   else:                    ← opcional; corre si termina sin break
#       

contador = 0                  # 1. inicializar ANTES del while
while contador < 5:           # 2. condición
    print(f"Iteración {contador}")   # 3. bloque
    contador += 1             # 4. actualizar (¡no olvidar!)
# 5. aquí continúa el programa cuando contador >= 5

# Cualquier expresión que dé True/False es válida como condición:
lista = [3, 1, 4, 1, 5, 9, 2]
while lista:                  # lista vacía es falsy → para al vaciarse
    elem = lista.pop()
    print(elem)               # 2 9 5 1 4 1 3 (orden LIFO)

# Condición compuesta:
x, intentos = 100, 0
while x > 1 and intentos < 50:
    x = x ** 0.9
    intentos += 1
print(f"Resultado: {x:.4f} tras {intentos} iteraciones")

🔁 while True con break: el patrón más frecuente

while True crea un bucle que solo termina con un break explícito. Es el patrón más utilizado para menús interactivos, servidores que escuchan conexiones, y cualquier situación donde la condición de salida se determina dentro del propio bloque.

# Menú interactivo básico:
def mostrar_menu():
    print("\n=== MENÚ ===")
    print("1. Ver informe")
    print("2. Exportar datos")
    print("3. Salir")

while True:
    mostrar_menu()
    opcion = input("Elige una opción: ").strip()

    if opcion == "1":
        generar_informe()
    elif opcion == "2":
        exportar_datos()
    elif opcion == "3":
        print("Hasta luego.")
        break                    # única salida del bucle
    else:
        print("Opción no válida. Intenta de nuevo.")

# Juego: adivinar número
import random
secreto = random.randint(1, 100)
intentos = 0

while True:
    try:
        intento = int(input("Adivina el número (1-100): "))
    except ValueError:
        print("Introduce un número entero.")
        continue                 # vuelve al inicio sin incrementar intentos

    intentos += 1

    if intento < secreto:
        print("Demasiado bajo.")
    elif intento > secreto:
        print("Demasiado alto.")
    else:
        print(f"¡Correcto! Lo adivinaste en {intentos} intentos.")
        break

# Reconexión automática con backoff:
import time

max_reintentos = 5
reintento = 0

while True:
    try:
        conectar_al_servidor()
        print("Conectado.")
        break
    except ConnectionError:
        reintento += 1
        if reintento >= max_reintentos:
            print("No se pudo conectar tras varios intentos.")
            break
        espera = 2 ** reintento       # 2, 4, 8, 16 segundos
        print(f"Reintentando en {espera}s... (intento {reintento}/{max_reintentos})")
        time.sleep(espera)

✅ Validar entrada del usuario

Uno de los usos más frecuentes del while en aplicaciones de línea de comandos es pedir un dato hasta que sea válido. El bucle repite hasta que el usuario introduce algo correcto.

# Validar un entero dentro de rango:
def pedir_entero(mensaje, minimo, maximo):
    while True:
        try:
            valor = int(input(mensaje))
            if minimo <= valor <= maximo:
                return valor
            print(f"Por favor introduce un número entre {minimo} y {maximo}.")
        except ValueError:
            print("Eso no es un número entero. Inténtalo de nuevo.")

edad = pedir_entero("¿Cuál es tu edad? ", 0, 120)
nota = pedir_entero("Introduce tu nota (0-10): ", 0, 10)

# Validar una opción de una lista de valores permitidos:
def pedir_opcion(mensaje, opciones_validas):
    while True:
        respuesta = input(mensaje).strip().lower()
        if respuesta in opciones_validas:
            return respuesta
        print(f"Opción no válida. Elige entre: {', '.join(opciones_validas)}")

formato = pedir_opcion("Formato de exportación (csv/json/xml): ", {"csv", "json", "xml"})

# Validar un email con expresión regular:
import re

PATRON_EMAIL = re.compile(r'^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$')

while True:
    email = input("Introduce tu email: ").strip()
    if PATRON_EMAIL.match(email):
        print(f"Email válido: {email}")
        break
    print("Formato de email no válido. Ejemplo: usuario@dominio.com")

# Con límite de intentos (seguridad):
MAX_INTENTOS = 3

for intento in range(1, MAX_INTENTOS + 1):
    password = input(f"Contraseña (intento {intento}/{MAX_INTENTOS}): ")
    if verificar_password(password):
        print("Acceso concedido.")
        break
else:
    bloquear_cuenta()
    print("Demasiados intentos fallidos. Cuenta bloqueada.")

⏭️ continue en el while

continue interrumpe la iteración actual y vuelve al inicio del while, donde se reevalúa la condición. Atención: si la variable de control se actualiza al final del bloque y usas continue antes de ese punto, puedes crear un bucle infinito.

# Procesar solo números positivos de una entrada:
numeros_procesados = []
total = 5

while len(numeros_procesados) < total:
    try:
        n = float(input(f"Introduce un número positivo ({len(numeros_procesados)+1}/{total}): "))
    except ValueError:
        print("Eso no es un número. Inténtalo de nuevo.")
        continue                  # vuelve al inicio sin añadir nada

    if n <= 0:
        print("Debe ser positivo. Descartado.")
        continue                  # igual: vuelve al inicio

    numeros_procesados.append(n)  # solo llega aquí si es válido y positivo

print(f"Media: {sum(numeros_procesados)/len(numeros_procesados):.2f}")

# ❌ Trampa clásica con continue: bucle infinito
i = 0
while i < 5:
    if i == 3:
        continue          # ← i nunca llega a i += 1 → bucle infinito en i=3
    print(i)
    i += 1

# ✅ Solución: actualizar ANTES del continue
i = 0
while i < 5:
    i += 1                # se actualiza SIEMPRE, antes del continue
    if i == 3:
        continue          # salta el print pero i ya se incrementó
    print(i)              # 1 2 4 5

💎 El else del while

Como en el for, el while tiene un bloque else que se ejecuta cuando la condición del bucle se hace False de forma natural — es decir, sin un break. Es especialmente útil con intentos limitados.

# Sistema de intentos con while/else:
PASSWORD_CORRECTA = "python2026"
MAX_INTENTOS = 3
intentos = 0

while intentos < MAX_INTENTOS:
    pwd = input("Introduce la contraseña: ")
    if pwd == PASSWORD_CORRECTA:
        print("✅ Acceso concedido.")
        break
    intentos += 1
    restantes = MAX_INTENTOS - intentos
    if restantes > 0:
        print(f"❌ Contraseña incorrecta. Te quedan {restantes} intento(s).")
else:
    # Solo llega aquí si se agotaron los intentos sin break
    print("🔒 Demasiados intentos fallidos. Cuenta bloqueada.")
    registrar_intento_bloqueo()

# Comparación sin else (más verboso):
acceso_concedido = False
intentos = 0
while intentos < MAX_INTENTOS:
    pwd = input("Contraseña: ")
    if pwd == PASSWORD_CORRECTA:
        acceso_concedido = True
        break
    intentos += 1
if not acceso_concedido:
    print("Cuenta bloqueada.")    # necesitas la variable bandera

# while/else en búsqueda:
cola = [("Ana", "pendiente"), ("Luis", "completado"), ("Marta", "pendiente")]
buscado = "Luis"
i = 0

while i < len(cola):
    nombre, estado = cola[i]
    if nombre == buscado:
        print(f"Encontrado: {nombre} — {estado}")
        break
    i += 1
else:
    print(f"'{buscado}' no está en la cola.")

📐 Algoritmos de convergencia

Los algoritmos numéricos iterativos son el caso paradigmático donde while es la única elección razonable: no sabes cuántas iteraciones necesitarás hasta alcanzar la precisión deseada.

import math

# Raíz cuadrada por el método de Newton-Raphson:
def sqrt_newton(n, tolerancia=1e-10):
    """Calcula √n iterando hasta que la mejora es menor que la tolerancia."""
    if n < 0:
        raise ValueError("No existe raíz cuadrada real de un número negativo.")
    x = n / 2.0          # estimación inicial
    iteraciones = 0

    while abs(x * x - n) > tolerancia:
        x = (x + n / x) / 2.0
        iteraciones += 1

    return x, iteraciones

resultado, iters = sqrt_newton(2)
print(f"√2 ≈ {resultado:.15f}")           # 1.414213562373095
print(f"math.sqrt(2) = {math.sqrt(2):.15f}")  # idéntico
print(f"Iteraciones: {iters}")            # ~30 iteraciones

# Suma de una serie (π/4 = 1 - 1/3 + 1/5 - 1/7 + ...):
def pi_leibniz(tolerancia=1e-6):
    total = 0.0
    termino = 1.0
    n = 0
    while abs(termino) > tolerancia:
        termino = ((-1) ** n) / (2 * n + 1)
        total += termino
        n += 1
    return total * 4, n

pi_aprox, iters = pi_leibniz()
print(f"π ≈ {pi_aprox:.6f} ({iters} términos)")    # 3.141593

# Búsqueda binaria iterativa (no sabes cuántos pasos tomará):
def busqueda_binaria(lista_ordenada, objetivo):
    izq, der = 0, len(lista_ordenada) - 1
    pasos = 0

    while izq <= der:
        mid = (izq + der) // 2
        pasos += 1
        if lista_ordenada[mid] == objetivo:
            return mid, pasos
        elif lista_ordenada[mid] < objetivo:
            izq = mid + 1
        else:
            der = mid - 1

    return -1, pasos     # no encontrado

datos = list(range(0, 1000, 2))      # [0, 2, 4, ..., 998]
pos, pasos = busqueda_binaria(datos, 742)
print(f"742 en posición {pos} — {pasos} comparaciones (de {len(datos)} elementos)")

🐛 Errores clásicos: el bucle infinito accidental

1. Olvidar actualizar la variable de control

# ❌ Bucle infinito: i nunca cambia
i = 0
while i < 5:
    print(i)
    # falta: i += 1

# ✅ Correcto:
i = 0
while i < 5:
    print(i)
    i += 1

2. Actualizar en la dirección equivocada

# ❌ Bucle infinito: i se aleja de 5 en lugar de acercarse
i = 0
while i < 5:
    print(i)
    i -= 1    # i va 0, -1, -2, -3 ... nunca llega a 5

# ✅ Actualizar en la dirección correcta:
i = 0
while i < 5:
    print(i)
    i += 1    # 0, 1, 2, 3, 4 → para cuando i=5

3. continue antes de la actualización

# ❌ Bucle infinito cuando i==2: continue salta el i+=1
i = 0
while i < 5:
    if i == 2:
        continue          # i se queda en 2 para siempre
    print(i)
    i += 1

# ✅ Actualizar ANTES del continue:
i = 0
while i < 5:
    i += 1                # siempre se ejecuta
    if i == 3:
        continue
    print(i)              # 1 2 4 5

4. Añadir un límite de seguridad

# Patrón defensivo: siempre termina, aunque falle la lógica
MAX_ITER = 10_000
n_iter   = 0

while condicion_principal() and n_iter < MAX_ITER:
    procesar()
    n_iter += 1

if n_iter >= MAX_ITER:
    import warnings
    warnings.warn(f"while terminado por límite de seguridad ({MAX_ITER} iteraciones)")

✅ Resumen y próximos pasos

El while repite mientras la condición sea True, sin necesitar conocer de antemano cuántas iteraciones habrá. El patrón while True con break es el más frecuente en código real — menús, validación de entrada, reconexiones. El else del while corre solo si no hubo break. Y el error más común es olvidar actualizar la variable de control, creando un bucle infinito.

La siguiente lección: break, continue y pass — tres sentencias de control que modifican el flujo de cualquier bucle, incluyendo cómo usar pass como marcador de posición y los patrones avanzados de salida múltiple en bucles anidados.

❓ Preguntas frecuentes