Laço while em Python: quando o laço for não é suficiente

Iniciante20 min5 exercícios65 XP

Este tutorial foi traduzido do original em inglês.Read in English Leer en español Читать на русском อ่านภาษาไทย Avisar sobre um erro de tradução

Antes de começar

Laço for em Python: percorra qualquer coisa, com exemplos

0/5 exercícios

Uma máquina de venda automática não sabe quantas moedas você vai inserir. Ela fica esperando: "enquanto o total for menor que o preço, continue aceitando moedas". Ela não pode usar um laço for, porque não sabe o número de repetições com antecedência. Ela precisa de um laço while.

Neste tutorial, você vai aprender a usar laços while nas situações em que precisa repetir algo até que uma condição mude. Também vai ver como evitar laços infinitos, como usar break para sair mais cedo e quando escolher while em vez de for.

No final, você vai ter dois tipos de laço na sua caixa de ferramentas: for para percorrer coleções conhecidas e while para repetir até que uma condição seja atendida.

Como funciona um laço while em Python?

Um laço while testa uma condição antes de cada repetição. Se a condição for True, o corpo do laço é executado. Depois o Python volta ao início e testa a condição de novo. Isso se repete até a condição virar False.

Pense num segurança na porta que confere seu crachá toda vez que você tenta entrar. Enquanto o crachá for válido, você entra. No momento em que ele vence, a porta fica fechada.

Um laço while que conta até 5

count = 1

while count <= 5:

print(count)

count += 1

print("Done!")

# Output:

# 1

# 2

# 3

# 4

# 5

# Done!

Saída

1
2
3
4
5
Done!

O fluxo é este: o Python testa count <= 5. Como count começa em 1, a condição é True, então o corpo é executado: ele exibe count e soma 1. Depois o Python testa de novo. Isso continua até count chegar a 6; nesse ponto, 6 <= 5 é False e o laço para.

O ponto essencial é que algo dentro do laço precisa, em algum momento, tornar a condição False. Aqui, count += 1 garante que o contador cresça até passar de 5. Sem essa linha, o laço rodaria para sempre.

Como contar e acumular com laços while?

Laços while são ótimos para tarefas em que você precisa processar dados até atingir um objetivo. Você define uma condição, e o laço continua rodando até que ela seja satisfeita.

Contando: quantas vezes dobrar para passar de 1000?

# How many doubles of 1 to exceed 1000?

value = 1

doubles = 0

while value <= 1000:

value = value * 2

doubles += 1

print(f"After {doubles} doubles, the value is {value}")

# Output:

# After 10 doubles, the value is 1024

Saída

After 10 doubles, the value is 1024

Não seria fácil escrever isso como um laço for, porque não sabemos de antemão quantas vezes vamos dobrar o valor. O laço while continua até o valor passar de 1000, e nós contamos quantas vezes ele rodou.

Acumulando: somar até passar de 100

# Summing numbers until the total reaches 100

total = 0

number = 1

while total < 100:

total += number

number += 1

# number was incremented one extra time after the last addition

print(f"Sum of 1 to {number - 1} = {total}")

# Output:

# Sum of 1 to 14 = 105

Saída

Sum of 1 to 14 = 105

O laço soma números consecutivos (1, 2, 3, ...) até o total chegar a 100 ou passar disso. Depois do laço, number vale um a mais que o último número somado, porque a linha number += 1 roda depois de cada soma. Por isso exibimos number - 1.

O que são laços infinitos e como funciona o break?

Um laço infinito é um laço cuja condição nunca vira False. Às vezes isso é um bug. Mas às vezes é intencional: você cria um laço infinito de propósito e usa break para sair quando quiser.

Laço infinito por acidente (bug!)

# DON'T RUN THIS - it never stops!
count = 1
while count <= 5:
    print(count)
    # Oops, forgot count += 1

Laço infinito intencional com break

while True:
    answer = "yes"
    print("Looping...")
    if answer == "yes":
        break
print("Escaped!")

while True cria um laço que, por padrão, roda para sempre. A instrução break sai do laço na hora e pula para a primeira linha depois dele. Esse padrão é muito comum em menus, laços de jogos e validação de entrada.

