Laços e condições em Python: for, while, range, enumerate, break, if/elif e match/case

Os laços em Python servem para repetir uma ação: percorrer uma lista de compras, processar cada linha de um arquivo, pedir ao usuário um número válido até que ele o digite. A linguagem tem dois laços — for e while — e, para tomar decisões dentro deles, as condições if/elif/else e o operador match/case. Vamos examinar cada ferramenta com exemplos práticos.

Condições: if, elif, else

O comando condicional executa um bloco de código somente se a expressão for verdadeira. O bloco é marcado por um recuo de 4 espaços — não existem chaves em Python, e um recuo errado gera imediatamente o erro IndentationError.

spent = 4200
limit = 5000

if spent > limit:
    print("Limite excedido")
elif spent > limit * 0.8:
    print("Resta menos de 20% do orçamento")
else:
    print("Tudo certo")

Os ramos elif são verificados de cima para baixo, e apenas o primeiro que se encaixar é executado. Por isso, coloque as condições mais rigorosas no topo: se a verificação spent > limit * 0.8 estivesse em primeiro lugar, a mensagem sobre o limite excedido nunca apareceria.

O que é considerado verdadeiro

Na condição nem sempre é preciso escrever uma comparação. São falsos False, None, zero (0, 0.0) e coleções vazias: "", [], {}. Todo o resto é verdadeiro. Por isso, a verificação «a lista não está vazia» é escrita de forma curta:

expenses = []
if not expenses:
    print("Ainda não há gastos")

As condições se combinam com and, or, not, e um intervalo é cómodo de verificar com uma cadeia de comparações: if 0 < amount <= 100_000:. Para uma escolha curta de valor existe o operador ternário: status = "alto" if spent > limit else "normal".

Laço for em Python: sintaxe e exemplos

O for em Python não é um contador, como em C, mas sim uma iteração sobre elementos. Ele pega, um a um, cada elemento de um objeto iterável: lista, string, dicionário, arquivo, intervalo. O análogo do foreach de outras linguagens é justamente o for comum.

expenses = [350, 1200, 89, 4500]
total = 0
for amount in expenses:
    total += amount
print(total)  # 6139

Sintaxe do laço for: for variável in coleção:, seguido de um bloco com recuo. A variável guarda o último valor depois do laço — às vezes isso é útil, mas em programas grandes não convém depender disso.

Laço por string, lista e dicionário

A string é percorrida caractere a caractere, a lista — elemento a elemento. O laço por dicionário percorre, por padrão, as chaves; para obter chave e valor ao mesmo tempo, use .items():

by_category = {"alimentação": 3200, "transporte": 900, "cinema": 600}

for category, amount in by_category.items():
    print(f"{category}: R$ {amount}")

Para percorrer apenas os valores, há .values(). Alterar o tamanho de um dicionário durante a iteração não é permitido — você receberá RuntimeError: dictionary changed size during iteration. Se for preciso remover elementos, percorra uma cópia: for key in list(d):.

Função range: laço por números

Quando é preciso percorrer números, entra em cena o range(). Ele não cria uma lista na memória, mas entrega os números um a um, por isso range(10**9) funciona instantaneamente.

Regra principal: o limite da direita não entra no intervalo. range(1, 10) termina no 9 — esta é uma causa frequente do erro «de um». O passo pode ser negativo, mas não pode ser zero.

for i in range(1, 4):
    print(f"Dia {i}")
# Dia 1
# Dia 2
# Dia 3

enumerate: contador no laço

Iniciantes costumam escrever for i in range(len(items)) para saber o número do elemento. Isso funciona, mas é menos legível. A função enumerate() devolve pares «número, elemento», e o parâmetro start define a partir de qual número contar:

items = ["café", "táxi", "almoço"]
for n, item in enumerate(items, start=1):
    print(n, item)
# 1 café
# 2 táxi
# 3 almoço

Para percorrer em paralelo duas listas existe o zip(): for name, price in zip(names, prices):. Ele para na menor das listas; a partir do Python 3.10 é possível passar strict=True, e então tamanhos diferentes geram um erro.

Laço while em Python

O while repete o bloco enquanto a condição for verdadeira. Ele é escolhido quando o número de repetições não é conhecido de antemão: aguardar uma entrada correta, ler dados até o fim, repetir uma requisição até dar certo.

balance = 10_000
month = 0
while balance > 0:
    balance -= 2_700
    month += 1
print(f"O dinheiro dura {month} meses")  # 4

O principal perigo é esquecer de alterar a variável da condição. Assim o laço nunca termina. Se o programa «travou», pressione Ctrl+C: o Python interrompe a execução com KeyboardInterrupt.

Laço infinito e do while

Às vezes o laço infinito em Python é escrito de propósito: while True: com saída por break. Assim também se faz o laço com pós-condição — em Python não existe a construção do while, e seu lugar é ocupado por este recurso: o corpo é executado pelo menos uma vez, e a verificação fica no fim.

