Pregunta ¿Accediendo al índice en los bucles 'for'?


¿Cómo accedo al índice para una lista como la siguiente?

ints = [8, 23, 45, 12, 78]

Cuando lo recorro usando un for loop, ¿cómo accedo al índice de bucle, de 1 a 5 en este caso?


2560
2018-02-06 22:47


origen


Respuestas:


Usar una variable de estado adicional, como una variable de índice (que normalmente usarías en lenguajes como C o PHP), se considera no pitónico.

La mejor opción es usar la función incorporada enumerate(), disponible en Python 2 y 3:

for idx, val in enumerate(ints):
    print(idx, val)

Revisa PEP 279 para más.


4444
2018-02-06 22:52



Usando un bucle for, ¿cómo accedo al índice de bucle, del 1 al 5 en este caso?

Utilizar enumerate para obtener el índice con el elemento mientras iteras:

for index, item in enumerate(items):
    print(index, item)

Y tenga en cuenta que los índices de Python comienzan en cero, por lo que obtendría 0 a 4 con lo anterior. Si quiere el conteo, 1 a 5, haga esto:

for count, item in enumerate(items, start=1):
    print(count, item)

Flujo de control unidiomático

Lo que está pidiendo es el equivalente Pythonic de lo siguiente, que es el algoritmo que usarían la mayoría de los programadores de lenguajes de bajo nivel:

index = 0            # Python's indexing starts at zero
for item in items:   # Python's for loops are a "for each" loop 
    print(index, item)
    index += 1

O en idiomas que no tienen un bucle for-each:

index = 0
while index < len(items):
    print(index, items[index])
    index += 1

o a veces más comúnmente (pero unidiomatically) encontrado en Python:

for index in range(len(items)):
    print(index, items[index])

Usa la función Enumerar

Python enumerate función reduce el desorden visual ocultando la contabilidad de los índices, y encapsulando el iterable en otro iterable (un enumerate objeto) que produce una tupla de dos ítems del índice y el ítem que proporcionaría el iterable original. Eso se ve así:

for index, item in enumerate(items, start=0):   # default is zero
    print(index, item)

Este ejemplo de código es bastante bueno canónico ejemplo de la diferencia entre el código que es idiomático de Python y el código que no lo es. El código idiomático es sofisticado (pero no complicado) Python, escrito de la manera en que estaba destinado a ser utilizado. Los diseñadores del lenguaje esperan el código idiomático, lo que significa que, por lo general, este código no solo es más legible, sino también más eficiente.

Obtener un conteo

Incluso si no necesita índices a medida que avanza, pero necesita un recuento de las iteraciones (a veces deseables) puede comenzar con 1 y el número final será tu conteo.

for count, item in enumerate(items, start=1):   # default is zero
    print(item)

print('there were {0} items printed'.format(count))

El recuento parece ser más de lo que pretendes pedir (en lugar del índice) cuando dijiste que querías del 1 al 5.


Descomponerlo: una explicación paso a paso

Para romper estos ejemplos, digamos que tenemos una lista de elementos que queremos iterar con un índice:

items = ['a', 'b', 'c', 'd', 'e']

Ahora pasamos este iterable para enumerar, creando un objeto enumerate:

enumerate_object = enumerate(items) # the enumerate object

Podemos extraer el primer elemento de esta iterable que obtendríamos en un bucle con el next función:

iteration = next(enumerate_object) # first iteration from enumerate
print(iteration)

Y vemos que obtenemos una tupla de 0, el primer índice, y 'a', el primer artículo:

(0, 'a')

podemos usar lo que se conoce como "secuencia de desempaque"para extraer los elementos de esta dos tuplas:

index, item = iteration
#   0,  'a' = (0, 'a') # essentially this.

y cuando inspeccionamos index, encontramos que se refiere al primer índice, 0, y item se refiere al primer artículo, 'a'.

>>> print(index)
0
>>> print(item)
a

Conclusión

  • Los índices de Python comienzan en cero
  • Para obtener estos índices de un iterable mientras itera sobre él, use la función de enumerar
  • El uso de enumerar de la manera idiomática (junto con el desempaquetado de tuplas) crea un código que es más legible y mantenible:

Entonces haz esto:

for index, item in enumerate(items, start=0):   # Python indexes start at zero
    print(index, item)

516
2018-01-21 17:11



Es bastante simple comenzar desde 1 otro que 0:

for index, item in enumerate(iterable, start=1):
   print index, item

Nota

Pista importante, aunque un poco engañosa desde index será un tuple  (idx, item) aquí. Bueno para ir.


105
2018-05-27 10:04



for i in range(len(ints)):
   print i, ints[i]

67
2018-02-06 22:49



Como es la norma en Python, hay varias formas de hacerlo. En todos los ejemplos se supone: lst = [1, 2, 3, 4, 5]

1. Usando enumerate (considerado más idiomático)

for index, element in enumerate(lst):
    # do the things that need doing here

Esta es también la opción más segura, en mi opinión, porque la posibilidad de entrar en recursión infinita ha sido eliminada. Tanto el elemento como su índice se mantienen en variables y no es necesario escribir ningún código adicional para acceder al artículo.

