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

    Introducción

    Python es un lenguaje de programación de muy alto nivel y tiende a alejarse de cualquier cosa que se parezca remotamente a la estructura de datos internos. Debido a esto, generalmente 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 la index. En cada aumento, accedemos a la lista de ese index:

    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 el index. Entonces, usamos esto index variable para acceder a los elementos de la lista en orden de 0..n, dónde n es el final de la lista.

    Este código producirá la salida:

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

    Usando enumerate ()

    enumerate() es una función incorporada 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 enumerado se puede convertir fácilmente en una lista utilizando un list() constructor. 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:

    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:

    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 enumerado. Luego, convertimos ese objeto enumerado en una lista usando el list() constructor e imprimió cada lista en la salida estándar.

    Además, puede configurar el start argumento para cambiar la indexación. Actualmente, está basado en 0. Vamos a cambiarlo para empezar 1 en lugar:

    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:

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

    Uso de comprensiones de listas

    La comprensión de una lista es una forma de definir y crear listas basadas en listas ya existentes. Suele ser una forma más rápida, elegante y compacta de manipular listas, en comparación con funciones y for bucles.

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

    • iterable – Una colección cuyos elementos podemos inspeccionar uno a la vez
    • miembro – Valor u objeto en una lista (que es iterable)
    • 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:

    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, 4, 9, 16, 25]
    

    En esta lista de comprensión, my_list representa lo iterable, m representa a 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:

    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:

    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 list() constructor. Este constructor no acepta argumentos ni tiene 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 pasa ningún parámetro, 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 list() constructor, que luego escupió una lista equivalente.

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

    Usando zip ()

    los zip() La función acepta dos o más parámetros, que 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:

    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))
    

    Al ejecutar el fragmento de código anterior obtenemos:

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

    La longitud del iterador que devuelve esta función es igual a la longitud del más pequeño de sus parámetros.

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

    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:

    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 primer parámetro de la zip() función, y my_list como segundo parámetro. La función emparejó cada índice con su valor correspondiente, y los imprimimos como tuplas usando un for lazo.

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

    print(list((index, value)))
    

    Conclusión

    En este artículo pasamos por 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, analizamos los conceptos básicos de las listas por comprensión y cómo se pueden utilizar 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í se vuelve demasiado complicada. Las comprensiones de listas complicadas pueden generar mucho 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 basaron en las funciones integradas de Python: enumerate() y zip(), que unió los índices y sus valores correspondientes en tuplas. Luego, convertimos esas tuplas en listas y las imprimimos en la salida estándar.

     

    Etiquetas:

    Deja una respuesta

    Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *