3 Laços de Repetição

Laços de repetição são estruturas fundamentais que nos permitem executar o mesmo bloco de código várias vezes. Em Python, os dois principais tipos de laços são o while e o for.

3.1 O Laço `while`

O laço while (enquanto) executa um bloco de código repetidamente enquanto uma condição especificada for verdadeira. É ideal para situações onde não sabemos de antemão quantas vezes o loop precisará ser executado.

Sintaxe:

while condicao:
    # Código a ser executado enquanto a condição for Verdadeira

Cuidado: É fundamental garantir que a condição do while possa se tornar falsa em algum momento. Caso contrário, o programa entrará em um laço infinito.

3.2 Exemplos Básicos de `while`

Contagem (contagem.py): Crie um programa que peça ao usuário um número inteiro e conte de 1 até esse número com um laço while, exibindo cada número em uma linha. Ao terminar, o programa exibe “Contagem concluída!”.

print("Contador")
numero_final = int(input("Digite um número inteiro para a contagem: "))
contador = 1
while contador <= numero_final:
    print(contador)
    contador = contador + 1
print("Contagem concluída!")

Exemplo de execução:

Contador
Digite um número inteiro para a contagem: 3
1
2
3
Contagem concluída!

A variável contador, que começa em 1, controla o laço. Antes de cada volta, o while testa a condição contador <= numero_final e, enquanto ela for verdadeira, executa o bloco indentado: exibe o contador e soma 1 a ele. Depois, volta para testar a condição de novo.

A linha 6 é o que faz o laço terminar. Com numero_final igual a 3, o contador vale 1, 2 e 3 nas três voltas e, depois da terceira, passa a valer 4; a condição fica falsa e o programa segue para a última linha. Sem a linha 6, o contador valeria 1 para sempre e o programa entraria em um laço infinito.

Validação de Senha (validador.py): Crie um programa que simule a tela de bloqueio de um dispositivo. O PIN correto, guardado na variável segredo, é "1234". O programa pede “Digite o PIN de 4 dígitos:” e, enquanto o PIN digitado estiver errado, exibe “PIN errado, tente novamente.” e pede de novo. Quando o usuário acerta, o programa exibe “Dispositivo Desbloqueado.”. Use a leitura antecipada, isto é, peça o PIN uma vez antes do laço e outra vez no fim de cada volta.

segredo = "1234"
pin = input("Digite o PIN de 4 dígitos: ")
while pin != segredo:
    print("PIN errado, tente novamente.")
    pin = input("Digite o PIN de 4 dígitos: ")
print("Dispositivo Desbloqueado.")

Exemplo de execução:

Digite o PIN de 4 dígitos: 1111
PIN errado, tente novamente.
Digite o PIN de 4 dígitos: 4321
PIN errado, tente novamente.
Digite o PIN de 4 dígitos: 1234
Dispositivo Desbloqueado.

O programa usa a leitura antecipada: o PIN é lido uma vez antes do laço, para que a condição pin != segredo tenha um valor para testar logo na primeira vez. O operador != significa “diferente de”. Enquanto o PIN estiver errado, o laço exibe o aviso e lê um novo PIN, que substitui o anterior e é testado na volta seguinte.

Se o usuário acertar logo na primeira tentativa, a condição já começa falsa e o corpo do laço nunca executa. Em qualquer caso, a mensagem final só aparece quando o PIN digitado é igual ao segredo.

3.3 Aplicações Práticas com `while`

Jogo de Adivinhação (adivinhacao.py): Crie um jogo em que o programa sorteia um número inteiro entre 1 e 100 e o jogador tenta adivinhar esse número. A cada palpite errado, o programa avisa “Muito baixo! Tente um número maior.” ou “Muito alto! Tente um número menor.” e pede outro palpite. Quando o jogador acerta, o programa exibe uma mensagem de parabéns com o número secreto. Considere que o usuário sempre digita um número inteiro válido.

from random import randint
numero_secreto = randint(1, 100)
print("--- Jogo de Adivinhação ---")
print("Tente adivinhar o número secreto entre 1 e 100.")
palpite = int(input("Digite seu palpite: "))
while palpite != numero_secreto:
    if palpite < numero_secreto:
        print("Muito baixo! Tente um número maior.")
    elif palpite > numero_secreto:
        print("Muito alto! Tente um número menor.")
    palpite = int(input("Digite seu palpite: "))
print(f"Parabéns! Você acertou! O número secreto era {numero_secreto}.")
print("Fim do jogo!")

Exemplo de execução:

--- Jogo de Adivinhação ---
Tente adivinhar o número secreto entre 1 e 100.
Digite seu palpite: 50
Muito alto! Tente um número menor.
Digite seu palpite: 25
Muito baixo! Tente um número maior.
Digite seu palpite: 37
Muito baixo! Tente um número maior.
Digite seu palpite: 42
Parabéns! Você acertou! O número secreto era 42.
Fim do jogo!

A linha 1 importa a função randint do módulo random, que faz parte do Python e reúne funções para gerar números aleatórios. Na linha 2, randint(1, 100) sorteia um inteiro entre 1 e 100, incluindo os dois extremos.

O laço segue o padrão de leitura antecipada do exemplo anterior: o primeiro palpite é lido antes do while, e cada novo palpite é lido no fim da volta. Dentro do laço, um if/elif compara o palpite com o número secreto para dar a dica. Quando o jogador acerta, a condição do while fica falsa e o programa revela o número. Como o sorteio muda a cada execução, o jogo é diferente toda vez.

Geração de Sequências (sequencia_fibonacci.py): Crie um programa que peça um número inteiro como limite e exiba, na mesma linha e separados por espaço, os números da sequência de Fibonacci menores ou iguais a esse limite. A sequência começa com 0 e 1, e cada número seguinte é a soma dos dois anteriores: 0, 1, 1, 2, 3, 5, …

limite = int(input("Digite um número limite para a sequência de Fibonacci: "))
a = 0
b = 1
print(f"Sequência de Fibonacci até {limite}:")
while a <= limite:
    print(a, end=" ")
    proximo_fibonacci = a + b
    a = b
    b = proximo_fibonacci
print()
print("Fim da sequência.")

Exemplo de execução:

Digite um número limite para a sequência de Fibonacci: 20
Sequência de Fibonacci até 20:
0 1 1 2 3 5 8 13 
Fim da sequência.

As variáveis a e b guardam, respectivamente, o número atual e o próximo da sequência. A cada volta, o programa exibe a e avança as duas variáveis uma posição: calcula o número seguinte, faz o próximo virar o atual e guarda o novo próximo. A variável proximo_fibonacci é necessária porque, depois da linha 8, o valor antigo de a já foi perdido. O laço termina quando o número atual passa do limite.

O argumento end=" " faz o print terminar com um espaço, em vez de pular para a próxima linha, por isso os números aparecem lado a lado. O print() vazio depois do laço encerra essa linha.

3.4 Controlando o Fluxo do Laço com `break` e `continue`

Às vezes, precisamos de mais controle sobre o comportamento de um loop.

break: Interrompe o loop imediatamente, e a execução do programa continua na linha seguinte ao loop.
continue: Pula para a próxima iteração do loop, ignorando todo o código restante no bloco da iteração atual.

Sintaxe do break:

while condicao_loop:
    # ... código ...
    if condicao_parada:
        break  # Interrompe o loop
    # ... mais código ...

Sintaxe do continue:

while condicao_loop:
    # ... código ...
    if condicao_pular:
        continue  # Pula para a próxima iteração
    # ... código que pode ser pulado ...

3.5 Exemplos de `break`

Validação de Entrada (perguntador.py): Crie um programa que pergunte “Podemos ir ao parque?” repetidamente até o usuário responder exatamente “sim”. Use um laço while True com break. Depois do laço, o programa exibe “Finalmente! Vamos lá.”.

while True:
    resposta = input("Podemos ir ao parque? ")
    if resposta == "sim":
        break
print("Finalmente! Vamos lá.")

Exemplo de execução:

Podemos ir ao parque? talvez
Podemos ir ao parque? agora não
Podemos ir ao parque? sim
Finalmente! Vamos lá.

A condição True é sempre verdadeira, então o while, sozinho, repetiria para sempre. A saída do laço fica a cargo do break: quando a resposta é exatamente sim, ele interrompe o laço imediatamente, e a execução continua na primeira linha depois dele. Para qualquer outra resposta, o if é ignorado e a pergunta é feita de novo.

Eco infinito (eco_infinito.py): Crie um programa que repita tudo o que o usuário digita, precedido de “Eco:”, até que ele digite “sair”. Nesse caso, o programa exibe “Entendido. Encerrando o programa…” e encerra o laço.

print("Bem-vindo ao 'Eco Infinito'!")
print("Digite algo para eu repetir. Digite 'sair' para terminar.")
while True:
    entrada = input("Sua vez: ")
    if entrada == "sair":
        print("Entendido. Encerrando o programa...")
        break
    print(f"Eco: {entrada}")
print("Fim do programa.")

Exemplo de execução:

Bem-vindo ao 'Eco Infinito'!
Digite algo para eu repetir. Digite 'sair' para terminar.
Sua vez: ola
Eco: ola
Sua vez: tudo bem?
Eco: tudo bem?
Sua vez: sair
Entendido. Encerrando o programa...
Fim do programa.

O laço é infinito, como no exemplo anterior, e lê um texto a cada volta. O teste de saída vem logo depois da leitura: quando o usuário digita sair, o programa exibe a despedida e o break encerra o laço antes que a palavra seja repetida no eco. Para qualquer outro texto, o bloco do if é pulado e a linha 8 exibe o eco.

Jogo com Tentativas Limitadas (jogo_palavra_secreta.py): Crie um jogo em que o jogador tem 3 tentativas para descobrir a palavra secreta “python”. A cada rodada, o programa pede um palpite identificado pelo número da tentativa. Se o jogador acertar, o jogo termina com “Parabéns, você acertou!”. Se as tentativas acabarem, o programa exibe “Você perdeu! Suas tentativas acabaram.” e revela a palavra.

palavra_secreta = "python"
max_tentativas = 3
jogador_ganhou = False
tentativas_feitas = 0
print("--- Jogo da Palavra Secreta ---")
print(f"Você tem {max_tentativas} tentativas para adivinhar a palavra.")
print("Dica: É uma linguagem de programação!")
while tentativas_feitas < max_tentativas:
    tentativa_num = tentativas_feitas + 1
    palpite = input(f"Tentativa {tentativa_num}: ")
    if palpite == palavra_secreta:
        jogador_ganhou = True
        break
    tentativas_feitas += 1
if jogador_ganhou:
    print("Parabéns, você acertou!")
else:
    print("Você perdeu! Suas tentativas acabaram.")
    print(f"A palavra secreta era '{palavra_secreta}'.")
print("Fim de jogo.")

Execução em que o jogador acerta:

--- Jogo da Palavra Secreta ---
Você tem 3 tentativas para adivinhar a palavra.
Dica: É uma linguagem de programação!
Tentativa 1: limão
Tentativa 2: python
Parabéns, você acertou!
Fim de jogo.

Execução em que as tentativas acabam:

--- Jogo da Palavra Secreta ---
Você tem 3 tentativas para adivinhar a palavra.
Dica: É uma linguagem de programação!
Tentativa 1: açaí
Tentativa 2: pitaia
Tentativa 3: manga
Você perdeu! Suas tentativas acabaram.
A palavra secreta era 'python'.
Fim de jogo.

O laço repete enquanto ainda houver tentativas e pode terminar de duas formas: pelo break, quando o jogador acerta, ou pela própria condição, quando as tentativas acabam. A variável jogador_ganhou funciona como uma sinalização (flag): ela começa como False e só muda para True no acerto. Depois do laço, o if consulta essa variável para saber qual dos dois casos aconteceu e exibir a mensagem certa.

A variável tentativas_feitas conta os erros. O operador +=, na linha 14, é uma forma curta de escrever tentativas_feitas = tentativas_feitas + 1. Como a contagem começa em 0, a linha 9 soma 1 para exibir o número da tentativa a partir de 1.

Menu Interativo (caixa_eletronico.py): Crie um programa que simule um caixa eletrônico com saldo inicial de R$ 1000,00. Em um laço, o programa oferece as opções “sacar”, “saldo” e “sair”.

Em “sacar”, o programa pede o valor. Se o valor for menor ou igual a zero, exibe “Valor inválido. Digite um valor positivo.”; se for maior que o saldo, exibe “Saldo insuficiente.”; nos demais casos, desconta o valor e mostra o saldo restante.
Em “saldo”, exibe o saldo atual.
Em “sair”, agradece e encerra.
Qualquer outra opção conta como tentativa inválida. Na terceira tentativa inválida, o programa exibe “Muitas tentativas inválidas. Encerrando.” e encerra.

