Cómo acceder al índice en Python's for Loop

En este tutorial, veremos cómo acceder al índice en un bucle for de Python. Usaremos un enfoque manual genérico, así como enumeraciones, la función zip() y listas de comprensión.

Introducción

Python es un lenguaje de programación de muy alto nivel y tiende a desviarse de cualquier cosa que se parezca remotamente a la estructura de datos internos. Debido a esto, normalmente no necesitamos los índices de una lista para acceder a sus elementos, sin embargo, a veces los necesitamos desesperadamente.

En este artículo, repasaremos diferentes enfoques sobre cómo acceder a un índice en el bucle for de Python.

¿Cómo acceder al índice en el bucle for de Python?

El método más fácil y popular para acceder al índice de elementos en un bucle for es recorrer la longitud de la lista, aumentando el índice. En cada aumento, accedemos a la lista en ese índice:

1
2
3
4
5
6
my_list = [3, 5, 4, 2, 2, 5, 5]

print("Indices and values in my_list:")

for index in range(len(my_list)):
    print(index, my_list[index], end = "\n")

Aquí, no iteramos a través de la lista, como lo haríamos normalmente. Iteramos desde 0..len(my_list) con index. Luego, usamos esta variable index para acceder a los elementos de la lista en orden 0..n, donde n es el final de la lista.

Este código producirá la salida:

1
2
3
4
5
6
7
8
Indices and values in my_list:
0 3
1 5
2 4
3 2
4 2
5 5
6 5

Usando enumerar()

enumerate() es una función integrada de Python que es muy útil cuando queremos acceder tanto a los valores como a los índices de una lista. Vale la pena señalar que este es el método más rápido y eficiente para adquirir el índice en un bucle for.

Este método agrega un contador a un iterable y los devuelve juntos como un objeto enumerado. Este objeto de enumeración se puede convertir fácilmente en una lista usando un constructor list(). Esta es la forma más común de acceder a ambos elementos y sus índices al mismo tiempo.

Ahora, echemos un vistazo al código que ilustra cómo se usa este método:

1
2
3
4
my_list = [3, 5, 4, 2, 2, 5, 5]
print("Indices and values in my_list:") 
for index, value in enumerate(my_list): 
    print(list((index, value))) 

Este código producirá la salida:

1
2
3
4
5
6
7
8
Indices and values in my_list:
[0, 3]
[1, 5]
[2, 4]
[3, 2]
[4, 2]
[5, 5]
[6, 5]

Lo que hicimos en este ejemplo fue enumerar cada valor en una lista con su índice correspondiente, creando un objeto de enumeración. Luego, convertimos ese objeto de enumeración en una lista usando el constructor list() e imprimimos cada lista en la salida estándar.

Además, puede configurar el argumento start para cambiar la indexación. Actualmente, está basado en 0. Cambiémoslo para que comience en 1 en su lugar:

1
2
3
4
my_list = [3, 5, 4, 2, 2, 5, 5]
print("Indices and values in my_list:") 
for index, value in enumerate(my_list, start=1): 
    print(list((index, value))) 

Ahora, esto produce:

1
2
3
4
5
6
7
8
Indices and values in my_list:
[1, 3]
[2, 5]
[3, 4]
[4, 2]
[5, 2]
[6, 5]
[7, 5]

Usar listas de comprensión

Una comprensión de lista es una forma de definir y crear listas basadas en listas ya existentes. Por lo general, es una forma más rápida, elegante y compacta de manipular listas, en comparación con las funciones y los bucles for.

Cada lista de comprensión en Python contiene estos tres elementos:

  1. iterable - Una colección cuyos elementos podemos inspeccionar uno a la vez
  2. miembro: valor u objeto en una lista (que es iterable)
  3. expresión: puede ser cualquier expresión válida que devuelva un valor (un miembro, un iterable, una llamada a una función...)

Echemos un vistazo al siguiente ejemplo:

1
2
3
my_list = [1, 2, 3, 4, 5]
my_list_squared = [m*m for m in my_list]
print(my_list_squared)

Este código producirá la salida:

1
[1, 4, 9, 16, 25]

