Hacer-mientras (do-while) en Python con while True y break

Python no tiene el bucle "hacer-mientras" (do-while) de lenguajes como C y Java. La manera de escribirlo es un while True: con un break en el momento en que la repetición debe terminar. El cuerpo corre primero, la prueba viene después, y por eso el bloque se ejecuta al menos una vez. Es el formato natural de todo lo que tiene que ocurrir antes de saber si vale la pena repetir: pedir un dato y comprobar si sirve, mostrar un menú y ver qué eligió la persona, esperar un evento con límite de tiempo.

El artículo anterior mostró que el while normal prueba antes y puede no correr ninguna vez. Este muestra el otro formato, las tres maneras de escribirlo y cuándo conviene cada una, la validación de entrada, el menú, la salida en medio del bloque, los cuidados con el break y el uso en la ESP32.

Qué es un hacer-mientras

La diferencia entre los dos bucles es el lugar de la prueba. En el while, la prueba viene antes del cuerpo: si la condición ya nace falsa, el cuerpo no corre. En el hacer-mientras, el cuerpo viene primero y la prueba decide si habrá otra vuelta. La figura muestra los dos flujos, y el ejemplo muestra la diferencia en la práctica, con el mismo valor inicial:

n = 0
while n > 0:
    print("while común: corre", n)
    n = n - 1
print("---")
n = 0
while True:
    print("hacer-mientras: corre una vez con", n)
    n = n - 1
    if n <= 0:
        break
print("fin")

La salida es ---, hacer-mientras: corre una vez con 0 y fin. El primer bucle no imprime nada, porque n > 0 ya empieza falso. El segundo corre el cuerpo una vez con n valiendo 0, y solo entonces el if manda salir. La palabra break interrumpe el bucle en el acto, y el programa continúa en la primera línea después de él.

La condición de while True es siempre verdadera, así que el bucle solo termina por el break. Por eso la receta tiene siempre las dos piezas: el while True abre el bucle y el if ...: break es la única puerta de salida. Escribir la segunda pensando en "salir cuando" suele ser más natural que la negación ("repetir mientras no"), y la figura muestra el if not repetir, la condición de continuar, dada vuelta hacia la condición de salir.

La receta: validar una entrada

El uso más común es comprobar lo que la persona escribió. Si el valor no sirve, avisa y pregunta de nuevo, las veces que haga falta:

while True:
    idade = int(input("Edad: "))
    if 0 <= idade <= 120:
        break
    print("Edad inválida, inténtalo de nuevo")
print("edad aceptada:", idade)

Con las entradas -5, 200 y 25, el programa muestra el mensaje de edad inválida dos veces y termina con edad aceptada: 25. Si la primera entrada es 25, el aviso nunca aparece y el bucle da una sola vuelta. La lectura está dentro del bucle, aparece una única vez, y el if con break es la regla de aceptación: la condición que describe la edad válida, 0 <= idade <= 120, sin ninguna negación.

La figura sigue las tres vueltas. En las dos primeras, la condición da False y el programa pasa de largo por el break, cae en el print de aviso y vuelve a la parte de arriba del while. En la tercera, la condición da True, el break sale del bucle y el programa sigue hacia el print final. La comparación encadenada, 0 <= idade <= 120, es la misma del artículo sobre operadores relacionales y lógicos.

Tres formas de escribir la misma idea

El while True con break no es la única opción. Hay tres maneras de escribir una repetición que necesita correr al menos una vez, y cada una tiene un costo.

A. Leer dos veces. Es lo que hizo el artículo sobre el while con el centinela: la lectura viene una vez antes del bucle y otra al final del bloque.

idade = int(input("Edad: "))
while idade < 0 or idade > 120:
    print("Edad inválida, inténtalo de nuevo")
    idade = int(input("Edad: "))
print("edad aceptada:", idade)

La salida es la misma del ejemplo con break. La ventaja es que la prueba sigue arriba, y quien lee conoce de entrada la condición del bucle. El costo es la lectura duplicada: si el mensaje del input cambia, hay que cambiarlo en los dos lugares, y olvidar uno de ellos es un error común. Fíjate también en que la condición ahora describe lo que es inválido (idade < 0 or idade > 120), la negación de la que estaba en el if del break.

B. while True con break, mostrado arriba. La lectura aparece una vez, y el precio es que la salida queda escondida en medio del bloque. Quien lee necesita recorrer el cuerpo para encontrar el break.

C. Empezar con la condición verdadera. Cuando la decisión de repetir viene de una respuesta de la persona, se puede dar a la prueba un valor que ya empieza verdadero:

resp = "s"
rodadas = 0
while resp == "s":
    rodadas = rodadas + 1
    print("ronda", rodadas)
    resp = input("¿Otra (s/n)? ")
print("jugó", rodadas)

La salida tiene ronda 1, la pregunta, ronda 2, la pregunta, ronda 3, la pregunta con la respuesta n y jugó 3. El resp = "s" inicial no es una respuesta de verdad: es un truco para que la primera prueba pase. Funciona bien aquí porque la regla de parada es simple y está en el while, sin ningún break. No funciona cuando la condición de parada depende de lo que el cuerpo calcula.