saldo = 1000.00
tentativas_invalidas = 0
print("Bem-vindo ao Caixa Eletrônico")
print(f"Seu saldo atual é: R$ {saldo}")
while True:
    print("Opções: sacar, saldo, sair")
    escolha = input("Escolha uma opção: ")
    if escolha == "sacar":
        valor_saque = float(input("Digite o valor do saque: "))
        if valor_saque <= 0:
            print("Valor inválido. Digite um valor positivo.")
        elif valor_saque > saldo:
            print("Saldo insuficiente.")
        else:
            saldo -= valor_saque
            print(f"Saque de R$ {valor_saque} realizado com sucesso.")
            print(f"Saldo restante: R$ {saldo}")
    elif escolha == "saldo":
        print(f"Seu saldo atual é: R$ {saldo}")
    elif escolha == "sair":
        print("Obrigado por usar nosso caixa eletrônico. Volte sempre!")
        break
    else:
        print("Opção inválida. Tente novamente.")
        tentativas_invalidas += 1
        if tentativas_invalidas >= 3:
            print("Muitas tentativas inválidas. Encerrando.")
            break
print("Fim da operação.")

Exemplo de execução:

Bem-vindo ao Caixa Eletrônico
Seu saldo atual é: R$ 1000.0
Opções: sacar, saldo, sair
Escolha uma opção: saldo
Seu saldo atual é: R$ 1000.0
Opções: sacar, saldo, sair
Escolha uma opção: sacar
Digite o valor do saque: 1500
Saldo insuficiente.
Opções: sacar, saldo, sair
Escolha uma opção: sacar
Digite o valor do saque: 200
Saque de R$ 200.0 realizado com sucesso.
Saldo restante: R$ 800.0
Opções: sacar, saldo, sair
Escolha uma opção: sair
Obrigado por usar nosso caixa eletrônico. Volte sempre!
Fim da operação.

O while True mantém o menu na tela, e um if/elif/else trata cada opção escolhida. No saque, um if/elif/else aninhado recusa valores menores ou iguais a zero e valores maiores que o saldo; nos demais casos, a linha 15 desconta o valor com o operador -=, que equivale a saldo = saldo - valor_saque.

O laço tem duas saídas por break: a opção sair e a terceira opção inválida. As opções inválidas são contadas na variável tentativas_invalidas, e o if da linha 26 encerra o programa quando ela chega a 3.

3.6 Exemplos de `continue`

Maiores de Idade (maiores.py): Crie um programa que leia 5 idades (int) e exiba quantas delas são de maiores de idade, isto é, de 18 anos ou mais. Use continue para pular as idades menores que 18.

maiores = 0
lidas = 0
while lidas < 5:
    lidas = lidas + 1
    idade = int(input("Idade: "))
    if idade < 18:
        continue
    maiores = maiores + 1
print(f"Maiores de idade: {maiores}")

Exemplo de execução:

Idade: 15
Idade: 30
Idade: 17
Idade: 18
Idade: 42
Maiores de idade: 3

Quando a idade é menor que 18, o continue abandona a volta atual e o laço segue para a próxima idade, pulando a linha 8, que faz a contagem. Diferente do break, o continue não encerra o laço: ele apenas passa para a próxima volta.

O contador lidas aumenta no início da volta, antes do continue. Se o aumento ficasse no fim, a volta pulada nunca o executaria, e o programa ficaria preso na primeira idade menor que 18.

Leituras de Sensor (leituras_sensor.py): Crie um programa que leia 3 temperaturas (float) enviadas por um sensor e exiba a média das leituras válidas. O valor -999 indica falha na leitura: nesse caso, o programa exibe “Falha na leitura, ignorada.” e não usa o valor. Considere que pelo menos uma leitura é válida.

soma = 0
validas = 0
lidas = 0
while lidas < 3:
    lidas = lidas + 1
    leitura = float(input("Temperatura lida: "))
    if leitura == -999:
        print("Falha na leitura, ignorada.")
        continue
    soma = soma + leitura
    validas = validas + 1
print(f"Média das leituras válidas: {soma / validas}")

Exemplo de execução:

Temperatura lida: 20
Temperatura lida: -999
Falha na leitura, ignorada.
Temperatura lida: 24
Média das leituras válidas: 22.0

As variáveis soma e validas acumulam, respectivamente, a soma das temperaturas aceitas e a quantidade delas. Quando a leitura vale -999, o continue pula as linhas 10 e 11, e a leitura com falha não entra na soma nem na contagem.

