Python while

Até agora, cada linha dos seus programas rodou uma vez só, de cima para baixo. Mas boa parte do trabalho de um computador é repetir: mostrar os 30 alunos da turma, somar os preços de todas as compras, perguntar de novo até a pessoa digitar uma resposta que preste. Para repetir existem os laços (em inglês, loops). O mais simples deles é o while, que em inglês quer dizer "enquanto": enquanto a condição for verdadeira, repita.

Todos os programas desta aula rodaram no Python 3.14 da máquina da Ana (usuária ana, computador notebook), salvos na pasta pessoal dela e executados com python3 arquivo.py (veja Rodando um Programa). Você pode rodar cada um no editor do guia.

A ideia: "enquanto tiver pão no cesto, atenda o próximo"

A padaria do bairro abre às 6 horas com um cesto de pães. O dono deixa um bilhete para o funcionário: "Enquanto tiver pão no cesto, atenda o próximo cliente." O bilhete não diz quantos clientes vão ser atendidos. Mesmo assim, ele funciona:

1. O funcionário olha o cesto: tem pão? Sim → atende um cliente.
2. Olha de novo: tem pão? Sim → atende mais um.
3. … e assim por diante …
4. Olha de novo: tem pão? Não → para de atender e vai fazer outra coisa.

Três detalhes desse bilhete valem para todo while:

• A pergunta vem antes de cada atendimento. Se o cesto já começar vazio, ninguém é atendido.
• Cada volta muda alguma coisa (sai pão do cesto). Sem isso, a resposta da pergunta seria sempre a mesma, e o funcionário atenderia para sempre.
• Quando a resposta vira não, ele sai da repetição e continua o resto do dia.

No Python, a "pergunta" é uma condição, a mesma do if: uma expressão que dá True (verdadeiro) ou False (falso), como contador <= 5 (veja Booleanos e Comparações). A diferença é que o if roda o bloco uma vez se a condição for verdadeira; o while roda o bloco de novo e de novo, enquanto ela continuar verdadeira.

1. O primeiro while: contar de 1 a 5

contador = 1
while contador <= 5:
    print(f"Volta {contador}")
    contador += 1
print(f"Fim! contador agora vale {contador}")

contador = 1

A variável contadora, criada antes do laço, com o valor inicial. Poderia se chamar volta ou i (de "índice", um nome tradicional para contadores); o importante é que ela exista antes de a condição ser testada.

while

A palavra-chave do laço: "enquanto".

contador <= 5

A condição, testada antes de cada volta. Lê-se: "enquanto o contador for menor ou igual a 5". No Python, ela não precisa de parênteses.

:

Os dois-pontos fecham a linha do while, como no if. Eles avisam: "agora vem o bloco que se repete".

print(f"Volta {contador}")

A primeira linha do corpo do laço. Ela está 4 espaços mais para dentro: é essa indentação que diz ao Python que a linha faz parte do while (veja Sintaxe e Indentação). A f-string põe o valor atual do contador no lugar de {contador}.

contador += 1

Soma 1 ao contador (o atalho de contador = contador + 1; veja Operadores de Atribuição). É esta linha que faz o laço andar: sem ela, o contador seria 1 para sempre.

print(f"Fim! …")

Esta linha voltou para a margem esquerda: ela está fora do laço e roda uma vez só, depois que o laço termina.

$ python3 contador.py
Volta 1
Volta 2
Volta 3
Volta 4
Volta 5
Fim! contador agora vale 6

Cada execução do corpo se chama uma volta (os programadores também dizem iteração). Aqui foram 5 voltas.

Passo a passo: o que o Python fez

Siga a variável contador volta por volta. Fazer de conta que você é o computador é a melhor forma de entender laços:

Por isso a última linha mostra contador agora vale 6: o laço só termina quando a condição fica falsa, e ela só fica falsa quando o contador passa de 5. A condição foi testada 6 vezes para o corpo rodar 5 vezes.

contador = 1
while contador <= 5:
    print(f"Volta {contador}")
    contador += 1