2. Creando una variable para mantener el índice (utilizando for)

for index in range(len(lst)):   # or xrange
    # you will have to write extra code to get the element

3. Creando una variable para mantener el índice (utilizando while)

index = 0
while index < len(lst):
    # you will have to write extra code to get the element
    index += 1  # escape infinite recursion

4. Siempre hay otra manera

Como se explicó anteriormente, hay otras formas de hacer esto que no se han explicado aquí y que incluso pueden aplicarse más en otras situaciones. p.ej utilizando itertools.chain con que. Maneja bucles anidados mejor que los otros ejemplos.


34
2017-08-15 02:17



De forma anticuada:

for ix in range(len(ints)):
    print ints[ix]

Lista de comprensión:

[ (ix, ints[ix]) for ix in range(len(ints))]

>>> ints
[1, 2, 3, 4, 5]
>>> for ix in range(len(ints)): print ints[ix]
... 
1
2
3
4
5
>>> [ (ix, ints[ix]) for ix in range(len(ints))]
[(0, 1), (1, 2), (2, 3), (3, 4), (4, 5)]
>>> lc = [ (ix, ints[ix]) for ix in range(len(ints))]
>>> for tup in lc:
...     print tup
... 
(0, 1)
(1, 2)
(2, 3)
(3, 4)
(4, 5)
>>> 

20
2018-02-06 22:52



La forma más rápida de acceder a los índices de la lista dentro del ciclo Python 2.7 es usar el método de rango para listas pequeñas y enumerar método para listas de tamaño medio y grande.

Por favor mira diferentes aproximaciones que se puede usar para iterar sobre la lista y acceder al valor del índice y sus métricas de rendimiento (que supongo que sería útil para ti) en ejemplos de código a continuación:

from timeit import timeit

# Using range
def range_loop(iterable):
    for i in range(len(iterable)):
        1 + iterable[i]

# Using xrange
def xrange_loop(iterable):
    for i in xrange(len(iterable)):
        1 + iterable[i]

# Using enumerate
def enumerate_loop(iterable):
    for i, val in enumerate(iterable):
        1 + val

# Manual indexing
def manual_indexing_loop(iterable):
    index = 0
    for item in iterable:
        1 + item
        index += 1

Vea las métricas de rendimiento para cada método a continuación:

from timeit import timeit

def measure(l, number=10000):
print "Measure speed for list with %d items" % len(l)
print "xrange: ", timeit(lambda :xrange_loop(l), number=number)
print "range: ", timeit(lambda :range_loop(l), number=number)
print "enumerate: ", timeit(lambda :enumerate_loop(l), number=number)
print "manual_indexing: ", timeit(lambda :manual_indexing_loop(l), number=number)

measure(range(1000))
# Measure speed for list with 1000 items
# xrange:  0.758321046829
# range:  0.701184988022
# enumerate:  0.724966049194
# manual_indexing:  0.894635915756

measure(range(10000))
# Measure speed for list with 100000 items
# xrange:  81.4756360054
# range:  75.0172479153
# enumerate:  74.687623024
# manual_indexing:  91.6308541298

measure(range(10000000), number=100)
# Measure speed for list with 10000000 items
# xrange:  82.267786026
# range:  84.0493988991
# enumerate:  78.0344707966
# manual_indexing:  95.0491430759

Como resultado, usando range método es el más rápido hasta la lista con 1000 artículos. Para la lista con el tamaño> 10 000 artículos enumerate es el ganador.

Agregando algunos enlaces útiles a continuación:


16
2017-08-04 09:49



No sé si lo siguiente es pitónico o no, pero usa la función de Python enumerate e imprime el índice y el valor.

int_list = [8, 23, 45, 12, 78]
for index, value in enumerate(int_list):
   print(index, value)

Salida:

0 8
1 23
2 45
3 12
4 78

16
2017-10-28 18:17



ints = [9, 23, 45, 12, 78]
ints.extend([1,2,3,4,5,6,7,8])
for idx, val in enumerate(ints):
    print(idx,val)

De esta forma puedes extender una lista. Extender significa que puede agregar múltiples valores a la vez.

Para agregar esta lista, debe escribir el código que se indica a continuación:

ints = [9, 23, 45, 12, 78]
ints.append([1])
for idx, val in enumerate(ints):
    print(idx,val)

De esta forma, puede agregar un solo valor a la vez. Si tú escribes ints.append([1]) entonces esto creará una sub-lista para este elemento.


15
2018-02-05 17:28



En primer lugar, los índices serán de 0 a 4. Los lenguajes de programación comienzan a contar desde 0; no olvide eso o se encontrará con una excepción de índice fuera de límites. Todo lo que necesita en el bucle for es una variable que cuenta de 0 a 4, así:

for x in range(0, 5):

Tenga en cuenta que escribí de 0 a 5 porque el ciclo detiene un número antes del máximo. :)

Para obtener el valor de un uso de índice

list[index]

11
2018-05-25 15:08