A média divide a soma por validas, e não por 3, já que as leituras ignoradas não contam. No exemplo, a média é (20 + 24) / 2.

Cadastro de Alunos (cadastro_alunos.py): Crie um programa que processe 4 alunos, contando-os com um while. Para cada um, o programa pede o nome e a nota (float). Se o nome for vazio, exibe “Nome vazio, aluno ignorado.”; se a nota for menor que 0 ou maior que 10, exibe “Nota inválida, aluno ignorado.”. Nos demais casos, exibe “aprovado” para nota maior ou igual a 6 e “reprovado” para as outras. Ao final, exibe o total de aprovados.

aprovados = 0
alunos = 0
while alunos < 4:
    alunos = alunos + 1
    nome = input("Nome do aluno: ")
    if nome == "":
        print("Nome vazio, aluno ignorado.")
        continue
    nota = float(input("Nota (0 a 10): "))
    if nota < 0 or nota > 10:
        print("Nota inválida, aluno ignorado.")
        continue
    if nota >= 6:
        print(f"{nome}: aprovado")
        aprovados = aprovados + 1
    else:
        print(f"{nome}: reprovado")
print(f"Total de aprovados: {aprovados}")

Exemplo de execução:

Nome do aluno: Ana
Nota (0 a 10): 7.5
Ana: aprovado
Nome do aluno: 
Nome vazio, aluno ignorado.
Nome do aluno: Bruno
Nota (0 a 10): 11
Nota inválida, aluno ignorado.
Nome do aluno: Carla
Nota (0 a 10): 4
Carla: reprovado
Total de aprovados: 1

O laço tem duas verificações de entrada, nas linhas 6 e 10, e cada uma usa o continue para descartar o aluno com dado inválido. No exemplo, o nome vazio faz o programa pular a leitura da nota, porque a volta termina antes dela.

Só os alunos que passam pelas duas verificações chegam ao if/else das linhas 13 a 17, que decide entre aprovado e reprovado e conta os aprovados. Sem o continue, esse if/else teria de ficar dentro de outros dois blocos else, um para cada verificação.

Gastos (gastos.py): Crie um programa que some gastos digitados pelo usuário em um laço while True. A cada entrada, o usuário digita um valor (float), aperta Enter sem digitar nada, caso em que a entrada é ignorada, ou digita “fim”. Para cada valor, o programa exibe o total até o momento; com “fim”, exibe o total gasto e encerra.

total = 0
while True:
    entrada = input("Gasto (Enter para ignorar, 'fim' para sair): ")
    if entrada == "fim":
        break
    if entrada == "":
        continue
    total = total + float(entrada)
    print(f"Total até agora: R$ {total}")
print(f"Total gasto: R$ {total}")

Exemplo de execução:

Gasto (Enter para ignorar, 'fim' para sair): 25.5
Total até agora: R$ 25.5
Gasto (Enter para ignorar, 'fim' para sair): 
Gasto (Enter para ignorar, 'fim' para sair): 10
Total até agora: R$ 35.5
Gasto (Enter para ignorar, 'fim' para sair): fim
Total gasto: R$ 35.5

O programa usa os dois comandos juntos: o break da linha 5 encerra o laço, e o continue da linha 7 apenas descarta a entrada vazia. Esse continue vem antes da conversão com float(), porque um texto vazio não pode ser convertido em número e o programa pararia com um erro.

Empréstimo (emprestimo.py): Crie um programa que simule a análise de crédito de exatamente 3 clientes. Para cada cliente, o programa pede o salário (float), o valor do empréstimo (float) e o número de parcelas (int), aplicando as regras abaixo na ordem.

Se o salário for menor ou igual a zero, exibe “Salário inválido.” e passa ao próximo cliente.
Se o empréstimo for maior que 6 vezes o salário, recusa o pedido.
Se a prestação (empréstimo dividido pelo número de parcelas) passar de 30% do salário, recusa o pedido.
Se todas as verificações passarem, exibe “Aprovado!” e soma o valor ao total concedido.

Um pedido recusado não entra no total. Ao final, o programa exibe o total concedido.

total = 0
contador = 0
while contador < 3:
    contador = contador + 1
    salario = float(input("Salário: "))
    if salario <= 0:
        print("Salário inválido.")
        continue
    valor = float(input("Empréstimo: "))
    if valor > 6 * salario:
        print("Recusado: valor alto demais.")
        continue
    parcelas = int(input("Parcelas: "))
    if valor / parcelas > 0.3 * salario:
        print("Recusado: prestação alta demais.")
        continue
    print("Aprovado!")
    total = total + valor
