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

URL: https://skillaria.top/pt/guides/python/lacos-python-for-while

Laços em Python repetem ações: for percorre os elementos de qualquer coleção ou do intervalo range(), e while executa enquanto a condição for verdadeira. Para interromper um laço use break, para pular uma iteração — continue, e enumerate() fornece o número do elemento. As decisões são tomadas por if/elif/else, e a análise de dados por forma é feita pelo operador match/case (desde o Python 3.10).

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.

| Chamada | Números |
| --- | --- |

| `range(5)` | 0, 1, 2, 3, 4 |

| `range(2, 6)` | 2, 3, 4, 5 |

| `range(0, 10, 3)` | 0, 3, 6, 9 |

| `range(5, 0, -1)` | 5, 4, 3, 2, 1 |

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  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.

## FAQ

**Qual é a diferença entre for e while em Python?**

O for percorre uma sequência pronta e sabe sozinho quando parar, enquanto o while se repete enquanto a condição for verdadeira. Se o número de repetições é conhecido ou há uma coleção, use for; se você aguarda um evento, use while.

**Como percorrer um laço na ordem inversa?**

Use reversed(items) para uma coleção ou range(n - 1, -1, -1) para números. A função reversed não copia a lista, apenas a percorre do fim.

**Existe switch em Python?**

Não há um switch separado; seu papel é desempenhado pela cadeia if/elif e pelo operador match/case, surgido no Python 3.10. O match faz mais: desmonta listas e dicionários pela forma e captura valores.

**O que é mais rápido — um laço ou uma list comprehension?**

A comprehension do tipo [x * 2 for x in items] costuma ser um pouco mais rápida que o laço equivalente com append e é mais curta. Para lógica complexa com várias condições, o laço comum é mais legível.

**Como sair de dois laços aninhados de uma vez?**

O break interrompe apenas o laço interno. A forma mais simples é colocar os laços numa função e sair com return.


---
Source: Skillaria.Top (https://skillaria.top)