print(f"Fim! contador agora vale {contador}")

contador = 1
while contador <= 10:
    print(f"Volta {contador}")
    contador += 1
print(f"Fim! contador agora vale {contador}")

2. Contar para trás

O passo não precisa ser "mais 1". Para uma contagem regressiva, comece do maior número, diminua com -= 1 e troque a condição para "maior que zero":

segundos = 5
while segundos > 0:
    print(f"{segundos}...")
    segundos -= 1
print("Já!")

$ python3 regressiva.py
5...
4...
3...
2...
1...
Já!

Quando segundos chega a 0, a pergunta 0 > 0 dá False e o laço termina. O Já! está fora do bloco (na margem esquerda), então aparece uma vez só, no fim.

O passo também pode ser de 2 em 2 (contador += 2), de 10 em 10, ou até uma multiplicação (valor *= 2), como você vai ver na missão final.

3. Quando você não sabe quantas voltas vão ser

Nos dois exemplos acima, dava para saber de antemão: 5 voltas. O while brilha mesmo quando ninguém sabe quantas voltas serão. A Ana quer juntar R$ 1000 para comprar um notebook novo. Ela consegue guardar R$ 150 por mês. Quantos meses vai levar?

saldo = 0
meses = 0
while saldo < 1000:
    saldo += 150
    meses += 1
    print(f"Mês {meses}: R$ {saldo}")
print(f"A Ana juntou R$ {saldo} em {meses} meses.")

$ python3 poupanca.py
Mês 1: R$ 150
Mês 2: R$ 300
Mês 3: R$ 450
Mês 4: R$ 600
Mês 5: R$ 750
Mês 6: R$ 900
Mês 7: R$ 1050
A Ana juntou R$ 1050 em 7 meses.

Repare nos papéis das duas variáveis:

• saldo é um acumulador: começa em 0 e, a cada volta, recebe mais um pouco. É ele que a condição olha.
• meses é um contador: conta as voltas, para no fim a gente saber quantas foram.

No mês 6 o saldo era 900, ainda menor que 1000: mais uma volta. No mês 7 ele passou para 1050, a condição 1050 < 1000 deu False, e o laço parou. O programa descobriu sozinho que eram 7 meses.

Zero voltas também é possível

Como a pergunta vem antes da primeira volta, o corpo pode não rodar nenhuma vez. Se a Ana já tivesse R$ 1200:

saldo = 1200
meses = 0
while saldo < 1000:
    saldo += 150
    meses += 1
print(f"Meses de espera: {meses}")

$ python3 nunca.py
Meses de espera: 0

Logo no primeiro teste, 1200 < 1000 deu False: o Python pulou o bloco inteiro e foi direto para o print. Isso não é erro; é o cesto que já começou vazio.

4. Repetir com input(): somar até digitar 0

No caixa da padaria, a Ana digita o preço de cada item da compra. Ela não sabe quantos itens o cliente trouxe; quando acabar, ela digita 0. Um valor especial que quer dizer "acabou" se chama sentinela (como o vigia que avisa a hora de parar).

total = 0
preco = float(input("Preço do item (0 para terminar): "))
while preco != 0:
    total += preco
    preco = float(input("Preço do item (0 para terminar): "))
print(f"Total da compra: R$ {total:.2f}")

preco = float(input(…))

A primeira leitura acontece antes do laço, para a condição ter o que testar. O input() sempre devolve texto; o float() o transforma num número com casas decimais (veja input() e Conversão de Tipos).

while preco != 0:

"Enquanto o preço for diferente de zero." O != é o "diferente" do Python.

total += preco

Junta o preço no acumulador.

preco = float(input(…))

A próxima leitura, no fim do bloco. É ela que faz o laço andar: cada volta lê um preço novo, e a condição testa esse preço novo.

{total:.2f}

Mostra o total com 2 casas decimais (o jeito de escrever dinheiro). Os detalhes estão em f-strings.

No terminal, a Ana digitou 4.50, 12.90, 3.25 e, por fim, 0:

$ python3 compras.py
Preço do item (0 para terminar): 4.50
Preço do item (0 para terminar): 12.90
Preço do item (0 para terminar): 3.25
Preço do item (0 para terminar): 0
Total da compra: R$ 20.65

Repare que a pergunta aparece no código duas vezes: uma antes do laço e uma no fim do bloco. É o jeito clássico de escrever esse tipo de laço com while. Na seção Formas diferentes você vê como escrever a pergunta uma vez só.

total = 0
preco = float(input("Preço do item (0 para terminar): "))
while preco != 0:
    total += preco
    preco = float(input("Preço do item (0 para terminar): "))
print(f"Total da compra: R$ {total:.2f}")

5. Pedir de novo até a resposta ser válida

A professora da Ana lança as notas da turma num programa. Nota vai de 0 a 10; se ela digitar 15 sem querer, o programa deve reclamar e perguntar de novo, quantas vezes for preciso. Isso é validar a entrada, e é um dos usos mais comuns do while:

nota = int(input("Digite a nota (0 a 10): "))
while nota < 0 or nota > 10:
    print("Nota inválida! Tem de ser de 0 a 10.")
    nota = int(input("Digite a nota (0 a 10): "))
print(f"Nota aceita: {nota}")

A condição nota < 0 or nota > 10 quer dizer "a nota é inválida" (menor que 0 ou maior que 10; veja and, or e not). Enquanto ela for inválida, o programa reclama e lê de novo. Uma tentativa no terminal, digitando 15, depois -2, depois 8:

$ python3 nota.py
Digite a nota (0 a 10): 15
Nota inválida! Tem de ser de 0 a 10.
Digite a nota (0 a 10): -2
Nota inválida! Tem de ser de 0 a 10.
Digite a nota (0 a 10): 8
Nota aceita: 8

E se ela digitar 8 logo de cara? A condição dá False no primeiro teste, o bloco não roda nenhuma vez, e o programa aceita a nota direto. Ninguém leva bronca à toa.

nota = int(input("Digite a nota (0 a 10): "))
if nota < 0 or nota > 10:
    print("Nota inválida! Tem de ser de 0 a 10.")
    nota = int(input("Digite a nota (0 a 10): "))
print(f"Nota aceita: {nota}")

nota = int(input("Digite a nota (0 a 10): "))
while nota < 0 or nota > 10:
    print("Nota inválida! Tem de ser de 0 a 10.")
    nota = int(input("Digite a nota (0 a 10): "))
print(f"Nota aceita: {nota}")

Esse programa ainda tem um ponto fraco: se a professora digitar oito, por extenso, o int() não consegue converter e o programa para com um ValueError (você vai ver a mensagem em Quando dá errado). Tratar esse caso também é possível, mas pede uma ferramenta nova, o try, que tem aula própria: try e except.

6. O laço infinito, e como pará-lo

Um laço cuja condição nunca fica falsa não termina nunca: é um laço infinito. O jeito mais comum de criar um sem querer é esquecer a linha que faz o laço andar. Olhe o contador da seção 1 sem o contador += 1:

contador = 1
while contador <= 5:
    print(f"Volta {contador}")
print("Fim!")

O contador fica em 1 para sempre, então 1 <= 5 é sempre True, e o programa mostra Volta 1 sem parar. No lab, foram centenas de milhares de linhas por segundo. O Fim! nunca chega.

No terminal: Ctrl+C

Para interromper um programa que não termina, segure Ctrl e aperte C. O terminal mostra ^C (é assim que ele escreve o Ctrl+C) e o Python para, com esta mensagem:

$ python3 infinito.py
Volta 1
Volta 1
Volta 1                          « …centenas de milhares de linhas iguais…
Volta 1
^CVolta 1                        « o ^C é o Ctrl+C; o Volta 1 já estava a caminho da tela
Traceback (most recent call last):
  File "/home/ana/infinito.py", line 3, in <module>
    print(f"Volta {contador}")
    ~~~~~^^^^^^^^^^^^^^^^^^^^^
KeyboardInterrupt

