Faça-enquanto (do-while) em Python com while True e break

O Python não tem o laço "faça-enquanto" (do-while) das linguagens como C e Java. O jeito de escrevê-lo é um while True: com um break no momento em que a repetição deve acabar. O corpo roda primeiro, o teste vem depois, e por isso o bloco executa pelo menos uma vez. É o formato natural de tudo o que precisa acontecer antes de se saber se vale repetir: pedir um dado e conferir se ele serve, mostrar um menu e ver o que a pessoa escolheu, esperar um evento com limite de tempo.

O artigo anterior mostrou que o while normal testa antes e pode não rodar nenhuma vez. Este mostra o outro formato, as três maneiras de escrevê-lo e quando cada uma é melhor, a validação de entrada, o menu, a saída no meio do bloco, os cuidados com o break e o uso na ESP32.

O que é um faça-enquanto

A diferença entre os dois laços é o lugar do teste. No while, o teste vem antes do corpo: se a condição já nasce falsa, o corpo não roda. No faça-enquanto, o corpo vem primeiro e o teste decide se haverá outra volta. A figura mostra os dois fluxos, e o exemplo mostra a diferença na prática, com o mesmo valor inicial:

n = 0
while n > 0:
    print("while comum: roda", n)
    n = n - 1
print("---")
n = 0
while True:
    print("faca-enquanto: roda uma vez com", n)
    n = n - 1
    if n <= 0:
        break
print("fim")

A saída é ---, faca-enquanto: roda uma vez com 0 e fim. O primeiro laço não imprime nada, porque n > 0 já começa falso. O segundo roda o corpo uma vez com n valendo 0, e só então o if manda sair. A palavra break interrompe o laço na hora, e o programa continua na primeira linha depois dele.

A condição de while True é sempre verdadeira, então o laço só termina pelo break. É por isso que a receita tem sempre as duas peças: o while True abre o laço e o if ...: break é a única porta de saída. Escrever a segunda pensando como "sair quando" costuma ser mais natural do que a negação ("repetir enquanto não"), e a figura mostra o if not repetir, a condição de continuar, virada para a condição de sair.

A receita: validar uma entrada

O uso mais comum é conferir o que a pessoa digitou. Se o valor não serve, avisa e pergunta de novo, quantas vezes forem precisas:

while True:
    idade = int(input("Idade: "))
    if 0 <= idade <= 120:
        break
    print("Idade invalida, tente de novo")
print("idade aceita:", idade)

Com as entradas -5, 200 e 25, o programa mostra a mensagem de idade inválida duas vezes e termina com idade aceita: 25. Se a primeira entrada for 25, o aviso nunca aparece e o laço dá uma volta só. A leitura está dentro do laço, aparece uma única vez, e o if com break é a regra de aceitação: a condição que descreve a idade válida, 0 <= idade <= 120, sem negação nenhuma.

A figura acompanha as três voltas. Nas duas primeiras, a condição dá False e o programa passa direto pelo break, caindo no print de aviso e voltando ao topo do while. Na terceira, a condição dá True, o break sai do laço e o programa segue para o print final. A comparação com encadeamento, 0 <= idade <= 120, é a mesma do artigo sobre operadores relacionais e lógicos.

Três formas de escrever a mesma ideia

O while True com break não é a única opção. Há três jeitos de escrever uma repetição que precisa rodar ao menos uma vez, e cada um tem um custo.

A. Ler duas vezes. É o que o artigo sobre o while fez com a sentinela: a leitura vem uma vez antes do laço e outra no fim do bloco.

idade = int(input("Idade: "))
while idade < 0 or idade > 120:
    print("Idade invalida, tente de novo")
    idade = int(input("Idade: "))
print("idade aceita:", idade)

A saída é a mesma do exemplo com break. A vantagem é que o teste continua no topo, e quem lê sabe de cara a condição do laço. O custo é a leitura duplicada: se a mensagem do input mudar, é preciso mudar nos dois lugares, e esquecer um deles é um erro comum. Repare também que a condição agora descreve o que é inválido (idade < 0 or idade > 120), a negação da que estava no if do break.

B. while True com break, mostrado acima. A leitura aparece uma vez, e o preço é que a saída fica escondida no meio do bloco. Quem lê precisa percorrer o corpo para achar o break.

C. Começar com a condição verdadeira. Quando a decisão de repetir vem de uma resposta da pessoa, dá para dar ao teste um valor que já começa verdadeiro:

resp = "s"
rodadas = 0
while resp == "s":
    rodadas = rodadas + 1
    print("rodada", rodadas)
    resp = input("Outra (s/n)? ")
print("jogou", rodadas)