Jogo de adivinhação com while True + break

# Simulating a guessing game (without real input)

secret = 7

guesses = [3, 9, 5, 7] # simulated guesses

attempt = 0

while True:

guess = guesses[attempt]

attempt += 1

print(f"Guess {attempt}: {guess}")

if guess == secret:

print(f"Correct! You got it in {attempt} tries!")

break

elif guess < secret:

print("Too low!")

else:

print("Too high!")

# Output:

# Guess 1: 3

# Too low!

# Guess 2: 9

# Too high!

# Guess 3: 5

# Too low!

# Guess 4: 7

# Correct! You got it in 4 tries!

Saída

Guess 1: 3
Too low!
Guess 2: 9
Too high!
Guess 3: 5
Too low!
Guess 4: 7
Correct! You got it in 4 tries!

O laço continua rodando até alguém acertar o número secreto. Não dá para prever quando isso vai acontecer, então while True com break é o padrão natural. O break só é executado quando guess == secret, então o laço termina exatamente no momento certo.

Como validar a entrada com um laço while?

Um dos usos mais práticos dos laços while é a validação de entrada: pedir dados repetidamente até o usuário fornecer algo válido. É esse o padrão por trás de todo formulário que diz "digite um endereço de e-mail válido".

Laço de validação de entrada

# Simulating input validation (without real input)

test_inputs = ["abc", "-5", "0", "25"] # simulated user inputs

input_index = 0

age = -1 # start invalid

while age <= 0 or age > 120:

user_input = test_inputs[input_index]

input_index += 1

print(f"Enter your age: {user_input}")

if user_input.isdigit():

age = int(user_input)

else:

print("Please enter a number.")

continue

if age <= 0 or age > 120:

print("Age must be between 1 and 120.")

print(f"Your age: {age}")

# Output:

# Enter your age: abc

# Please enter a number.

# Enter your age: -5

# Age must be between 1 and 120.

# Enter your age: 0

# Age must be between 1 and 120.

# Enter your age: 25

# Your age: 25

Saída

Enter your age: abc
Please enter a number.
Enter your age: -5
Please enter a number.
Enter your age: 0
Age must be between 1 and 120.
Enter your age: 25
Your age: 25

O laço continua perguntando até receber uma idade válida. Entradas inválidas, como "abc" ou números negativos, geram mensagens de erro, e o laço se repete. Só quando uma idade válida é informada a condição age <= 0 or age > 120 vira False, e o laço termina.

Repare na instrução continue: quando a entrada não é um número, pulamos o resto do corpo do laço e voltamos direto para o início. Você vai aprender mais sobre continue no próximo tutorial.

Quando usar while e quando usar for?

Tanto for quanto while repetem código, mas cada um foi feito para situações diferentes. Escolher o certo deixa seu código mais claro e menos sujeito a erros.

Use `for` quando...	Use `while` quando...
Você está percorrendo uma coleção	Você está esperando uma condição mudar
Você sabe quantas vezes repetir	Você NÃO sabe quantas vezes repetir
Você está processando cada item de uma lista	Você está repetindo até algo acontecer
Exemplo: exibir o nome de cada aluno	Exemplo: perguntar de novo até a entrada ser válida

For vs while: a ferramenta certa para cada caso

# FOR loop: you know the items to process

fruits = ["apple", "banana", "cherry"]

for fruit in fruits:

print(f"I like {fruit}")

print()

# WHILE loop: you don't know when to stop

num = 1

while num < 100:

num = num * 3

print(num, end=" ")

print(f"\nFirst power of 3 >= 100: {num}")

# Output:

# I like apple

# I like banana

# I like cherry

# 3 9 27 81 243

# First power of 3 >= 100: 243

Saída

I like apple
I like banana
I like cherry

3 9 27 81 243 
First power of 3 >= 100: 243

O laço for é perfeito para a lista de frutas: sabemos exatamente o que estamos percorrendo. O laço while é perfeito para as potências de 3: não sabemos de antemão quantas multiplicações serão necessárias para passar de 100.

Laço while (complexidade desnecessária)