$ echo $?
130

Linha por linha:

^C

O terminal mostrando que você apertou Ctrl+C.

Traceback (most recent call last):

"Rastro (a chamada mais recente por último)": o Python vai contar onde o programa estava quando parou.

File "/home/ana/infinito.py", line 3, in <module>

Ele estava no arquivo infinito.py, na linha 3, no programa principal (<module>). Faz sentido: é a única linha que o laço repetia.

print(f"Volta {contador}") e ~~~~~^^^^^

A linha em si, com o trecho que estava rodando marcado embaixo.

KeyboardInterrupt

"Interrupção pelo teclado". Não é um defeito do seu código: é o Python avisando que você mandou parar.

echo $? → 130

O código de saída do programa (o $? do terminal). 0 quer dizer "terminou bem"; 130 é o código de quem foi interrompido com Ctrl+C.

Se a tela encher tão rápido que o Ctrl+C parece não fazer efeito, espere um instante: o terminal ainda está mostrando as linhas que já tinham sido impressas.

No editor do guia

A caixa "Experimente" roda o Python de verdade dentro do navegador, então um laço infinito lá também não termina sozinho. A diferença é que o editor tem as suas próprias travas:

• enquanto o programa roda, o botão ▶ Rodar vira ■ Parar. Clicar nele é o Ctrl+C do editor: a caixa mostra ^C e [programa interrompido], sem o traceback do KeyboardInterrupt;
• se o programa passar de 10 segundos rodando sem terminar, o editor o para sozinho e avisa que pode ser um laço infinito (o tempo em que o programa espera você digitar não conta);
• se o programa escrever demais (como o Volta 1 sem fim), o editor também o para antes disso.

Mais detalhes na aula O Editor do Guia.

Quando o infinito é de propósito: while True

Às vezes o laço infinito é proposital: um programa que fica esperando pedidos até alguém mandar parar. Para isso se escreve while True:, uma condição que é sempre verdadeira. Um laço assim precisa de uma saída no meio do bloco, que é o break (em inglês, "quebrar"). Ele aparece logo abaixo, em Formas diferentes, e tem aula própria: break e continue.

7. while no modo interativo

Dá para escrever um laço direto no >>> do Python (veja O Modo Interativo). Depois da linha com os dois-pontos, o prompt muda para ...: o Python está esperando o corpo do laço. No Python 3.14, os 4 espaços de indentação aparecem sozinhos; você digita só o print(n). Para dizer que o bloco acabou, aperte Enter numa linha vazia:

$ python3
Python 3.14.4 (main, Aug 20 2026, 10:41:58) [GCC 15.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> n = 3
>>> while n > 0:
...     print(n)
...     n -= 1
...
3
2
1
>>> n
0
>>> exit()

O laço só rodou depois da linha vazia, de uma vez. E a variável continua lá depois do laço: n terminou valendo 0, o valor que fez a condição n > 0 ficar falsa.

Formas diferentes de fazer a mesma coisa

A validação da nota (seção 5) pode ser escrita de duas formas. A primeira é a que você já viu: lê antes do laço e lê de novo no fim do bloco.

nota = int(input("Digite a nota (0 a 10): "))
while nota < 0 or nota > 10:
    print("Nota inválida! Tem de ser de 0 a 10.")
    nota = int(input("Digite a nota (0 a 10): "))
print(f"Nota aceita: {nota}")

A segunda usa while True e sai do laço com break quando a nota é boa. A pergunta aparece uma vez só:

while True:
    nota = int(input("Digite a nota (0 a 10): "))
    if 0 <= nota <= 10:
        break
    print("Nota inválida! Tem de ser de 0 a 10.")
print(f"Nota aceita: {nota}")

$ python3 nota_true.py
Digite a nota (0 a 10): 11
Nota inválida! Tem de ser de 0 a 10.
Digite a nota (0 a 10): 7
Nota aceita: 7

O 0 <= nota <= 10 é uma comparação encadeada: "0 menor ou igual à nota, e a nota menor ou igual a 10", ou seja, a nota é válida. Quando é, o break pula para fora do laço, direto para o print final.

E contar de 1 a 5 também tem outra forma, mais curta, com o for e o range(), que são as próximas aulas. Fica só de aperitivo:

for contador in range(1, 6):
    print(f"Volta {contador}")

Quando dá errado

contador = 1
while contador <= 5
    print(f"Volta {contador}")
    contador += 1

$ python3 dois_pontos.py
  File "/home/ana/dois_pontos.py", line 2
    while contador <= 5
                       ^
SyntaxError: expected ':'

contador = 1
while contador <= 5:
print(f"Volta {contador}")
contador += 1

$ python3 indentacao.py
  File "/home/ana/indentacao.py", line 3
    print(f"Volta {contador}")
    ^^^^^
IndentationError: expected an indented block after 'while' statement on line 2

contador = 1
while contador <= 5:
    print(f"Volta {contador}")
contador += 1

while contador <= 5:
    print(f"Volta {contador}")
    contador += 1

$ python3 sem_inicio.py
Traceback (most recent call last):
  File "/home/ana/sem_inicio.py", line 1, in <module>
    while contador <= 5:
          ^^^^^^^^
NameError: name 'contador' is not defined

nota = input("Digite a nota (0 a 10): ")
while nota < 0 or nota > 10:
    print("Nota inválida! Tem de ser de 0 a 10.")
    nota = input("Digite a nota (0 a 10): ")
print(f"Nota aceita: {nota}")

$ python3 tipo.py
Digite a nota (0 a 10): 8
Traceback (most recent call last):
  File "/home/ana/tipo.py", line 2, in <module>
    while nota < 0 or nota > 10:
          ^^^^^^^^
TypeError: '<' not supported between instances of 'str' and 'int'

$ python3 nota.py
Digite a nota (0 a 10): oito
Traceback (most recent call last):
  File "/home/ana/nota.py", line 1, in <module>
    nota = int(input("Digite a nota (0 a 10): "))
ValueError: invalid literal for int() with base 10: 'oito'

nota = input("Digite a nota (0 a 10): ")
while nota < 0 or nota > 10:
    print("Nota inválida! Tem de ser de 0 a 10.")
    nota = input("Digite a nota (0 a 10): ")
print(f"Nota aceita: {nota}")

nota = int(input("Digite a nota (0 a 10): "))
while nota < 0 or nota > 10:
    print("Nota inválida! Tem de ser de 0 a 10.")
    nota = int(input("Digite a nota (0 a 10): "))
print(f"Nota aceita: {nota}")

Referência rápida

Exercícios

x = 10
while x > 4:
    print("Oi")
    x -= 2

Missão final: o dinheiro que dobra

valor = 1
dias = 0
# escreva o while aqui

print(f"Passou de R$ 1000 em {dias} dias: R$ {valor}")

valor = 1
dias = 0
while valor <= 1000:
    valor *= 2
    dias += 1
print(f"Passou de R$ 1000 em {dias} dias: R$ {valor}")

A resposta é 10 dias, com R$ 1024. No lab, saiu Passou de R$ 1000 em 10 dias: R$ 1024. Experimente trocar 1000 por um milhão (1000000): bastam mais 10 dias (no lab, deu 20 dias: R$ 1048576). É a força de dobrar.

Resumo

• while condição: ("enquanto") repete o bloco indentado enquanto a condição for True. A condição é testada antes de cada volta; se for falsa logo de cara, o bloco não roda nenhuma vez.
• Laço com contador tem três peças: início (antes do laço), condição e passo (dentro do bloco).
• O while é a escolha quando não se sabe quantas voltas vão ser: até a meta, até o valor sentinela, até a resposta ser válida.
• Com input(), leia uma vez antes do laço e de novo no fim do bloco, e converta com int() ou float().
• Sem o passo (ou com o passo fora da indentação), o laço é infinito. No terminal, Ctrl+C para o programa com um KeyboardInterrupt.
• while True: é um laço infinito de propósito; ele precisa de um break para sair (aula break e continue).