while True:
    raw = input("Valor: ")
    if raw.isdigit():
        amount = int(raw)
        break
    print("Digite um número inteiro")

O laço for raramente é infinito — apenas se percorrer um iterador sem fim, como itertools.count().

break e continue: saída do laço e pulo de iteração

break interrompe o laço imediatamente, e a execução segue para o código depois dele. continue pula o restante da iteração atual e passa para a próxima.

expenses = [350, -10, 1200, 0, 99_999, 89]

for amount in expenses:
    if amount <= 0:
        continue          # pular esta iteração
    if amount > 50_000:
        print("Valor suspeito, parar")
        break             # sair do laço
    print(amount)

Serão impressos 350 e 1200, e depois a mensagem — o laço não chega até o 89. Os dois comandos atuam apenas sobre o laço mais próximo em que se encontram.

else no laço

O for e o while têm um ramo else incomum: ele é executado se o laço terminou sozinho, sem break. É cômodo para buscas:

for amount in expenses:
    if amount > 50_000:
        print("Encontramos um gasto grande")
        break
else:
    print("Não há gastos grandes")

Laços aninhados

Um laço dentro de outro executa o interno por completo a cada iteração do externo. Assim se percorrem tabelas, matrizes e pares de valores.

for row in range(1, 4):
    for col in range(1, 4):
        print(row * col, end="\t")
    print()

Atenção a dois pontos. Primeiro, a complexidade cresce rápido: dois laços aninhados sobre 10 000 elementos dão 100 milhões de operações. Segundo, o break sai apenas do laço interno. Para interromper ambos, mova os laços para uma função e use return — fica mais limpo do que usar flags.

Operador match/case

Uma longa cadeia if cmd == ... elif ... pode ser substituída, a partir do Python 3.10, pelo operador match (PEP 634). Não se trata apenas de um switch: ele compara o valor com um padrão pela forma dos dados e já separa as partes em variáveis.

def parse(text):
    match text.split():
        case ["add", item, amount]:
            return f"Adicionar {item}: {amount}"
        case ["list"] | ["ls"]:
            return "Mostrar gastos"
        case ["quit"]:
            return "Sair"
        case _:
            return "Comando desconhecido"

print(parse("add Café 250"))  # Adicionar Café: 250
print(parse("add Café"))      # Comando desconhecido

O padrão-lista ["add", item, amount] só combina com uma lista de exatamente três elementos, cujo primeiro é "add". Por isso, um comando sem valor cai no ramo _, que captura todo o restante. O símbolo | reúne variantes.

Dicionários, tipos e condição-guarda

Um padrão-dicionário verifica apenas as chaves listadas, e as extras são ignoradas. A notação int(a) verifica o tipo e captura o valor, e um if depois do padrão acrescenta uma condição adicional (guard):

match event:
    case {"type": "expense", "amount": int(a)} if a > 10_000:
        print("Gasto grande", a)
    case {"type": "expense", "amount": int(a)}:
        print("Gasto", a)

A principal armadilha do match

Um nome solto no case é uma captura, e não uma comparação com uma variável. case limit: combina com qualquer valor e o grava em limit. Para comparar com constantes é preciso usar um nome com ponto, por exemplo case Color.RED:, ou literais.

A sintaxe do match desde a 3.10 quase não mudou. No Python 3.15 foi eliminada uma pequena assimetria: nos padrões literais antes só era permitido o sinal de menos antes de um número, agora também se pode escrever case +1:. Em versões mais antigas esse código dará erro de sintaxe.

Erros típicos em laços

• Alterar a lista durante a iteração. Remover elementos dentro do for pula os vizinhos. É melhor montar uma nova lista: clean = [x for x in items if x > 0].
• Limite do range. range(1, n) não inclui o n.
• Esquecer de alterar a condição do while — laço infinito.
• Concatenar strings com += dentro de um laço em grandes volumes é mais lento do que "".join(parts).
• Atribuição no lugar de comparação: if x = 5 é erro de sintaxe; a comparação se escreve com ==.

Exercícios com laços para praticar

1. Calcule a soma e a média de uma lista de gastos, ignorando os valores negativos.
2. Exiba a tabuada de 1 a 9 com laços aninhados.
3. Peça números ao usuário até que ele digite uma linha vazia e depois mostre o máximo.
4. Encontre o primeiro número maior que 1000 em uma lista e informe, caso não exista, usando for ... else.
5. Processe os comandos add, del e list com match.

Resumo

Os laços em Python se reduzem a duas construções: o for percorre os elementos de uma coleção ou de um range(), e o while funciona enquanto a condição for verdadeira. O break e o continue controlam o andamento do laço, enumerate() e zip() dispensam contadores manuais, e if/elif/else com match/case cuidam das decisões. Todas essas ferramentas são praticadas com o controle de gastos na aula do curso de Python.