names = ["Alice", "Bob", "Charlie"]
i = 0
while i < len(names):
    print(names[i])
    i += 1

Laço for (limpo e direto)

names = ["Alice", "Bob", "Charlie"]
for name in names:
    print(name)

Exercícios práticos

Agora é a sua vez de escrever laços while! Estes exercícios focam nos tipos de problema em que o while se destaca: número de repetições desconhecido, parada por condição e acumulação.

Lembre-se: um laço while precisa de algo que mude dentro dele. Se o seu laço roda para sempre, confira se você está atualizando a variável da condição.

Exercício 1: contagem regressiva

Escreva o código

Use um laço while para exibir uma contagem regressiva de 5 até 1, seguida de "Blastoff!" na última linha.

Saída esperada:

5
4
3
2
1
Blastoff!

# Create a countdown from 5 to 1, then print "Blastoff!"

Exercício 2: encontre a potência de 2

Escreva o código

Começando em 1, dobre um número até ele passar de 500. Exiba cada valor pelo caminho (incluindo o primeiro valor que passar de 500). Depois exiba o resultado final.

Saída esperada:

1
2
4
8
16
32
64
128
256
512
First power of 2 over 500: 512

Dica: use um laço while True com um break depois que o valor passar de 500.

value = 1

# Keep doubling and printing until value exceeds 500

Exercício 3: preveja a saída

Preveja a saída

Sem executar o código, preveja exatamente o que ele vai exibir. Acompanhe cada repetição com cuidado, prestando atenção em quando a condição é testada e quando x muda.

Depois execute o código para conferir sua resposta.

x = 10

while x > 1:

x = x // 2

print(x)

print("done")

Exercício 4: corrija o bug: contador de dígitos

Corrija o erro

Este código deveria contar quantos dígitos um número tem, dividindo-o por 10 repetidamente. Mas ele tem um bug: dá a resposta errada para o número 9999. Corrija o código para que ele exiba:

9999 has 4 digits

Não mude o número nem a instrução print final.

number = 9999

original = number

digits = 0

while number >= 10:

number = number // 10

digits += 1

print(f"{original} has {digits} digits")

Exercício 5: a sequência de Collatz

Escreva o código

A conjectura de Collatz é um problema famoso da matemática. Comece com qualquer número inteiro positivo. Se ele for par, divida por 2. Se for ímpar, multiplique por 3 e some 1. Repita até chegar a 1.

Começando com n = 6, exiba cada valor da sequência (incluindo o 6 e o 1) e depois exiba quantos passos foram necessários.

Saída esperada:

6
3
10
5
16
8
4
2
1
Steps: 8

n = 6

steps = 0

# Print n, then apply Collatz rules until n reaches 1

# Count each transformation as a step

Resumo: laços while em Python

Aqui está tudo o que você aprendeu sobre laços while:

Padrão	O que faz	Exemplo
`while condition:`	Repete até a condição ser False	`while count > 0:`
`while True:` + `break`	Repete para sempre, você sai manualmente	Laços de jogos, menus
Laço de contagem	Conta para cima ou para baixo até um alvo	`while count <= 10:`
Laço acumulador	Constrói um total ou resultado	`while total < 100:`
Laço de validação	Repete até a entrada ser válida	`while age <= 0:`

Regras principais para lembrar:

A condição do while é testada ANTES de cada repetição

Algo dentro do laço precisa, em algum momento, tornar a condição False

break sai do laço na hora

Use for quando você sabe o que vai percorrer

Use while quando precisa repetir até uma condição mudar

Sempre confira se o seu laço while consegue de fato terminar

O que vem a seguir?

Você já viu o break sendo usado para sair de um laço mais cedo. Mas existem mais duas instruções de controle de laço: continue (pula o resto da repetição atual) e pass (não faz nada). No próximo tutorial, break, continue e pass em Python, você vai dominar as três e aprender quando cada uma é a escolha certa.

Como funciona um laço while em Python?

Como contar e acumular com laços while?

O que são laços infinitos e como funciona o break?

Como validar a entrada com um laço while?

Quando usar while e quando usar for?

Exercícios práticos

Resumo: laços while em Python

O que vem a seguir?

Tutoriais relacionados