¿Cuál elegir? Cuando la regla de parada cabe en una condición corta y la lectura no es larga, la forma A o la C mantiene el while honesto. Cuando la lectura abarca varias líneas, o la regla de parada solo puede evaluarse después de una cuenta, la forma B es la más limpia. Las tres dan el mismo resultado, y el criterio es la claridad.

La salida en medio del bloque

El break no tiene que estar al final. Puede estar en el medio, entre lo que viene antes de él (la lectura, por ejemplo) y lo que viene después (el procesamiento). Es la manera más limpia de escribir la suma hasta escribir cero, sin repetir la lectura:

total = 0
while True:
    n = int(input("Valor (0 para parar): "))
    if n == 0:
        break
    total = total + n
print("total", total)

La salida termina con total 40, la misma de la versión con el centinela del artículo Por qué repetir. La lectura aparece una vez, el break descarta el cero antes de que sea sumado, y el total solo recibe valores válidos. Los desafíos Hasta cero, Contador de positivos y Mayor número piden este formato, y pueden resolverse de las dos maneras.

El menú

Un menú es el hacer-mientras por naturaleza: muestra las opciones, lee la elección, actúa y repite hasta que la persona elige salir.

saldo = 100
while True:
    print("1 saldo | 2 depositar 50 | 0 salir")
    opcao = int(input("Opción: "))
    if opcao == 0:
        break
    elif opcao == 1:
        print("saldo", saldo)
    elif opcao == 2:
        saldo = saldo + 50
        print("depositado")
    else:
        print("opción inválida")
print("hasta luego, saldo final", saldo)

Con las elecciones 1, 9, 2 y 0, el programa muestra el saldo de 100, avisa que la opción 9 es inválida, deposita otros 50 y sale con hasta luego, saldo final 150. El if es el del artículo sobre if, elif y else, y la opción de salida es la primera de la cadena, la que ejecuta el break. El else final cubre cualquier número que no sea una opción, y el menú vuelve a mostrarse. Es el formato de cualquier programa que se queda esperando comandos.

Cuidados con el break

El break es simple, y justamente por eso vale la pena conocer tres límites suyos.

Sin un break alcanzable, el bucle no termina. Un while True cuya salida depende de una condición que nunca se cumple corre para siempre. En programas de clase, una buena defensa es un contador de seguridad:

tentativas = 0
while True:
    tentativas += 1
    print("intento", tentativas)
    if tentativas == 3:
        print("me rindo")
        break

La salida es intento 1, intento 2, intento 3 y me rindo. El contador convierte un bucle potencialmente infinito en un bucle con número máximo de vueltas, y la misma idea sirve para esperas que pueden no terminar nunca.

El break sale solo del bucle más interno. Con bucles anidados, el bucle de afuera continúa:

for i in range(3):
    for j in range(3):
        if j == 1:
            break
        print(i, j)
print("fin")

La salida es 0 0, 1 0, 2 0 y fin. En cada vuelta del bucle de afuera, el for j imprime el par con j igual a 0 y sale cuando llega al 1. El bucle de afuera sigue normalmente y da las tres vueltas. Para salir de los dos de una vez, hace falta una variable de control que el bucle de afuera también pruebe o, cuando las funciones entren en la serie, un return.

El break solo existe dentro de un bucle. Fuera de él, el programa ni siquiera arranca:

break

Traceback (most recent call last):
  File "main.py", line 1
SyntaxError: 'break'/'continue' outside loop

El Python del computador dice SyntaxError: 'break' outside loop. Los dos mensajes quieren decir lo mismo: el break está fuera de un for o while, normalmente por una sangría equivocada que lo dejó en el margen.

Qué cambia en la ESP32

El while True es la estructura del programa principal de una placa, y allí el break suele no existir: el aparato funciona hasta que se apaga. El hacer-mientras aparece en trozos menores del programa, siendo el más común esperar un evento con límite de tiempo. El ejemplo espera un botón con un plazo de 300 ms:

from machine import Pin
import time
botao = Pin(4, Pin.IN, Pin.PULL_UP)
inicio = time.ticks_ms()
while True:
    if botao.value() == 0:
        print("presionado")
        break
    if time.ticks_diff(time.ticks_ms(), inicio) > 300:
        print("tiempo agotado")
        break
    time.sleep_ms(20)
print("fin")

En el simulador, sin circuito, la salida es tiempo agotado y fin. Con la resistencia pull-up interna, el pin queda en 1 mientras nadie presiona el botón (tema del artículo sobre pull-up y pin flotante), así que la prueba botao.value() == 0 nunca es verdadera y el plazo se acaba. El bucle tiene dos salidas, cada una con su break, y la pausa de 20 ms dentro de él evita que el procesador quede corriendo a toda velocidad. El resultado de un bucle así es siempre una de dos cosas, el evento llegó o el plazo se acabó, y el programa necesita tratar las dos.