print(f"Total concedido: R$ {total}")

Exemplo de execução:

Salário: 0
Salário inválido.
Salário: 2000
Empréstimo: 10000
Parcelas: 3
Recusado: prestação alta demais.
Salário: 3000
Empréstimo: 3000
Parcelas: 12
Aprovado!
Total concedido: R$ 3000.0

Cada cliente passa por três verificações, nas linhas 6, 10 e 14. Quando uma delas falha, o continue encerra a análise daquele cliente e o laço passa ao próximo. Por isso, o código da aprovação, no fim do laço, só executa para quem passou em todas as verificações, e só esses empréstimos são somados ao total. Repare também que cada pergunta só é feita quando necessária: com salário inválido, o programa nem pede o valor do empréstimo.

Versão Sem continue (emprestimo_sem_continue.py): Resolva o mesmo problema do exemplo anterior sem usar continue.

total = 0
contador = 0
while contador < 3:
    contador = contador + 1
    salario = float(input("Salário: "))
    if salario <= 0:
        print("Salário inválido.")
    else:
        valor = float(input("Empréstimo: "))
        if valor > 6 * salario:
            print("Recusado: valor alto demais.")
        else:
            parcelas = int(input("Parcelas: "))
            if valor / parcelas > 0.3 * salario:
                print("Recusado: prestação alta demais.")
            else:
                print("Aprovado!")
                total = total + valor
print(f"Total concedido: R$ {total}")

Exemplo de execução:

Salário: 0
Salário inválido.
Salário: 2000
Empréstimo: 10000
Parcelas: 3
Recusado: prestação alta demais.
Salário: 3000
Empréstimo: 3000
Parcelas: 12
Aprovado!
Total concedido: R$ 3000.0

Esta versão faz as mesmas verificações, mas sem continue. Para que o programa não siga adiante quando uma verificação falha, todo o restante da análise precisa ficar dentro do else da verificação anterior. Com isso, o código da aprovação, nas linhas 17 e 18, acaba três níveis de recuo mais à direita que na versão com continue.

Esse formato é chamado de “código seta”, por causa do desenho que a indentação forma. Compare as duas versões: na que usa continue, todas as regras ficam no mesmo nível, e o código é mais fácil de ler e de modificar.

3.7 Listas e o Laço `for`

Antes de falarmos sobre repetição, precisamos conhecer as Listas. Uma lista é uma estrutura de dados que permite armazenar múltiplos itens em uma única variável. Em Python, criamos listas usando colchetes [].

O laço for é a ferramenta perfeita para iterar (percorrer) cada item de uma lista.

Inventário de Itens (lista_itens.py): Crie um programa que guarde em uma lista itens os elementos “Espada”, “Escudo”, “Poção” e “Mapa” e, depois da mensagem “Itens no inventário:”, exiba cada item precedido de “-”.

itens = ["Espada", "Escudo", "Poção", "Mapa"]
print("Itens no inventário:")
for item in itens:
    print(f"- {item}")

Exemplo de execução:

Itens no inventário:
- Espada
- Escudo
- Poção
- Mapa

A lista é criada com colchetes, com os itens separados por vírgulas, e guarda vários valores em uma única variável. O for percorre a lista do primeiro ao último elemento: a cada volta, a variável item recebe o próximo elemento, e o print exibe esse elemento com um traço na frente. Quando os elementos acabam, o laço termina sozinho, sem precisar de contador nem de condição.

3.8 Adicionando Elementos a uma Lista

Podemos começar com uma lista vazia e adicionar elementos a ela usando o comando .append(). O laço for funciona da mesma maneira, percorrendo a lista não importa como ela foi construída.

Lista de Compras (lista_compras.py): Crie um programa que comece com uma lista vazia materiais, adicione a ela “multimetro”, “sensor de temperatura” e “cabos de medicao” com append e, em seguida, exiba cada material em uma linha.

materiais = []
print("Adicionando materiais para a bancada de teste...")
materiais.append("multimetro")
materiais.append("sensor de temperatura")
materiais.append("cabos de medicao")
print("Lista final de materiais:")
for material in materiais:
    print(f"Material necessario: {material}")

Exemplo de execução:

Adicionando materiais para a bancada de teste...
Lista final de materiais:
Material necessario: multimetro
Material necessario: sensor de temperatura
Material necessario: cabos de medicao

A lista começa vazia, com [], e cresce a cada .append(), que acrescenta um item no final sem apagar os anteriores. Depois das três chamadas, a lista contém os materiais na ordem em que foram adicionados. O for percorre essa lista da mesma forma que no exemplo anterior: o laço não depende de como a lista foi construída, apenas dos elementos que ela tem.

3.9 Iterando com `range()`

Além de listas, o for é muito usado com a função range(), que gera uma sequência matemática de números. É útil quando queremos repetir uma ação um número específico de vezes, sem precisar criar uma lista manualmente.

range(5): Gera números de 0 a 4.
range(1, 6): Gera números de 1 a 5.
range(0, 11, 2): Gera números de 0 a 10, pulando de 2 em 2.

Exemplos:

Repetição Simples (repetidor.py): Crie um programa que use for com range() para repetir 5 vezes a mensagem “Iteração número X”, em que X é o número da repetição atual, começando de 0.

for i in range(5):
    print(f"Iteração número {i}")

Exemplo de execução:

Iteração número 0
Iteração número 1
Iteração número 2
Iteração número 3
Iteração número 4

A função range(5) gera a sequência de números de 0 a 4. O 5 não entra na sequência, mas ela tem exatamente 5 números, por isso o laço repete 5 vezes. A cada volta, a variável i recebe o próximo número, que aparece na mensagem.

Acumulando Valores (acumulador.py): Crie um programa que some os números de 1 a 5 com um laço for. A cada volta, o programa exibe o número somado e o total parcial; ao final, exibe a soma final.

total = 0
for numero in range(1, 6):
    total = total + numero
    print(f"Adicionei {numero}, Total agora é {total}")
print(f"Soma Final: {total}")

Exemplo de execução:

Adicionei 1, Total agora é 1
Adicionei 2, Total agora é 3
Adicionei 3, Total agora é 6
Adicionei 4, Total agora é 10
Adicionei 5, Total agora é 15
Soma Final: 15

A variável total é um acumulador: ela começa em 0, antes do laço, e a cada volta recebe o valor que já tinha somado ao número atual. Como o segundo argumento do range(1, 6) não entra na sequência, o laço soma os números de 1 a 5, e o total passa por 1, 3, 6, 10 e 15. A soma final é exibida depois do laço, fora do bloco indentado.

Contagem com Passos (pulador.py): Crie um programa que exiba “Apenas números pares:” e, em seguida, os números pares de 0 a 10, usando o terceiro argumento do range().

print("Apenas números pares:")
for i in range(0, 11, 2):
    print(i)

Exemplo de execução:

Apenas números pares:
0
2
4
6
8
10

O range() aceita um terceiro argumento, o passo, que indica quanto o número aumenta de uma volta para a outra. Com range(0, 11, 2), a sequência começa em 0, avança de 2 em 2 e para antes de 11, o que gera 0, 2, 4, 6, 8 e 10. O fim é 11, e não 10, para que o 10 seja incluído.

Contagem Regressiva (contagem_regressiva.py): Crie um programa que exiba “Preparando para o lançamento…”, faça uma contagem regressiva de 10 até 1 com for e range() e, ao final, exiba “Fogo!”.

print("Preparando para o lançamento...")
for i in range(10, 0, -1):
    print(i)
print("Fogo!")

Exemplo de execução:

Preparando para o lançamento...
10
9
8
7
6
5
4
3
2
1
Fogo!

Com passo negativo, o range() conta para trás. O range(10, 0, -1) começa em 10, diminui de 1 em 1 e para antes de chegar a 0, por isso o último número exibido é 1. A mensagem Fogo! aparece depois do laço.

Média de N Números (media_numeros.py): Crie um programa que pergunte quantos números inteiros o usuário vai digitar, leia esses números com for e range() e exiba a média aritmética deles. Se a quantidade não for positiva, o programa exibe “Quantidade inválida.”.

quantidade = int(input("Quantos números você vai inserir? "))
soma = 0
for i in range(quantidade):
    numero = int(input(f"Digite o {i+1} número: "))
    soma += numero
if quantidade > 0:
    media = soma / quantidade
    print(f"A média dos {quantidade} números é: {media}")
else:
    print("Quantidade inválida.")

Exemplo de execução:

Quantos números você vai inserir? 3
Digite o 1 número: 7
Digite o 2 número: 8
Digite o 3 número: 9
A média dos 3 números é: 8.0

A quantidade digitada define quantas vezes o laço repete, e cada volta lê um número e soma esse valor ao acumulador. A pergunta usa {i+1} porque i começa em 0, e a contagem fica mais natural a partir de 1.

Depois do laço, o if evita a divisão por zero. Se o usuário informar a quantidade 0, o laço não executa nenhuma vez, e a divisão soma / quantidade causaria um erro; nesse caso, o programa exibe Quantidade inválida.

3.10 Iterando sobre Strings

O laço for também pode tratar um texto (String) como se fosse uma “lista de caracteres”. Ele percorre o texto letra por letra.

Contador de Vogais (conta_vogais.py): Crie um programa que peça uma frase, exiba cada vogal minúscula encontrada nela e, ao final, informe quantas vogais a frase contém. Use continue para pular as letras que não são vogais.

frase = input("Digite uma frase para contar as vogais: ")
contador_vogais = 0
print("Analisando a frase...")
for letra in frase:
    if letra != "a" and letra != "e" and letra != "i" and letra != "o" and letra != "u":
        continue
    print(f"Vogal encontrada: {letra}")
    contador_vogais = contador_vogais + 1
print()
print(f"A frase contém {contador_vogais} vogais.")
print("Fim do programa.")

Exemplo de execução:

Digite uma frase para contar as vogais: Ana gosta de python
Analisando a frase...
Vogal encontrada: a
Vogal encontrada: o
Vogal encontrada: a
Vogal encontrada: e
Vogal encontrada: o

A frase contém 5 vogais.
Fim do programa.

O for percorre a frase caractere por caractere, incluindo espaços e pontuação. O if funciona como uma guarda: ele junta com and as comparações com as cinco vogais e, quando a letra é diferente de todas elas, o continue passa para a próxima letra. Assim, só as vogais chegam às linhas que exibem a vogal e aumentam o contador.

A comparação usa apenas letras minúsculas, então vogais maiúsculas, como o A de Ana, não entram na contagem.

Limpador de Texto (limpador_de_texto.py): Crie um programa que remova as pontuações ,.!?- do texto “Sensor-3, pressao alta! Reavaliar? Sim.”. O programa percorre o texto caractere por caractere, avisa cada pontuação removida e, ao final, exibe o texto original e o texto limpo.

texto_original = "Sensor-3, pressao alta! Reavaliar? Sim."
pontuacao = ",.!?-"
texto_limpo = ""
print(f"Texto original: {texto_original}")
print("Limpando o texto...")
for caractere in texto_original:
    if caractere in pontuacao:
        print(f"Pontuacao '{caractere}' removida.")
        continue
    texto_limpo = texto_limpo + caractere
print(f"Texto limpo: {texto_limpo}")

Exemplo de execução:

Texto original: Sensor-3, pressao alta! Reavaliar? Sim.
Limpando o texto...
Pontuacao '-' removida.
Pontuacao ',' removida.
Pontuacao '!' removida.
Pontuacao '?' removida.
Pontuacao '.' removida.
Texto limpo: Sensor3 pressao alta Reavaliar Sim

O operador in, na linha 7, verifica se um valor existe dentro de uma sequência, como uma string ou uma lista. Aqui, ele testa se o caractere atual aparece na string pontuacao. Quando aparece, o programa avisa a remoção e o continue pula para o próximo caractere.

Os demais caracteres são acrescentados, um a um, à variável texto_limpo, que começa vazia. Entre textos, o operador + junta os dois lados. No final, o programa exibe Sensor3 pressao alta Reavaliar Sim.

3.1 O Laço while

3.2 Exemplos Básicos de while

3.3 Aplicações Práticas com while

3.4 Controlando o Fluxo do Laço com break e continue

3.5 Exemplos de break

3.6 Exemplos de continue

3.7 Listas e o Laço for

3.8 Adicionando Elementos a uma Lista

3.9 Iterando com range()

3.10 Iterando sobre Strings

3.1 O Laço `while`

3.2 Exemplos Básicos de `while`

3.3 Aplicações Práticas com `while`

3.4 Controlando o Fluxo do Laço com `break` e `continue`

3.5 Exemplos de `break`

3.6 Exemplos de `continue`

3.7 Listas e o Laço `for`

3.9 Iterando com `range()`