Como usar a função enumerate em Python

A função enumerate é uma das formas mais simples e idiomáticas de obter, ao mesmo tempo, o item de um iterável e a sua posição durante um laço for . Ela elimina a necessidade de contadores manuais e evita o uso excessivo de range(len(...)) , tornando o código mais legível e menos propenso a erros.

O que faz a função enumerate em Python?

A função enumerate(iterável, start=0) cria um iterador que retorna pares no formato (índice, item) a cada iteração. Esse índice é gerado automaticamente e começa, por padrão, em zero.

frutas = ["maçã", "banana", "uva"]

for i, fruta in enumerate(frutas):

print(i, fruta)

Saída:
0 maçã
1 banana
2 uva

Na prática, enumerate funciona como um contador acoplado ao laço, sincronizado com o iterável. O Python cuida da contagem e da associação entre posição e valor.

Para que serve a função enumerate na prática

O uso de enumerate é indicado sempre que a lógica do laço depende tanto do valor quanto da sua posição. Isso ocorre com frequência em tarefas simples do dia a dia.

Um exemplo comum é numerar linhas de um arquivo ou saída para usuários, usando contagem iniciada em 1:

for linha, texto in enumerate(arquivo, start=1):

print(f"{linha:>4}: {texto.rstrip()}")

 

Outro uso recorrente é atualizar uma lista “no lugar”, sem recorrer a range(len(...)) :

nums = [10, 20, 30]
for i, n in enumerate(nums):
nums[i] = n * 2
# [20, 40, 60]

 

Também é útil para gerar rótulos que dependem da posição:

etiquetas = [f"{i}: {v}" for i, v in enumerate(["A", "B", "C"], start=1)]
# ['1: A', '2: B', '3: C']

 

E para iterar dicionários mantendo um contador explícito:

precos = {"arroz": 22.9, "feijão": 8.5, "óleo": 6.7}

for i, (produto, valor) in enumerate(precos.items(), start=1):

print(i, produto, valor)

 

Em quais tipos de iteráveis funciona

A função enumerate funciona com qualquer objeto iterável, incluindo listas, tuplas, strings, range , arquivos, geradores e métodos como dict.items() .

Algumas observações importantes ajudam a evitar confusão:

• Em dicionários, use .items() se precisar acessar chave e valor juntos.
• Em conjuntos ( set ), a enumeração funciona, mas a ordem não é garantida.
• Em arquivos, enumerate é especialmente eficiente, pois o iterador é preguiçoso e não carrega tudo em memória.

Quando evita código verboso

Um dos maiores benefícios do enumerate é substituir padrões mais longos e frágeis.

Em vez de:

# Verboso, sujeito a off-by-one e repetição de indexação

for i in range(len(seq)):

valor = seq[i]

...

Prefira:

for i, valor in enumerate(seq):

...

Esse padrão é mais legível, reduz erros de índice e funciona até mesmo com iteráveis que não suportam indexação direta.

Quando a contagem precisa ser “humana”, basta definir o ponto inicial:

 

for valor in seq: ou for _, valor in enumerate(seq): (melhor ainda, sem enumerate ).

• Com dicionários, pegue chave e valor:
  for i, (k, v) in enumerate(meu_dict.items(), 1): ...
• Evite mudar o tamanho da lista durante a iteração. Atualizar “no lugar” (reatribuir seq[i] ) é ok; inserir/remover não.

Sintaxe, parâmetros e retorno

A assinatura da função é simples:

enumerate(iterável, start=0)

O primeiro parâmetro é qualquer iterável. O segundo, opcional, define o valor inicial do índice.

O retorno é um objeto do tipo enumerate , que é um iterador. Isso significa que ele é consumido durante a iteração e não pode ser reutilizado sem ser recriado.

Exemplos rápidos

list(enumerate("abc"))
# [(0, 'a'), (1, 'b'), (2, 'c')]

list(enumerate(range(3), start=10))
# [(10, 0), (11, 1), (12, 2)]

Quando usar enumerate

Use enumerate quando a posição do item é relevante para a lógica do código. Isso inclui numeração de saídas, atualização de listas, geração de mensagens de erro com contexto ou interrupção do laço ao encontrar uma condição específica.

for i, v in enumerate(valores, start=1):

if v > 100:

print(f"Primeiro acima de 100: posição {i}, valor {v}")

break

Evite enumerate quando o índice não é usado. Nesses casos, um for simples é mais claro. Também tenha cautela ao usá-lo com estruturas sem ordem previsível, como set.

Exemplos práticos com enumerate

Numeração de linhas de um arquivo com contagem humana (começando em 1):

with open("logs.txt", encoding="utf-8") as f:

for linha, texto in enumerate(f, start=1):

print(f"{linha:>4}: {texto.rstrip()}")

Atualização “no lugar” sem range(len(...)) :

notas = [7.5, 8.0, 6.0]

for i, n in enumerate(notas):

notas[i] = min(n + 0.5, 10.0)

print(notas) # [8.0, 8.5, 6.5]

Encontrar a primeira ocorrência que atende a uma condição e capturar a posição:

valores = [12, 5, 3, 27, 9]

posicao_primeiro_maior_10 = None

 

for i, v in enumerate(valores):

if v > 10:

posicao_primeiro_maior_10 = i

break

print(posicao_primeiro_maior_10) # 0

# (Alternativa concisa: next((i for i, v in enumerate(valores) if v > 10), None))

Rotular itens com posição em relatórios e interfaces:

opcoes = ["Básico", "Padrão", "Premium"]

rotulos = [f"{i}. {nome}" for i, nome in enumerate(opcoes, start=1)]

print(rotulos) # ['1. Básico', '2. Padrão', '3. Premium']

Iterar dicionários preservando a ordem de iteração e exibindo um contador:

precos = {"arroz": 22.9, "feijão": 8.5, "óleo": 6.7}

for i, (produto, valor) in enumerate(precos.items(), start=1):

print(f"{i} — {produto}: R$ {valor:.2f}")

Sincronizar índice com múltiplas coleções (útil em logs e validações):

usuarios = ["Ana", "Bruno", "Clara"]

perfis = ["admin", "editor", "viewer"]

ativos = [True, False, True]

 

for i, (u, p, a) in enumerate(zip(usuarios, perfis, ativos), start=1):

status = "ativo" if a else "inativo"

print(f"{i:02d} | {u:<5} | {p:<6} | {status}")

Filtrar por posição (pares/ímpares) sem criar índices manualmente:

dados = ["a", "b", "c", "d", "e"]

pares = [v for i, v in enumerate(dados) if i % 2 == 0] # posições 0,2,4

print(pares) # ['a', 'c', 'e']

Adicionar um campo id sequencial a registros já existentes:

registros = [{"nome": "Ana"}, {"nome": "Bruno"}, {"nome": "Clara"}]

for i, registro in enumerate(registros, start=1):

registro["id"] = i

print(registros)

# [{'nome': 'Ana', 'id': 1}, {'nome': 'Bruno', 'id': 2}, {'nome': 'Clara', 'id': 3}]

Esses padrões cobrem o uso diário de enumerate : leitura clara, menos código cerimonial e índices sempre sincronizados com os itens.

Erros comuns

Alguns erros aparecem com frequência e comprometem a clareza ou a segurança do código.

O mais comum é usar range(len(seq)) sem necessidade, tornando o código mais longo e sujeito a falhas. Outro erro recorrente é esquecer o parâmetro start=1 quando a numeração é exibida para usuários finais.

Também é comum tentar desempacotar chave e valor diretamente ao enumerar um dicionário sem usar .items() , confiar em ordem estável ao enumerar conjuntos ou modificar o tamanho de uma lista durante a iteração.

Além disso, enumerate não deve ser reutilizado após ser consumido, pois se trata de um iterador. E o índice retornado nunca deve ser tratado como identificador persistente.

Conclusão

A função enumerate é a forma idiomática em Python de combinar posição e valor em um mesmo laço. Ela reduz código cerimonial, melhora a legibilidade e diminui erros comuns de indexação. Funciona com qualquer iterável, permite ajustar o ponto inicial da contagem e se integra naturalmente ao estilo da linguagem.

Sempre que a lógica exigir o item e a sua posição, enumerate deve ser a primeira opção. Evite usá-la quando o índice não é necessário e mantenha atenção às estruturas sem ordem garantida. Com esses cuidados, a função se torna uma aliada constante na escrita de código mais limpo e confiável.