A saída tem rodada 1, a pergunta, rodada 2, a pergunta, rodada 3, a pergunta com a resposta n e jogou 3. O resp = "s" inicial não é uma resposta de verdade: é um truque para o primeiro teste passar. Funciona bem aqui porque a regra de parada é simples e está no while, sem break nenhum. Não funciona quando a condição de parada depende do que o corpo calcula.

Qual escolher? Quando a regra de parada cabe numa condição curta e a leitura não é longa, a forma A ou a C mantém o while honesto. Quando a leitura envolve várias linhas, ou a regra de parada só pode ser avaliada depois de uma conta, a forma B é a mais limpa. Os três dão o mesmo resultado, e o critério é a clareza.

A saída no meio do bloco

O break não precisa ficar no fim. Ele pode ficar no meio, entre o que vem antes dele (a leitura, por exemplo) e o que vem depois (o processamento). É o jeito mais limpo de escrever a soma até digitar zero, sem repetir a leitura:

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

A saída termina com total 40, a mesma da versão com a sentinela do artigo Por que repetir. A leitura aparece uma vez, o break descarta o zero antes de ele ser somado, e o total só recebe valores válidos. Os desafios Até zero, Contador de positivos e Maior número pedem esse formato, e podem ser resolvidos das duas formas.

O menu

Um menu é o faça-enquanto por natureza: mostra as opções, lê a escolha, age e repete até a pessoa escolher sair.

saldo = 100
while True:
    print("1 saldo | 2 depositar 50 | 0 sair")
    opcao = int(input("Opcao: "))
    if opcao == 0:
        break
    elif opcao == 1:
        print("saldo", saldo)
    elif opcao == 2:
        saldo = saldo + 50
        print("depositado")
    else:
        print("opcao invalida")
print("ate logo, saldo final", saldo)

Com as escolhas 1, 9, 2 e 0, o programa mostra o saldo de 100, avisa que a opção 9 é inválida, deposita mais 50 e sai com ate logo, saldo final 150. O if é o do artigo sobre if, elif e else, e a opção de saída é a primeira da cadeia, que executa o break. O else final cobre qualquer número que não seja uma opção, e o menu volta a se mostrar. É o formato de qualquer programa que fica esperando comandos.

Cuidados com o break

O break é simples, e por isso mesmo vale conhecer três limites dele.

Sem break alcançável, o laço não termina. Um while True cuja saída depende de uma condição que nunca se realiza roda para sempre. Em programas de aula, uma boa defesa é um contador de segurança:

tentativas = 0
while True:
    tentativas += 1
    print("tentativa", tentativas)
    if tentativas == 3:
        print("desisto")
        break

A saída é tentativa 1, tentativa 2, tentativa 3 e desisto. O contador transforma um laço potencialmente infinito num laço com número máximo de voltas, e a mesma ideia serve para esperas que podem nunca terminar.

O break sai só do laço mais interno. Com laços aninhados, o laço de fora continua:

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

A saída é 0 0, 1 0, 2 0 e fim. Em cada volta do laço de fora, o for j imprime o par com j igual a 0 e sai quando chega ao 1. O laço de fora segue normalmente e faz as três voltas. Para sair dos dois de uma vez, é preciso uma variável de controle que o laço de fora também teste, ou, quando as funções entrarem na série, um return.

O break só existe dentro de um laço. Fora dele, o programa nem começa:

break

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

O Python do computador diz SyntaxError: 'break' outside loop. As duas mensagens querem dizer o mesmo: o break está fora de um for ou while, normalmente por causa de um recuo errado que o deixou na margem.

O que muda na ESP32

O while True é a estrutura do programa principal de uma placa, e ali o break costuma não existir: o aparelho funciona até ser desligado. O faça-enquanto aparece em trechos menores do programa, o mais comum sendo esperar por um evento com limite de tempo. O exemplo espera um botão com um prazo 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("apertado")
        break
    if time.ticks_diff(time.ticks_ms(), inicio) > 300:
        print("tempo esgotado")
        break
    time.sleep_ms(20)
print("fim")

No simulador, sem circuito, a saída é tempo esgotado e fim. Com o resistor de pull-up interno, o pino fica em 1 enquanto ninguém aperta o botão (assunto do artigo sobre pull-up e pino flutuante), então o teste botao.value() == 0 nunca é verdadeiro e o prazo acaba. O laço tem duas saídas, cada uma com o seu break, e a pausa de 20 ms dentro dele evita que o processador fique rodando a toda velocidade. O resultado de um laço assim é sempre uma entre duas coisas, o evento chegou ou o prazo acabou, e o programa precisa tratar as duas.

A mesma estrutura serve para esperar a conexão Wi-Fi. A solução de referência do desafio Conectar ao Wi-Fi repete a espera enquanto a placa não está conectada e sai com break quando passam 10 segundos. O artigo sobre Wi-Fi, HTTP e MQTT mostra a conexão completa. Sem o limite de tempo, uma rede fora do ar deixaria a placa esperando para sempre.

Em sala de aula: onde o faça-enquanto costuma tropeçar

Os casos abaixo se repetem nas turmas que aprendem o break, e em quase todos o programa roda.

A condição de aceitação invertida

Quem escreve a regra de validação em português ("a idade tem de ser de 0 a 120") e a traduz com or em vez de and cria uma regra que aceita tudo:

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

A saída é -5 True False, 200 True False e 25 True True. Com o or, qualquer número passa: o -5 passa no <= 120 e o 200 passa no >= 0. É o mesmo erro de lógica do artigo sobre tabelas-verdade, agora dentro de um if com break, e o programa aceita a primeira entrada, seja ela qual for. A terceira coluna, com o encadeamento, é a que funciona.

O break sem o if

Um break solto no corpo do laço roda na primeira volta:

while True:
    print("so uma volta")
    break
print("fim")

A saída é so uma volta e fim. O laço é um while True com uma volta só, e o sintoma é o programa que "só pergunta uma vez". Em geral o break perdeu o if ou o recuo que o colocava dentro dele.

A mensagem de erro no lugar errado

Se o print("Idade invalida") fica antes do if, a mensagem aparece até para a idade válida. A ordem do corpo importa: conferir, sair se estiver certo, e só então avisar do erro.

Esquecer a conversão

O input() devolve texto, e comparar um texto com número dentro da validação é um erro de tipo ou um if que nunca é verdadeiro. A conversão com int() ou float() vai dentro do laço, junto da leitura, como no artigo sobre conversão de tipos.

Menu que não termina

O menu com opção de sair que não faz o break, ou que testa a opção como texto ("0") depois de converter para número. O teste de saída precisa ter o mesmo tipo da entrada.

Usar o while True sem precisar

Nem todo while precisa virar while True. Se a condição cabe na linha do while e a leitura não é longa, deixar o teste no topo, como na forma A, é mais direto. O while True com break é uma ferramenta para quando a saída no meio do bloco deixa o código mais claro.

Exercício: o caixa eletrônico

O programa pede um valor de saque e só aceita se ele for positivo, múltiplo de 10 e não passar do saldo de 500. Cada motivo de recusa tem a sua mensagem. Quando o valor é aceito, o laço termina e o saque é feito.

saldo = 500
while True:
    valor = int(input("Valor do saque: "))
    if valor <= 0:
        print("Digite um valor positivo")
    elif valor % 10 != 0:
        print("So notas de 10")
    elif valor > saldo:
        print("Saldo insuficiente")
    else:
        break
saldo = saldo - valor
print("sacou", valor, "saldo", saldo)

Com as entradas 0, 35, 600 e 120, a saída traz as três recusas, uma por entrada (Digite um valor positivo, So notas de 10 e Saldo insuficiente), e termina com sacou 120 saldo 380. Repare que o break está no else: ele só roda quando nenhuma recusa se aplicou, e é o único caminho de saída. O % é o resto da divisão, do artigo sobre operadores aritméticos.

Para ampliar, acrescente um limite de três tentativas com um contador, como no exemplo do desisto, e uma mensagem de bloqueio quando elas acabarem.

Perguntas frequentes

Por que o Python não tem do-while?

O while True com break já faz o trabalho, e a linguagem não ganhou uma segunda forma de escrever a mesma coisa. Quem vem de C ou Java encontra a mesma ideia com outra roupa.

while True é má prática?

Não. É a forma padrão do faça-enquanto e do laço principal de uma placa. O que importa é que a saída exista e seja alcançável, ou que o laço seja infinito de propósito.

Posso usar while 1?

Funciona, porque o 1 é verdadeiro, mas while True diz melhor o que se quer, e é a forma que se vê nos exemplos do MicroPython.

O que acontece com o else de um while True com break?

O bloco do else de um laço só roda quando ele termina sem break. Com break o else é ignorado. O assunto é do próximo artigo da série.

Como sair de dois laços de uma vez?

Com uma variável de controle testada pelos dois, ou colocando os laços numa função e usando return. Um break sozinho sai só do laço mais interno.

Para continuar

A trilha Lógica com Python tem desafios que podem ser resolvidos com while True e break: o Até zero, a Senha 1234, o Contador de positivos e o Maior número. Tente cada um das duas formas, lendo duas vezes e com break, e compare qual ficou mais clara.

O próximo assunto é o conjunto completo de comandos de controle dos laços: break, continue e o else que o for e o while aceitam.