Python: bucle while, repetir mientras se cumpla una condición

Nivel: iniciación Pregunta que responde: ¿Cómo podemos hacer que Python repita un conjunto de instrucciones mientras siga cumpliéndose una condición? Requisitos previos: variables, operadores, input() y estructuras condicionales con if.

De decidir una vez a comprobar una y otra vez

Cada noche, Sherezade deja su historia a medias justo cuando el rey necesita saber cómo continúa. Ninguno de los dos sabe cuántas noches durará aquello. Solo existe una regla que se vuelve a comprobar al amanecer: mientras el rey quiera saber cómo sigue, habrá otra noche.

Fueron mil y una. No se decidieron todas al principio: llegaron una después de otra.

Eso, precisamente, es la idea de un bucle while.

Ya hemos utilizado if, elif y else para hacer que Python tome decisiones. Una condición como temperatura > 30 puede ser verdadera o falsa, pero if la comprueba para decidir qué hacer en ese momento. while, en cambio, vuelve a esa condición después de ejecutar el bloque y pregunta de nuevo.

while repite un bloque mientras su condición sea verdadera.

La estructura básica de while

La forma general es:

while condicion:
    instrucciones

Python sigue una secuencia muy concreta: comprueba la condición; si es True, ejecuta el bloque con sangría y vuelve a comprobarla. El ciclo continúa mientras la condición siga siendo verdadera. En cuanto pasa a False, el programa sale del bucle y continúa con la instrucción siguiente.

La sangría tiene aquí la misma importancia que en if: indica qué instrucciones pertenecen al while.

Un primer bucle: contar intentos

Imagina un programa que debe realizar cinco intentos:

intento = 1

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

print("Fin de los intentos")

Aquí aparecen tres piezas fundamentales: el valor inicial intento = 1, la condición intento <= 5 y la actualización intento += 1.

Mientras la condición sea verdadera, Python seguirá entrando en el bloque. Cada vuelta aumenta intento en una unidad. Cuando llegue a 6, intento <= 5 será False y el bucle terminará.

El resultado será:

Intento 1
Intento 2
Intento 3
Intento 4
Intento 5
Fin de los intentos

while no significa «repite cinco veces». Significa «repite mientras intento <= 5». Somos nosotros quienes hemos construido una condición que, en este caso, acaba produciendo cinco repeticiones.

Qué ocurre en cada vuelta

Cada repetición del bloque se llama iteración. En el ejemplo anterior podemos seguir la evolución de intento:

La tabla hace visible algo que el programa realiza muy deprisa: la condición se vuelve a evaluar antes de cada nueva iteración.

Si empezamos con intento = 3 y mantenemos while intento <= 5:, el bloque se ejecutará tres veces: con 3, 4 y 5.

Un while puede no ejecutarse ninguna vez

La condición se comprueba antes de entrar en el bloque. Si ya es falsa al principio, el cuerpo del while no se ejecuta.

temperatura = 25

while temperatura > 30:
    print("Temperatura demasiado alta")
    temperatura -= 1

print("Temperatura dentro del límite")

Como 25 > 30 es False, Python pasa directamente a print("Temperatura dentro del límite").

Este detalle evita una idea equivocada frecuente: un while no garantiza ni siquiera una primera vuelta. Siempre pregunta antes de entrar.

Un while puede ejecutarse cero veces: comprueba la condición antes de entrar.

La condición debe poder cambiar: el bucle infinito

En el ejemplo de los intentos, intento += 1 no es un detalle. Es lo que hace avanzar al programa hacia una situación en la que la condición dejará de cumplirse.

Si eliminamos esa línea:

intento = 1

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

intento nunca cambia, de modo que intento <= 5 seguirá siendo True una y otra vez. El programa se queda atrapado en un bucle infinito.

Cuando ocurrió de verdad: el Zune de Microsoft

El 31 de diciembre de 2008, algunos modelos del reproductor Zune de Microsoft quedaron inutilizables hasta el día siguiente. El problema estaba en el código que convertía un número de días en año y día del año. Simplificando la parte que provocaba el fallo:

dias = 366
anio = 2008

while dias > 365:
    if anio % 4 == 0:          # simplificación: año bisiesto
        if dias > 366:
            dias -= 366
            anio += 1
    else:
        dias -= 365
        anio += 1

