Python: verificar el índice de un elemento en una lista

En este artículo, veremos ejemplos de cómo obtener el índice de un elemento en una lista con la función index(), para encontrar la primera, la última y todas las apariciones de un elemento.

Introducción

Las listas son útiles de diferentes maneras en comparación con otros tipos de datos debido a lo versátiles que son. En este artículo, veremos una de las operaciones más comunes con listas: encontrar el índice de un elemento.

Echaremos un vistazo a diferentes escenarios para encontrar un elemento, es decir, encontrar la primera, la última y todas las apariciones de un elemento. Así como lo que ocurre cuando el elemento que buscamos no existe.

Usando la función index()

Todas las operaciones que mencionamos en el último párrafo se pueden realizar con la función index() incorporada. La sintaxis de esta función es índice(elemento[, inicio[, fin]]).

El parámetro elemento representa naturalmente el elemento que estamos buscando. Los parámetros start y end son opcionales y representan el rango de índices en los que buscamos el elemento.

El valor predeterminado para start es 0 (buscando desde el principio), y el valor predeterminado para end es el número de elementos en la lista (buscando hasta el final de la lista).

La función devuelve la primera posición del elemento en la lista que podría encontrar, independientemente de cuántos elementos iguales haya después de la primera aparición.

Búsqueda de la primera aparición de un elemento {#búsqueda de la primera aparición de un elemento}

Usar la función index() sin establecer ningún valor para start y end nos dará la primera aparición del elemento que estamos buscando:

1
2
3
4
my_list = ['a', 'b', 'c', 'd', 'e', '1', '2', '3', 'b']

first_occurrence = my_list.index('b')
print("First occurrence of 'b' in the list: ", first_occurrence)

Lo que nos daría el resultado esperado:

1
First occurrence of 'b' in the list: 1

Búsqueda de todas las ocurrencias de un elemento

Para encontrar todas las apariciones de un elemento, podemos usar el parámetro opcional start para que busquemos solo en ciertos segmentos de la lista.

Por ejemplo, digamos que tendríamos la primera aparición de un elemento en el índice 3. Para encontrar el siguiente, necesitaríamos continuar nuestra búsqueda de la primera aparición de ese elemento después del índice 3. Repetiríamos este proceso, cambiando dónde comienza nuestra búsqueda, siempre que encontremos nuevas ocurrencias del elemento:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
my_list = ['b', 'a', 2, 'n', False, 'a', 'n', 'a']

all_occurrences = []
last_found_index = -1
element_found = True

while element_found:
    try:
        last_found_index = my_list.index('a', last_found_index + 1)
        all_occurrences.append(last_found_index)
    except ValueError:
        element_found = False
    
if len(all_occurrences) == 0:
    print("The element wasn't found in the list")
else:
    print("The element was found at: " + str(all_occurrences))

Ejecutar este código nos daría:

1
The element was found at: [1, 5, 7]

Tuvimos que usar un bloque try aquí, ya que la función index() arroja un error cuando no puede encontrar el elemento especificado en el rango dado. Esto puede ser inusual para los desarrolladores que están más acostumbrados a otros lenguajes, ya que funciones como estas generalmente devuelven -1/null cuando no se puede encontrar el elemento.

Sin embargo, en Python debemos tener cuidado y usar un bloque try cuando usamos esta función.

Otra forma más ordenada de hacer lo mismo sería usando la comprensión de listas e ignorando la función index() por completo:

1
2
3
4
5
my_list = ['b', 'a', 2, 'n', False, 'a', 'n', 'a']

all_occurrences = [index for index, element in enumerate(my_list) if element == 'a']

print("The element was found at: " + str(all_occurrences))

Lo que nos daría la misma salida que antes. Este enfoque tiene el beneficio adicional de no usar el bloque try.

Búsqueda de la última aparición de un elemento {#búsqueda de la última aparición de un elemento}

Si necesita encontrar la última aparición de un elemento en la lista, hay dos enfoques que puede usar con la función index():

  • Invierta la lista y busque la primera aparición en la lista invertida
  • Revise todas las ocurrencias del elemento y solo realice un seguimiento de la última ocurrencia

Con respecto al primer enfoque, si conociéramos la primera aparición del elemento en una lista invertida, podríamos encontrar la posición de la última aparición en la original. Más específicamente, podemos hacer esto restando reversed_list_index - 1 de la longitud de la lista original:

1
2
3
4
5
6
7
8
9
my_list = ['b', 'a', 2, 'n', False, 'a', 'n', 'a']

reversed_list_index = my_list[::-1].index('n')
# or alteratively:
# reversed_list_index2 = list(reversed(my_list)).index('n')

original_list_index = len(my_list) - 1 - reversed_list_index

print(original_list_index)

Lo que nos daría la salida deseada:

1
6

En cuanto al segundo enfoque, podríamos modificar el código que usamos para encontrar todas las ocurrencias y solo realizar un seguimiento de la última ocurrencia que encontramos:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
my_list = ['b', 'a', 2, 'n', False, 'a', 'n', 'a']

last_occurrence = -1
element_found = True

while element_found:
    try:
        last_occurrence = my_list.index('n', last_occurrence + 1)
    except ValueError:
        element_found = False
    
if last_occurrence == -1:
    print("The element wasn't found in the list")
else:
    print("The last occurrence of the element is at: ", last_occurrence)

Lo que nos daría el mismo resultado:

1
6

Conclusión

Hemos echado un vistazo a algunos de los usos más comunes de la función index() y cómo evitarla en algunos casos.

Tenga en cuenta el comportamiento potencialmente inusual de la función index(), donde arroja un error en lugar de devolver -1/None cuando un elemento no se encuentra en la lista.