---
title: "Loop: O que É e Como Funciona | Python Brasil"
url: "https://python.dev.br/glossario/loop/"
markdown_url: "https://python.dev.br/glossario/loop.MD"
description: "Domine loops em Python: for, while, break, continue, else, enumerate, zip e boas praticas para criar iteracoes eficientes e legiveis."
date: "2025-08-12"
author: ""
---

# Loop: O que É e Como Funciona | Python Brasil

Domine loops em Python: for, while, break, continue, else, enumerate, zip e boas praticas para criar iteracoes eficientes e legiveis.


## O que e um Loop?

Um **loop** (laco de repeticao) em Python e uma estrutura de controle que executa um bloco de codigo repetidamente enquanto uma condicao for verdadeira ou enquanto houver elementos em um iteravel. Python oferece duas estruturas de loop: `for` e `while`. O loop `for` e mais utilizado porque itera diretamente sobre elementos de uma sequencia, sem necessidade de gerenciar indices manualmente.

## Loop for

O `for` em Python itera sobre qualquer objeto **iteravel** — listas, tuplas, strings, dicionarios, conjuntos, arquivos, ranges e generators.

```python
# Iterando sobre uma lista
frutas = ['maca', 'banana', 'laranja']
for fruta in frutas:
    print(f'Eu gosto de {fruta}')

# Iterando sobre uma string
for letra in 'Python':
    print(letra, end=' ')  # P y t h o n

# Usando range
for i in range(5):
    print(i)  # 0, 1, 2, 3, 4

for i in range(2, 10, 3):
    print(i)  # 2, 5, 8

# Iterando sobre dicionario
config = {'host': 'localhost', 'porta': 8080, 'debug': True}

for chave in config:
    print(chave)

for chave, valor in config.items():
    print(f'{chave}: {valor}')

for valor in config.values():
    print(valor)
```

## Loop while

O `while` executa enquanto uma condicao for verdadeira. E ideal quando nao se sabe antecipadamente quantas iteracoes serao necessarias.

```python
# Loop while basico
contador = 0
while contador < 5:
    print(contador)
    contador += 1

# Leitura de entrada do usuario
while True:
    resposta = input('Digite "sair" para encerrar: ')
    if resposta.lower() == 'sair':
        break
    print(f'Voce digitou: {resposta}')

# While com condicao composta
tentativas = 0
max_tentativas = 3
autenticado = False

while tentativas < max_tentativas and not autenticado:
    senha = input('Senha: ')
    if senha == 'python123':
        autenticado = True
    else:
        tentativas += 1
        print(f'Tentativa {tentativas} de {max_tentativas}')
```

## break, continue e else

```python
# break — interrompe o loop completamente
for numero in range(100):
    if numero > 5:
        break
    print(numero)  # 0, 1, 2, 3, 4, 5

# continue — pula para a proxima iteracao
for i in range(10):
    if i % 2 == 0:
        continue
    print(i)  # 1, 3, 5, 7, 9

# else em loops — executa quando o loop termina sem break
def buscar_primo(limite):
    for n in range(2, limite):
        for divisor in range(2, int(n ** 0.5) + 1):
            if n % divisor == 0:
                break
        else:
            # Executado se o for interno NAO teve break
            print(f'{n} e primo')

buscar_primo(20)
```

## Funcoes Auxiliares para Loops

```python
# enumerate — itera com indice
nomes = ['Ana', 'Bruno', 'Carla']
for i, nome in enumerate(nomes):
    print(f'{i + 1}. {nome}')

for i, nome in enumerate(nomes, start=1):
    print(f'{i}. {nome}')

# zip — itera sobre multiplos iteraveis em paralelo
alunos = ['Ana', 'Bruno', 'Carla']
notas = [9.5, 7.8, 8.3]
for aluno, nota in zip(alunos, notas):
    print(f'{aluno}: {nota}')

# zip com tres ou mais iteraveis
materias = ['Matematica', 'Portugues', 'Ciencias']
for aluno, nota, materia in zip(alunos, notas, materias):
    print(f'{aluno} tirou {nota} em {materia}')

# reversed — itera em ordem inversa
for fruta in reversed(frutas):
    print(fruta)

# sorted — itera em ordem classificada
numeros = [3, 1, 4, 1, 5, 9]
for n in sorted(numeros):
    print(n)
```

## Loops Aninhados

```python
# Matriz (lista de listas)
matriz = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9],
]

for linha in matriz:
    for elemento in linha:
        print(elemento, end=' ')
    print()  # nova linha

# Produto cartesiano
cores = ['vermelho', 'azul']
tamanhos = ['P', 'M', 'G']
for cor in cores:
    for tamanho in tamanhos:
        print(f'{cor}-{tamanho}')

# Alternativa com itertools.product
from itertools import product
for cor, tamanho in product(cores, tamanhos):
    print(f'{cor}-{tamanho}')
```

## Comprehensions como Alternativa

Para loops simples que constroem colecoes, comprehensions sao mais concisas e geralmente mais rapidas.

```python
# Em vez de:
quadrados = []
for x in range(10):
    quadrados.append(x ** 2)

# Use:
quadrados = [x ** 2 for x in range(10)]

# Dict comprehension
nomes = ['ana', 'bruno', 'carla']
comprimentos = {nome: len(nome) for nome in nomes}

# Set comprehension
unicos = {len(nome) for nome in nomes}

# Generator expression (para iteracao preguicosa)
soma = sum(x ** 2 for x in range(1000000))
```

## Padroes Comuns com itertools

```python
from itertools import chain, groupby, islice, count

# chain — concatena iteraveis
for item in chain([1, 2], [3, 4], [5, 6]):
    print(item)

# islice — fatia iteradores
for valor in islice(count(10), 5):
    print(valor)  # 10, 11, 12, 13, 14

# groupby — agrupa elementos consecutivos
dados = [('fruta', 'maca'), ('fruta', 'banana'), ('vegetal', 'cenoura')]
dados.sort(key=lambda x: x[0])
for tipo, grupo in groupby(dados, key=lambda x: x[0]):
    print(f'{tipo}: {[item[1] for item in grupo]}')
```

## Erros Comuns

O erro mais perigoso e criar um loop infinito acidental com `while`, esquecendo de atualizar a variavel de controle. Outro erro frequente e modificar uma lista durante a iteracao com `for`, o que pode pular elementos ou gerar resultados inesperados — prefira iterar sobre uma copia ou usar list comprehension para filtrar. Tambem e comum usar `range(len(lista))` quando `enumerate()` seria mais Pythonico e menos propenso a erros de indice.

## Boas Praticas

Prefira `for` sobre `while` sempre que possivel, pois o `for` e menos propenso a loops infinitos. Use `enumerate` em vez de indices manuais. Use `zip` para iterar sobre multiplas sequencias. Considere comprehensions para loops simples. Para loops muito complexos, extraia a logica para funcoes. Evite loops desnecessarios — funcoes como `sum()`, `any()`, `all()`, `min()` e `max()` podem substituir loops inteiros.

## Quando Usar

Loops sao essenciais em qualquer programa que precise processar colecoes de dados, repetir acoes ate uma condicao ser atendida, ou percorrer estruturas de dados. Escolha `for` quando souber o iteravel antecipadamente e `while` quando a condicao de parada depender de logica dinamica.