Encontre Índices em Listas Python: Métodos Simples e Eficientes

Por

Descobrindo a Posição de Elementos em Listas Python

Neste guia detalhado, você explorará diversas técnicas para identificar o índice de um elemento específico dentro de uma lista em Python. Abordaremos tanto métodos iterativos básicos quanto o uso da função `index()`, que já vem integrada no Python.

Frequentemente, ao trabalhar com listas, surge a necessidade de saber exatamente em qual posição um certo item se encontra. Isso pode ser feito de duas maneiras:

  • Através de uma iteração pela lista, onde cada item é comparado com o valor que buscamos.
  • Utilizando o método `index()`, que é nativo do Python para listas.

Este tutorial irá cobrir ambos os métodos, fornecendo um entendimento claro de como cada um funciona. Vamos começar! 👩🏽‍💻

Relembrando Listas em Python

Em Python, uma lista é essencialmente uma coleção de itens. Esses itens podem ser todos do mesmo tipo, ou podem ser de tipos de dados distintos. Uma característica importante das listas é que elas são mutáveis, ou seja, podemos modificar seus elementos sem a necessidade de criar uma nova lista.

Para exemplificar, considere uma lista de frutas, contendo cinco itens diferentes:

frutas = ["maçã", "manga", "morango", "romã", "melão"]

A função `len()` do Python é uma ferramenta útil para descobrir o tamanho de qualquer objeto. Aplicando essa função à nossa lista de frutas, obtemos o número de itens que ela contém:

len(frutas)
# Saída: 5

Usaremos esta lista de frutas como base para os exemplos práticos deste tutorial.

A Importância da Indexação em Listas Python

Em Python, a indexação de listas começa em zero. Isso significa que o primeiro elemento de qualquer sequência está no índice 0, o segundo no índice 1, e assim sucessivamente. Se uma sequência tem um comprimento ‘k’, o último elemento estará no índice ‘k – 1’.

A função `range()` é muito útil para gerar sequências de índices enquanto iteramos por coleções em Python.

Importante: `range(k)` produz os índices 0, 1, 2, …, (k-1). Portanto, se ‘k’ for o comprimento da lista, obtemos todos os índices válidos.

O código abaixo ilustra como isso funciona:

for i in range(len(frutas)):
  print(f"índice:{i}, fruta[{i}] é {frutas[i]}")

# Saída
índice:0, fruta[0] é maçã
índice:1, fruta[1] é manga
índice:2, fruta[2] é morango
índice:3, fruta[3] é romã
índice:4, fruta[4] é melão

Agora que revisamos os conceitos básicos de listas em Python, vamos aprender como identificar o índice de um item específico dentro de uma lista.

Encontrando Índices via Iteração com Loops ‘for’

Voltando à nossa lista de frutas, vamos explorar como achar o índice de um item específico usando loops ‘for’ para iterar sobre a lista.

Usando ‘for’ e `range()`

Vamos definir o valor que procuramos como ‘alvo’.

Usando um loop ‘for’ e a função `range()`, podemos percorrer todos os índices da lista.

  • Iteramos sobre a lista, acessando cada índice individualmente.
  • Verificamos se o item naquele índice é igual ao valor ‘alvo’.
  • Se a comparação for verdadeira, exibimos que o alvo foi encontrado naquele índice.
frutas = ["maçã", "manga", "morango", "romã", "melão"]

alvo = "manga"

for i in range(len(frutas)):
  if frutas[i] == alvo:
   print(f"{alvo} encontrado no índice {i}")

# Saída
manga encontrado no índice 1

Neste exemplo, a string ‘manga’ aparece apenas uma vez (no índice 1) na lista.

No entanto, um alvo pode aparecer várias vezes ou mesmo não estar presente na lista. Para lidar com essas situações, vamos ajustar o loop e encapsular o processo em uma função chamada `encontrar_na_lista`.

Analisando a Função

A função `encontrar_na_lista` recebe dois parâmetros:

  • `alvo`: o valor que estamos procurando.
  • `lista_py`: a lista onde realizamos a busca.
def encontrar_na_lista(alvo, lista_py):
  indices_alvo = []
  for i in range(len(frutas)):
    if frutas[i] == alvo:
      indices_alvo.append(i)
  if indices_alvo == []:
    print("Desculpe, alvo não encontrado!")
  else:
    print(f"{alvo} encontrado nos índices {indices_alvo}")

Dentro da função, criamos uma lista vazia chamada `indices_alvo`. Iteramos pela lista, acessando cada elemento. Se o elemento for igual ao alvo, seu índice é adicionado à lista `indices_alvo` usando o método `append()`.

Importante: O método `list.append(item)` adiciona o item ao final da lista.

  • Caso o alvo não seja encontrado, a lista `indices_alvo` permanecerá vazia e uma mensagem indicará a ausência do alvo na lista.
  • Se o alvo aparecer em múltiplos índices, `indices_alvo` irá conter todos esses índices.

Vamos agora modificar a lista de frutas:

Desta vez, procuramos ‘manga’, que aparece duas vezes, nos índices 1 e 4:

frutas = ["maçã", "manga", "morango", "romã", "manga", "melão"]
alvo = "manga"
encontrar_na_lista(alvo,frutas)

# Saída
manga encontrado nos índices [1, 4]

Ao chamar a função, ambos os índices onde ‘manga’ aparece são retornados.

alvo = "nabo"
encontrar_na_lista(alvo,frutas)

# Saída
Desculpe, alvo não encontrado!

Se procurarmos por ‘nabo’, que não está na lista, uma mensagem indicará que o alvo não foi encontrado.

Usando ‘for’ e `enumerate()`

A função `enumerate()` do Python permite acessar simultaneamente os índices e os itens, eliminando a necessidade de usar `range()`.

O código a seguir demonstra o uso de `enumerate()`:

frutas = ["maçã", "manga", "morango", "romã", "manga", "melão"]
for indice, fruta in enumerate(frutas):
  print(f"Índice {indice}: {fruta}")

# Saída
Índice 0: maçã
Índice 1: manga
Índice 2: morango
Índice 3: romã
Índice 4: manga
Índice 5: melão

Agora, vamos reescrever a função `encontrar_na_lista` usando `enumerate()`:

def encontrar_na_lista(alvo, lista_py):
  indices_alvo = []
  for indice, fruta in enumerate(frutas):
   if fruta == alvo:
    indices_alvo.append(indice)
  if indices_alvo == []:
    print("Desculpe, alvo não encontrado!")
  else:
    print(f"{alvo} encontrado nos índices {indices_alvo}")

Assim como antes, podemos agora utilizar a função com argumentos válidos.

A definição acima pode ser convertida em uma list comprehension, o que faremos a seguir.

Encontrando Índices com List Comprehension

List comprehensions em Python facilitam a criação de listas a partir de listas existentes, baseadas em condições específicas. A estrutura geral é:

nova_lista = [<resultado> for <itens em iteráveis existentes> if <condição é verdadeira>]

A figura abaixo ilustra como os elementos da list comprehension são definidos. Com base nisso, podemos converter nossa função `encontrar_na_lista` para uma list comprehension:

Aplicando isso, a list comprehension para encontrar índices do alvo se torna:

indices_alvo = [indice for indice, fruta in enumerate(frutas) if fruta == alvo]

Como exercício, experimente usar esse trecho com diferentes exemplos.

Encontrando Índices com o Método `index()`

Além das iterações, Python oferece o método `.index()` para localizar o índice de um elemento. A sintaxe é:

lista.index(valor, inicio, fim)

Analisando o método:

  • `valor` é o elemento que buscamos.
  • `inicio` e `fim` são opcionais, usados para buscar em uma fatia da lista, de `inicio` até `fim-1`.

Importante: O método `.index()` retorna o índice da primeira ocorrência do valor na lista. Mesmo em fatias da lista `[inicio:fim-1]`, ele retorna apenas o primeiro índice correspondente.

Vamos usar nossos exemplos para entender melhor:

frutas = ["maçã", "manga", "morango", "romã", "manga", "melão"]
alvo = "manga"

frutas.index(alvo)
# Saída: 1

Apesar de ‘manga’ aparecer duas vezes, apenas o índice da primeira ocorrência é retornado.

Para obter o índice da segunda ocorrência, buscamos na fatia da lista de 2 até 4:

frutas.index(alvo, 2, 5)
# Saída: 4

Lidando com Erros `ValueError`

O que acontece ao tentar encontrar um item que não está na lista, como ‘cenoura’?

alvo = "cenoura"

frutas.index(alvo)

# Saída
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-17-81bd454e44f7> in <module>()
      1 alvo = "cenoura"
      2 
----> 3 frutas.index(alvo)

ValueError: 'cenoura' is not in list

Como visto, ocorre um `ValueError`. Podemos tratar esse erro usando `try` e `except`:

A estrutura geral é:

try:
  # Tentar fazer isso
except <TipoDeErro>:
  # Fazer isso se ocorrer <TipoDeErro>

Usando isso para tratar `ValueError`:

alvo = "cenoura"
try:
  frutas.index(alvo)
except ValueError:
  print(f"Desculpe, não encontrei {alvo} na lista")

# Saída
Desculpe, não encontrei cenoura na lista

Este código faz o seguinte:

  • Se o alvo estiver na lista, retorna seu índice.
  • Se não estiver, captura o `ValueError` e exibe uma mensagem de erro.

Resumindo

Aqui está um resumo dos métodos para encontrar o índice de um item em uma lista:

  • Use loops `for` e a função `range()` para acessar itens e índices. Verifique se os itens correspondem ao alvo.
  • A função `enumerate()` permite acessar item e índice simultaneamente.
  • Ambos os métodos podem ser usados em list comprehensions.
  • O método `.index()` retorna o índice de um item.
  • `lista.index(valor)` retorna o primeiro índice de `valor`, gerando `ValueError` se não encontrado.
  • Use `lista.index(valor, inicio, fim)` para buscar na fatia `[inicio:fim-1]`.

Em seguida, aprenda a ordenar um dicionário Python por chave ou valor. Boa programação!