En esta comprensión de lista, my_list representa el iterable, m representa un miembro y m*m representa la expresión.

Ahora que analizamos qué es la comprensión de listas, podemos usarla para recorrer una lista y acceder a sus índices y valores correspondientes. Echemos un vistazo a este ejemplo:

1
2
3
my_list = [3, 5, 4, 2, 2, 5, 5]
print("Indices and values in my_list:") 
print([list((i, my_list[i])) for i in range(len(my_list))])

Este código producirá la salida:

1
2
Indices and values in my_list:
[[0, 3], [1, 5], [2, 4], [3, 2], [4, 2], [5, 5], [6, 5]]

Lo que hicimos en este ejemplo fue usar el constructor list(). Este constructor no toma argumentos o toma un solo argumento: un iterable. Esto incluye cualquier objeto que pueda ser una secuencia (cadena, tuplas) o una colección (conjunto, diccionario).

Si no se pasan parámetros, devuelve una lista vacía, y si se pasa un iterable como parámetro, crea una lista que consta de sus elementos.

Construimos una lista de dos listas de elementos que tienen el formato [elementIndex, elementValue]. Estas listas de dos elementos se construyeron pasando pares al constructor list(), que luego generó una lista equivalente.

Esto creará 7 listas separadas que contienen el índice y su valor correspondiente en my_list que se imprimirá.

Usando zip()

La función zip() acepta dos o más parámetros, todos los cuales deben ser iterables.

Devuelve un objeto zip: un iterador de tuplas en el que el primer elemento de cada iterador pasado se empareja, el segundo elemento de cada iterador pasado se empareja, y de manera análoga para el resto de ellos:

1
2
3
4
5
6
7
8
9
list_a = [1, 2, 3]
list_b = ['A', 'B', 'C']

# Zip will make touples from elements with the same 
# index (position in the list). Meaning that 1 from the
# first list will be paired with 'A', 2 will be paired
# with 'B' and so on...
for elem1,elem2 in zip(list_a,list_b):
    print((elem1,elem2))

Ejecutando el fragmento de código anterior obtenemos:

1
2
3
(1, 'A')
(2, 'B')
(3, 'C')

La longitud del iterador que devuelve esta función es igual a la longitud del menor de sus parámetros.

Ahora que hemos explicado cómo funciona esta función, usémosla para resolver nuestra tarea:

1
2
3
4
my_list = [3, 5, 4, 2, 2, 5, 5]
print ("Indices and values in my_list:") 
for index, value in zip(range(len(my_list)), my_list):
    print((index, value))

Este código producirá la salida:

1
2
3
4
5
6
7
8
Indices and values in my_list:
(0, 3)
(1, 5)
(2, 4)
(3, 2)
(4, 2)
(5, 5)
(6, 5)

En este ejemplo, pasamos una secuencia de números en el rango de 0 a len(my_list) como el primer parámetro de la función zip(), y my_list como su segundo parámetro. La función emparejó cada índice con su valor correspondiente y los imprimimos como tuplas usando un ciclo for.

Si quisiéramos convertir estas tuplas en una lista, usaríamos el constructor list(), y nuestra función print se vería así:

1
print(list((index, value)))

Conclusión

En este artículo, analizamos cuatro métodos diferentes que nos ayudan a acceder a un índice y su valor correspondiente en una lista de Python.

Además del método más básico, repasamos los conceptos básicos de la comprensión de listas y cómo se pueden usar para resolver esta tarea. Aunque es una forma más rápida de hacerlo en comparación con un bucle for genérico, generalmente deberíamos evitar usarlo si la comprensión de la lista en sí misma se vuelve demasiado complicada. Las comprensiones de listas complicadas pueden conducir a una gran cantidad de código desordenado.

Es importante tener en cuenta que aunque cada comprensión de lista se puede reescribir en un bucle for, no todos los bucles for se pueden reescribir en una comprensión de lista.

Otros dos métodos que usamos se basaban en las funciones integradas de Python: enumerate() y zip(), que unían los índices y sus valores correspondientes en tuplas. Luego, convertimos esas tuplas en listas y las imprimimos en la salida estándar.

Licensed under CC BY-NC-SA 4.0