Cuando el cálculo llegaba a dias = 366 y anio = 2008, dias > 365 era verdadero. Pero, al ser un año bisiesto, dias > 366 era falso y dentro del bucle no cambiaba nada. Al volver arriba, la condición seguía siendo verdadera. Y así una vuelta tras otra.

El fallo no estaba en while: estaba en haber creado una situación en la que el bucle podía seguir vivo sin avanzar.

En una terminal, Ctrl + C suele interrumpir la ejecución y provocar un KeyboardInterrupt. En los ejercicios ejecutados dentro del navegador, Ctrl + C no detiene por sí mismo el programa: utiliza el control de detención del entorno, si existe. Si la pestaña se queda bloqueada, puede ser necesario recargarla; se perderá el trabajo no guardado.

No todos los bucles continuos son un error. Un microcontrolador que mide sensores, envía datos y vuelve a esperar puede trabajar deliberadamente durante toda su vida dentro de un ciclo. En ese contexto, repetir no es el problema: es el trabajo.

Al escribir un while, la pregunta decisiva es: qué puede cambiar para que la condición termine siendo False.

Compruébalo tú mismo: ¿termina o no termina?

Antes de ejecutar un bucle, intenta predecir si no llegará a entrar, si terminará después de varias iteraciones o si seguirá indefinidamente. En el recurso interactivo podrás comprobar cuatro situaciones: cinco intentos, una temperatura que ya está dentro del límite, un contador que avanza en sentido equivocado y el telar de Penélope.

La cuestión no es solo cuántas vueltas da el programa, sino si cada vuelta acerca la condición a False.

Cuando no sabemos cuántas repeticiones harán falta

while resulta especialmente natural cuando no podemos saber de antemano cuántas vueltas harán falta.

Imagina un programa que recibe mensajes hasta que el usuario escribe FIN:

mensaje = input("Mensaje: ")

while mensaje != "FIN":
    print("Recibido:", mensaje)
    mensaje = input("Mensaje: ")

print("Comunicación terminada")

No sabemos si FIN llegará en el primer intento, en el tercero o después de veinte mensajes. La repetición depende de una situación, no de una cantidad prefijada.

Hay un pequeño detalle práctico: "fin" no es igual que "FIN". Python distingue mayúsculas y minúsculas, así que escribir fin mantendría vivo el bucle. Más adelante veremos distintas formas de normalizar una entrada antes de compararla.

Este patrón aparece continuamente: repetir una petición hasta recibir un dato válido, mantener un menú activo hasta elegir «salir», reintentar una operación mientras sea posible o continuar un proceso mientras una tarea siga pendiente.

Un while que nadie sabe demostrar que termine siempre

La conjetura de Collatz parte de una regla muy sencilla: si un número es par, se divide entre 2; si es impar, se multiplica por 3 y se suma 1. Después se repite el proceso mientras el número no sea 1.

n = 27
pasos = 0

while n != 1:
    if n % 2 == 0:
        n = n // 2
    else:
        n = 3 * n + 1
    pasos += 1

print("Pasos:", pasos)

Los operadores % y // ya los conocemos: % obtiene el resto y // el cociente entero.

Con 27, el bucle da 111 vueltas y la secuencia llega a subir hasta 9232 antes de alcanzar 1. El cálculo se ha verificado por ordenador para todos los valores por debajo de 2**71, pero no existe una demostración matemática de que la secuencia llegue a 1 para todo entero positivo.

Es un recordatorio extraordinario: incluso una regla que cabe en unas pocas líneas puede plantear una pregunta muy difícil sobre si una repetición termina. En computación existe además un límite todavía más profundo: no hay un procedimiento general capaz de decidir, para cualquier programa y cualquier entrada, si el programa terminará o continuará indefinidamente.

Contadores y acumuladores

Dentro de un while aparecen con frecuencia dos ideas distintas: contar y acumular. Para estos ejemplos basta con los conceptos de variables, operadores y entrada/salida que ya hemos trabajado.

Un contador indica cuántas veces ha ocurrido algo. Por ejemplo, intentos += 1. Un acumulador conserva un total que se va construyendo en cada vuelta, como total += medida.

contador = 0
total = 0

while contador < 3:
    medida = float(input("Introduce una medida: "))
    total += medida
    contador += 1

media = total / contador
print("Media:", media)

contador empieza en 0 porque todavía no hemos recibido ninguna medida. total también empieza en 0 porque es el valor neutro de una suma: antes de acumular nada, la suma vale cero. Si estuviéramos construyendo un producto, lo normal sería empezar en 1.

