Função enumerate() do Python, explicada com exemplos

Vamos dar um exemplo de uma lista de compras definida na célula de código abaixo.

  shopping_list = ("fruits","cookies","cereals","protein bars","post-it notes")

Em Python, você pode usar o for loop para percorrer qualquer iterável. A sintaxe para fazer isso é a seguinte:

  for item in <iterable>:
    # do something on item

# item: looping variable
# <iterable>: any Python iterable: list, tuple, dictionary, string, and so on.

Agora, usando esta sintaxe, vamos percorrer shopping_list e acessar os itens individuais.

  for item in shopping_list:
  print(item)

# Output
fruits
cookies
cereals
protein bars
post-it notes

Essa construção ajuda você a acessar os itens diretamente. No entanto, às vezes você pode precisar acessar o índice dos itens, além dos próprios itens.

Você pode usar um index variável, que você pode incrementar dentro do corpo do loop, conforme mostrado abaixo:

  index = 0
for item in shopping_list:
  print(f"index:{index}, {item}")
  index += 1

# Output
index:0, fruits
index:1, cookies
index:2, cereals
index:3, protein bars
index:4, post-it notes

Mas este não é o método mais eficiente. Se você não lembrar de incrementar o índice, seu código não funcionará como esperado.

  index = 0
for item in shopping_list:
  print(f"index:{index}, {item}")
  # no update of index inside loop body
  # index is never updated and is always 0

# Output
index:0, fruits
index:0, cookies
index:0, cereals
index:0, protein bars
index:0, post-it notes

Outro padrão comum de uso do for loop está em conjunto com o range() função. Aprenderemos sobre isso na próxima seção.

Como usar a função range () para acessar o índice

Integrado do Python len() A função retorna o comprimento de qualquer objeto Python. Então você pode ligar para o len() função com shopping_list o argumento para obter o comprimento do shopping_list (que é 5, neste caso).

  len(shopping_list)
# Output: 5

O range() A função retorna um objeto de intervalo que você pode usar em loop. Quando você faz um loop range(stop)você obtém os índices 0, 1, 2,…, stop-1.

Definindo stop = len(list), você pode obter a lista de índices válidos. Então, usando o range() função, você pode acessar o índice, bem como o item correspondente, conforme mostrado abaixo.

  for index in range(len(shopping_list)):
  print(f"index:{index}, item: {shopping_list(index)}")

# Output
index:0, item: fruits
index:1, item: cookies
index:2, item: cereals
index:3, item: protein bars
index:4, item: post-it notes

No entanto, esta não é a maneira Pythonic recomendada para acessar índices e itens simultaneamente.

Sintaxe da função enumerate() do Python

do Python enumerar() A função permite acessar os itens junto com seus índices usando a seguinte sintaxe geral:

  enumerate(<iterable>, start = 0)

Na sintaxe acima:

• <iterable> é um obrigatório parâmetro e pode ser qualquer iterável do Python, como uma lista ou tupla.
• start é um parâmetro opcional que controla o índice no qual a contagem começa. Se você não especificar o valor de start, o padrão será zero.

Agora você pode ligar para o enumerate() função com shopping_list e retorna um objeto enumerate, conforme mostrado na célula de código abaixo.

  enumerate(shopping_list)
<enumerate at 0x7f91b4240410>

Você não pode fazer um loop através do enumerate objeto. Então vamos converter o enumerate objeto em uma lista Python.

  list(enumerate(shopping_list))

# Output
((0, 'fruits'),
 (1, 'cookies'),
 (2, 'cereals'),
 (3, 'protein bars'),
 (4, 'post-it notes'))

Outro método para acessar os itens do enumerate objeto é chamar o função next() com o enumerate objeto como argumento. Em Python, o next() A função retorna o próximo item de um iterador.

Internamente, o next() função funciona chamando o __next__ no objeto iterador para recuperar os itens sucessivos.

Vamos atribuir o objeto enumerate à variável shopping_list_enum.

  shopping_list_enum = enumerate(shopping_list)

Quando você ligar pela primeira vez next() com shopping_list_enumvocê obterá o índice zero e o item no índice 0: a tupla (0, 'fruits').

Quando você continuar a fazer mais chamadas para o next() função, você obterá os itens sucessivos junto com seus índices, conforme descrito abaixo.

  next(shopping_list_enum)
# (0, 'fruits')
next(shopping_list_enum)
# (1, 'cookies')
next(shopping_list_enum)
# (2, 'cereals')
next(shopping_list_enum)
# (3, 'protein bars')
next(shopping_list_enum)
# (4, 'post-it notes')

O que acontece se você ligar next() função depois de acessar todos os itens e chegar ao final da lista? você ganha um StopIteration Error.

  next(shopping_list_enum)
# ---------------------------------------------------------------------------
StopIteration                             Traceback (most recent call last)
<ipython-input-16-4220f68f6c7e> in <module>()
----> 1 next(shopping_list_enum)

StopIteration:

O enumerate() A função retorna os índices e itens sucessivos somente quando necessário e não são calculados antecipadamente. Em Projetos Python onde você precisa levar em conta a eficiência da memória, você pode tentar usar o enumerate() função quando você precisa percorrer grandes iteráveis.

Python enumerate () Exemplos de funções

Agora que aprendemos a sintaxe para usar o enumerate() função, vamos modificar o loop for que tínhamos anteriormente.

Da seção anterior, sabemos que percorrer o objeto enumerate retorna uma tupla com o índice e o item. Podemos desempacotar esta tupla em duas variáveis: index e item.

  for index, item in enumerate(shopping_list):
  print(f"index:{index}, item:{item}")

# Output
index:0, item:fruits
index:1, item:cookies
index:2, item:cereals
index:3, item:protein bars
index:4, item:post-it notes

A seguir, veremos como especificar um valor inicial personalizado.

Como enumerar () com valor inicial personalizado

Python segue a indexação zero, então o start o valor é 0 por padrão. No entanto, se você precisar dos índices em formato legível por humanos – começando em 1 ou qualquer outro índice de sua escolha, poderá especificar um padrão personalizado start valor.

No shopping_list por exemplo, se você quiser começar a contar a partir de 1, defina start = 1.

  for index, item in enumerate(shopping_list,1):
  print(f"index:{index}, item:{item}")

# Output
index:1, item:fruits
index:2, item:cookies
index:3, item:cereals
index:4, item:protein bars
index:5, item:post-it notes

No entanto, ao especificar o valor inicial personalizado, você deve especificá-lo como o segundo argumento posicional.

Se você trocar por engano a ordem do iterável e o valor inicial, ocorrerá um erro, conforme explicado na célula de código abaixo.

  for index, item in enumerate(1,shopping_list):
  print(f"index:{index}, item:{item}")

# Output
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-12-5dbf7e2749aa> in <module>()
----> 1 for index, item in enumerate(1,shopping_list):
      2   print(f"index:{index}, item:{item}")

TypeError: 'list' object cannot be interpreted as an integer

Para evitar tais erros, você pode especificar start como um argumento de palavra-chave, conforme mostrado abaixo.

  for index, item in enumerate(shopping_list, start = 1):
  print(f"index:{index}, item:{item}")

# Output
index:1, item:fruits
index:2, item:cookies
index:3, item:cereals
index:4, item:protein bars
index:5, item:post-it notes

Até agora, você aprendeu a usar o enumerate() função com listas Python. Você também pode usar a função enumerate para percorrer strings Python dicionários e tuplas.

Como usar a função enumerate () com tuplas do Python

Suponha shopping_list é uma tupla. Em Python, as tuplas também são coleções — semelhantes às listas do Python, mas são imutável. Portanto, você não pode modificá-los e tentar fazer isso levará a um erro.

O trecho de código a seguir inicializa shopping_list como uma tupla.

  shopping_list = ("fruits","cookies","cereals","protein bars","post-it notes")
type(shopping_list)
# Tuple

Se você tentar modificar o primeiro item na tupla, receberá um erro, pois uma tupla do Python é uma coleção imutável.

  shopping_list(0) = 'vegetables'

# Output
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-2-ffdafa961600> in <module>()
----> 1 shopping_list(0) = 'vegetables'

TypeError: 'tuple' object does not support item assignment

▶ Agora, execute o trecho de código a seguir para verificar se o enumerate() função funciona como esperado com tuplas.

  shopping_list = ("fruits","cookies","cereals","protein bars","post-it notes")
for index, item in enumerate(shopping_list):
    print(f"index:{index}, item:{item}")

Como usar a função enumerate () com strings Python

Você também pode usar a função enumerate() do Python para percorrer strings e acessar os caracteres e índices simultaneamente.

Aqui está um exemplo.

  py_str = 'Butterfly'
for index, char in enumerate(py_str):
  print(f"index {index}: {char}")

# Output
index 0: B
index 1: u
index 2: t
index 3: t
index 4: e
index 5: r
index 6: f
index 7: l
index 8: y

Na saída acima, vemos que os caracteres junto com seus índices (0-8) foram impressos.

Conclusão ‍

Aqui está um resumo do que você aprendeu.

• Você pode usar para loops para acessar os itens e manter um contador separado ou variável de índice.
• Se quiser, você pode usar o faixa() função para obter os índices válidos e acessar os itens indexando na lista.
• Como uma maneira Pythonic recomendada, você pode usar o Python’s enumerar() função com a sintaxe: enumerar (iterável). Por padrão, a contagem ou índice começa em 0.
• Você pode especificar o costume começar valor com a sintaxe enumerate(iterável, start) para obter o índice começando no valor começar e os itens correspondentes.
• Você pode usar a função enumerate ao trabalhar com tuplas, strings, dicionários e, em geral, qualquer iterável do Python.

Espero que você tenha achado este tutorial sobre a função enumerate() útil. A seguir, saiba como encontre o índice de um item nas listas do Python . Continue codificando!