La misma estructura sirve para esperar la conexión Wi-Fi. La solución de referencia del desafío Conectar al Wi-Fi repite la espera mientras la placa no está conectada y sale con break cuando pasan 10 segundos. El artículo sobre Wi-Fi, HTTP y MQTT muestra la conexión completa. Sin el límite de tiempo, una red caída dejaría a la placa esperando para siempre.

En el aula: dónde suele tropezar el hacer-mientras

Los casos de abajo se repiten en los grupos que aprenden el break, y en casi todos el programa corre.

La condición de aceptación invertida

Quien escribe la regla de validación en español ("la edad tiene que ser de 0 a 120") y la traduce con or en lugar de and crea una regla que acepta todo:

for idade in (-5, 200, 25):
    print(idade, idade >= 0 or idade <= 120, 0 <= idade <= 120)

La salida es -5 True False, 200 True False y 25 True True. Con el or, cualquier número pasa: el -5 pasa en el <= 120 y el 200 pasa en el >= 0. Es el mismo error de lógica del artículo sobre tablas de verdad, ahora dentro de un if con break, y el programa acepta la primera entrada, sea cual sea. La tercera columna, con el encadenamiento, es la que funciona.

El break sin el if

Un break suelto en el cuerpo del bucle corre en la primera vuelta:

while True:
    print("solo una vuelta")
    break
print("fin")

La salida es solo una vuelta y fin. El bucle es un while True con una sola vuelta, y el síntoma es el programa que "solo pregunta una vez". En general, el break perdió el if o la sangría que lo ponía dentro de él.

El mensaje de error en el lugar equivocado

Si el print("Edad inválida") queda antes del if, el mensaje aparece incluso para la edad válida. El orden del cuerpo importa: comprobar, salir si está bien, y solo entonces avisar del error.

Olvidar la conversión

El input() devuelve texto, y comparar un texto con un número dentro de la validación es un error de tipo o un if que nunca es verdadero. La conversión con int() o float() va dentro del bucle, junto a la lectura, como en el artículo sobre conversión de tipos.

Menú que no termina

Es el menú con opción de salir que no hace el break, o que prueba la opción como texto ("0") después de convertirla en número. La prueba de salida tiene que tener el mismo tipo que la entrada.

Usar el while True sin necesitarlo

No todo while necesita volverse while True. Si la condición cabe en la línea del while y la lectura no es larga, dejar la prueba arriba, como en la forma A, es más directo. El while True con break es una herramienta para cuando la salida en medio del bloque deja el código más claro.

Ejercicio: el cajero automático

El programa pide un monto de retiro y solo lo acepta si es positivo, múltiplo de 10 y no supera el saldo de 500. Cada motivo de rechazo tiene su mensaje. Cuando el valor es aceptado, el bucle termina y se hace el retiro.

saldo = 500
while True:
    valor = int(input("Monto del retiro: "))
    if valor <= 0:
        print("Escribe un valor positivo")
    elif valor % 10 != 0:
        print("Solo billetes de 10")
    elif valor > saldo:
        print("Saldo insuficiente")
    else:
        break
saldo = saldo - valor
print("retiró", valor, "saldo", saldo)

Con las entradas 0, 35, 600 y 120, la salida trae los tres rechazos, uno por entrada (Escribe un valor positivo, Solo billetes de 10 y Saldo insuficiente), y termina con retiró 120 saldo 380. Fíjate en que el break está en el else: solo corre cuando ningún rechazo se aplicó, y es el único camino de salida. El % es el resto de la división, del artículo sobre operadores aritméticos.

Para ampliarlo, agrega un límite de tres intentos con un contador, como en el ejemplo del me rindo, y un mensaje de bloqueo cuando se acaben.

Preguntas frecuentes

¿Por qué Python no tiene do-while?

El while True con break ya hace el trabajo, y el lenguaje no ganó una segunda forma de escribir lo mismo. Quien viene de C o Java encuentra la misma idea con otra ropa.

¿while True es mala práctica?

No. Es la forma estándar del hacer-mientras y del bucle principal de una placa. Lo que importa es que la salida exista y sea alcanzable, o que el bucle sea infinito a propósito.

¿Puedo usar while 1?

Funciona, porque el 1 es verdadero, pero while True dice mejor lo que se quiere, y es la forma que se ve en los ejemplos de MicroPython.

¿Qué pasa con el else de un while True con break?

El bloque del else de un bucle solo corre cuando termina sin break. Con break, el else se ignora. El tema es del próximo artículo de la serie.

¿Cómo salgo de dos bucles de una vez?

Con una variable de control probada por los dos, o poniendo los bucles en una función y usando return. Un break solo sale del bucle más interno.

Para continuar

La ruta Lógica con Python tiene desafíos que pueden resolverse con while True y break: el Hasta cero, la Contraseña 1234, el Contador de positivos y el Mayor número. Prueba cada uno de las dos maneras, leyendo dos veces y con break, y compara cuál quedó más clara.

El próximo tema es el conjunto completo de comandos de control de los bucles: break, continue y el else que aceptan el for y el while.