En cada vuelta, contador responde a cuántas medidas llevamos y total a cuánto hemos acumulado.

Cuándo elegir while

Una buena señal es que el problema pueda expresarse de manera natural con la palabra mientras:

• mientras queden intentos;
• mientras el dato no sea válido;
• mientras una opción no sea «salir»;
• mientras un valor permanezca fuera de un límite;
• mientras una tarea siga pendiente.

if y while pueden utilizar exactamente la misma condición, pero no hacen el mismo trabajo. if decide una vez; while ejecuta y regresa a la condición.

No deberíamos utilizar while por costumbre para cualquier repetición. Más adelante veremos for, que resulta especialmente cómodo cuando queremos recorrer elementos o trabajar con una sucesión de valores.

Errores habituales

Olvidar actualizar aquello de lo que depende la condición

contador = 0

while contador < 5:
    print(contador)

Si contador nunca cambia, el bucle no puede alcanzar su final.

Actualizar en la dirección equivocada: Penélope sabía hacerlo

En la Odisea, Penélope promete elegir marido cuando termine el sudario de Laertes. Teje durante el día y por la noche deshace lo tejido. Consigue mantener así la situación durante tres años.

En Python podríamos caricaturizar su estrategia así:

tejido = 0

while tejido < 100:
    tejido += 10    # de día
    tejido -= 10    # de noche

Penélope sabía lo que hacía: su bucle no avanzaba a propósito. En nuestro programa, cuando ocurre lo mismo suele ser un descuido.

La pregunta práctica es muy útil: ¿cada vuelta me acerca a que la condición sea falsa?

Confundir = con ==

= asigna un valor; == compara igualdad. Si escribimos while contador = 5:, Python ni siquiera inicia el programa. En versiones actuales, el propio error puede sugerir que quizá queríamos escribir ==.

Olvidar los dos puntos

La cabecera necesita ::

while contador < 5:
    print(contador)
    contador += 1

Romper la sangría

Las instrucciones que pertenecen al bucle deben llevar sangría:

while contador < 5:
    print(contador)
    contador += 1

print("Terminado")

La última línea queda fuera del bucle y se ejecuta cuando este termina.

Pensar solo en «cuántas vueltas»

A veces sabemos que un bucle se ejecutará cinco veces; otras veces, no. Lo importante con while es comprender qué condición mantiene vivo el bucle y qué puede hacer que termine.

Controlar el bucle desde dentro

Hasta ahora hemos dejado que la condición marque cuándo termina el while. Python también permite intervenir desde el propio bloque: salir antes de tiempo, saltar instrucciones de una vuelta o distinguir si el bucle terminó sin interrupción. Estas posibilidades se comprenden mejor después de dominar la repetición básica.

break: salir antes de tiempo

break abandona inmediatamente el bucle en el que se encuentra, aunque su condición todavía sea True. El programa continúa después del bucle.

Según cuenta Diógenes Laercio, el filósofo encendió una lámpara a plena luz del día y, mientras caminaba, decía que buscaba «un hombre». Para nuestro ejemplo de programación imaginaremos una búsqueda de personas honestas, que puede detenerse en cuanto encuentra lo que busca:

persona = 0

while persona < 5:
    persona += 1
    honesto = input("¿Persona honesta? (s/n): ")

    if honesto == "s":
        print("Encontrada en la persona", persona)
        break

print("Búsqueda terminada")

Si se responde s, no es necesario consultar a las personas restantes: break corta la búsqueda. Si ninguna respuesta es s, la condición acabará siendo falsa al completar cinco consultas.

continue: saltar lo que queda de una vuelta

continue no termina el bucle. Omite las instrucciones restantes de la iteración actual y vuelve a comprobar la condición.

Imaginemos seis lecturas de un sensor, donde cada tercera lectura se considera inválida:

lectura = 0
validas = 0

while lectura < 6:
    lectura += 1

    if lectura % 3 == 0:
        continue

    validas += 1

print("Lecturas válidas:", validas)

El resultado es Lecturas válidas: 4: se descartan las lecturas 3 y 6. La actualización lectura += 1 está antes de continue, por lo que incluso las vueltas descartadas hacen avanzar el contador.

Atención al orden. En este otro programa, n se queda en 2 y el bucle no termina:

n = 0

while n < 5:
    if n == 2:
        continue
    n += 1

Cuando n == 2, continue salta la actualización n += 1. Python vuelve a comprobar n < 5 con el mismo valor una y otra vez. Es un error característico de while: saltar una instrucción no debe impedir el avance necesario para terminar.

Con continue, comprueba que la variable de control puede seguir avanzando.

while ... else: terminar sin break

El else de un while tiene un significado diferente al de una alternativa de if: se ejecuta cuando el bucle termina sin encontrar un break. Esto incluye el caso en que la condición sea falsa antes de la primera iteración.

Podemos completar la búsqueda de Diógenes con un mensaje distinto para cada desenlace:

persona = 0

while persona < 5:
    persona += 1
    honesto = input("¿Persona honesta? (s/n): ")

    if honesto == "s":
        print("Encontrada en la persona", persona)
        break
else:
    print("No se encontró entre las cinco personas")

Si aparece una respuesta s, se ejecuta break y se omite el else. Si se recorren las cinco personas sin encontrar ninguna, la condición pasa a False y se ejecuta el else.

También ocurriría con cero vueltas: si la condición fuese falsa desde el principio, Python saltaría directamente al else. Un continue, en cambio, no lo impide: únicamente pasa a la siguiente comprobación. El else no significa «el bucle no se ejecutó», sino «el bucle terminó sin break».

El else de un bucle se ejecuta si no se ha salido de él mediante break.

Compruébalo tú mismo: ¿se ejecuta el else?

Predice el resultado de cuatro situaciones: salida normal tras cinco vueltas, salida mediante break, condición falsa desde el principio y continue en la última vuelta. Después, comprueba por dónde sale el flujo y si llega al else.

while True con break: hacer algo antes de preguntar si seguimos

Python no tiene una construcción específica do ... while. Cuando necesitamos ejecutar un bloque al menos una vez y decidir después si repetimos, podemos usar while True y salir con break.

Por ejemplo, pedir una medida hasta recibir una válida:

while True:
    temperatura = float(input("Temperatura (0 a 100): "))

    if 0 <= temperatura <= 100:
        break

    print("Valor fuera del intervalo. Repite la entrada.")

print("Temperatura aceptada:", temperatura)

Python permite encadenar comparaciones: 0 <= temperatura <= 100 equivale aquí a temperatura >= 0 and temperatura <= 100.

La condición True por sí sola nunca se vuelve falsa. Aquí la salida depende de break: si la medida está dentro del intervalo, se abandona el bucle; de lo contrario se vuelve a preguntar. Este ejemplo presupone que se introduce un número válido: el tratamiento de entradas no numéricas queda fuera de su objetivo.

El mismo patrón explica por qué ciertos ciclos permanentes —por ejemplo, un microcontrolador que espera y atiende eventos— no son necesariamente errores. La diferencia está en cómo se ha previsto detener el proceso cuando sea necesario.

Ideas esenciales

La repetición

• while es una estructura de repetición, no una estructura condicional.
• La condición se evalúa antes de cada iteración, incluida la primera.
• Un while puede ejecutarse cero veces.
• Si debe terminar, el programa necesita alguna forma de avanzar hacia una condición falsa.
• Un bucle infinito no implica que while funcione mal: normalmente significa que la condición nunca deja de cumplirse.
• while resulta especialmente útil cuando no sabemos de antemano cuántas repeticiones harán falta.
• Un contador registra cuántas veces ocurre algo; un acumulador conserva un total que se construye durante las iteraciones.
• if decide una vez; while vuelve a comprobar.

Controlar el bucle

• break abandona el bucle antes de que la condición tenga que hacerse falsa.
• continue salta el resto de la iteración y regresa a la condición.
• El else de un while se ejecuta si el bucle termina sin break, incluso cuando no se ha ejecutado ninguna iteración.
• while True con break permite ejecutar primero un bloque y decidir después si hay que repetir.

Una última idea

Cuando escribas un while, no empieces pensando en la palabra while.

Empieza con dos preguntas:

¿Qué condición mantiene la repetición? ¿Qué hará que esa condición deje de cumplirse?

Entre Sherezade, el Zune, Penélope y Collatz cambia el escenario, pero la pregunta siempre es la misma: qué mantiene viva la repetición y qué, si algo, conseguirá terminarla.

Entender eso importa mucho más que memorizar la sintaxis.