python - recorrer - ¿Accediendo al índice en bucles ''for''?

range python

Question

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

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

Cuando hago un bucle a través de un bucle for , ¿cómo accedo al índice de bucle, de 1 a 5 en este caso?

Answer 1

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

Use enumerate para obtener el índice con el elemento a medida que itera:

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 quieres el conteo, del 1 al 5, haz esto:

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

Flujo de control unidiomático.

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

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 para cada uno:

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

o, a veces, más comúnmente (pero unidiomáticamente) en Python:

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

Usa la función de enumerar

La función de enumerate de Python reduce el desorden visual al ocultar la contabilidad de los índices y encapsular lo iterable en otro iterable (un objeto de enumerate ) que produce una tupla de dos elementos del índice y el elemento que proporcionaría el iterable original. Eso se parece a esto:

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

Este ejemplo de código es bastante bueno, el ejemplo canonical 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) de Python, escrito de la forma en que fue diseñado para ser utilizado. Los diseñadores del lenguaje esperan el código idiomático, lo que significa que generalmente este código no solo es más legible, sino también más eficiente.

Conseguir una cuenta

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á su recuento.

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 lo que pretende pedir (en lugar de índice) cuando dijo que quería del 1 al 5.

Romperlo - una explicación paso a paso

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

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

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

enumerate_object = enumerate(items) # the enumerate object

Podemos sacar el primer elemento de esta iterable secuencia que podríamos hacer en un bucle con la 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 elemento:

(0, ''a'')

podemos usar lo que se conoce como " desempaquetado de secuencias " para extraer los elementos de esta tupla doble:

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

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

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

Conclusión

• Los índices de Python comienzan en cero
• Para obtener estos índices de un iterable a medida que se itera sobre él, use la función enumerar
• El uso de enumerate de forma idiomática (junto con el desempaquetado de la tupla) crea un código que es más fácil de leer y mantener:

Así que haz esto:

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

Answer 2

Como es la norma en Python, hay varias maneras de hacer esto. En todos los ejemplos, suponga: lst = [1, 2, 3, 4, 5]

1. Usando enumerate ( considerado el 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 se ha eliminado la posibilidad de ir a una recursión infinita. Tanto el elemento como su índice se mantienen en variables y no es necesario escribir ningún código adicional para acceder al elemento.

2. Creando una variable para mantener el índice ( usando 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 ( usando 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í e incluso pueden aplicarse más en otras situaciones. Por ejemplo, usando itertools.chain con para. Maneja los bucles anidados mejor que los otros ejemplos.

Answer 3

De acuerdo con esta discusión: http://bytes.com/topic/python/answers/464012-objects-list-index

Iteracion contador de bucle

El idioma actual para el bucle sobre los índices hace uso de la función ''rango'' incorporada:

for i in range(len(sequence)):
# work with index i

El bucle sobre ambos elementos e índices se puede lograr ya sea mediante el antiguo idioma o usando la nueva función incorporada ''zip'' [2]:

for i in range(len(sequence)):
e = sequence[i]
# work with index i and element e

o

for i, e in zip(range(len(sequence)), sequence):
# work with index i and element e

a través de http://www.python.org/dev/peps/pep-0212/

Answer 4

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

Answer 5

El uso de una variable de estado adicional, como una variable de índice (que normalmente usaría 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)

Echa un vistazo a PEP 279 para más.

Answer 6

En primer lugar, los índices serán de 0 a 4. Los lenguajes de programación comienzan a contar desde 0; No lo olvide 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 bucle detiene un número antes del máx. :)

Para obtener el valor de un índice de uso

list[index]

Answer 7

En su pregunta, escribe "¿Cómo accedo al índice de bucle, de 1 a 5 en este caso?"

Sin embargo, el índice para una lista, se ejecuta desde cero. Entonces, necesitamos saber si lo que realmente desea es el índice y el elemento para cada elemento de una lista, o si realmente desea números a partir de 1. Afortunadamente, en Python es fácil hacer una o ambas.

Primero, para aclarar, la función de enumerar, retorna iterativamente el índice y el elemento correspondiente para cada elemento en una lista.

alist = [ 1, 2, 3, 4, 5 ]
for n,a in enumerate(alist):
print( "%d %d"%(n,a) )

La salida para lo anterior es entonces,

0 1
1 2
2 3
3 4
4 5

Tenga en cuenta que el índice se ejecuta desde 0. Este tipo de indexación es común entre los lenguajes de programación modernos, incluidos python y c.

Si desea que su bucle abarque una parte de la lista, puede usar la sintaxis de python estándar para una parte de la lista. Por ejemplo, para pasar del segundo elemento de una lista hasta el último elemento, pero sin incluirlo, puede usar

for n,a in enumerate(alist[1:-1]):
print( "%d %d"%(n,a) )

Tenga en cuenta que una vez más, el índice de salida se ejecuta desde 0,

0 2
1 3
2 4

Eso nos lleva al interruptor de inicio = n para enumerar (). Esto simplemente compensa el índice, de manera equivalente, puede agregar un número al índice dentro del bucle.

for n,a in enumerate(alist,start=1):
print( "%d %d"%(n,a) )

para lo cual la salida es

1 1
2 2
3 3
4 4
5 5

Answer 8

Es bastante simple comenzar desde 1 no sea 0 :

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

Nota

Consejo importante, aunque un poco engañoso ya que el index será una tuple (idx, item) aquí. Bueno para ir.

Answer 9

Esto sirve el propósito bastante bien:

list1 = [10, ''sumit'', 43.21, ''kumar'', ''43'', ''test'', 3]
for x in list1:
print(''index:'', list1.index(x), ''value:'', x)

Answer 10

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

Consulte los diferentes enfoques que se pueden usar para iterar sobre la lista y acceder al valor del índice y sus métricas de rendimiento (que supongo que serían útiles para usted) en los 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, el método de range es el más rápido hasta enumerar con 1000 artículos. Para la lista con tamaño> 10 000 elementos enumerate es el ganador.

Agregando algunos enlaces útiles a continuación:

• ¿Cuál es la diferencia entre las funciones de rango y rango en Python 2.X?

• ¿Qué es más rápido para el uso del bucle mediante enumeración o para el uso del bucle utilizando xrange en Python?

• rango (len (lista)) o enumerar (lista)?

Answer 11

La mejor solución para este problema es usar enumerar la función de Python integrada.
enumerar la tupla de retorno
primer valor es el índice
El segundo valor es un elemento de la matriz en ese índice.

In [1]: ints = [8, 23, 45, 12, 78]
In [2]: for idx, val in enumerate(ints):
...: print(idx, val)
...:
(0, 8)
(1, 23)
(2, 45)
(3, 12)
(4, 78)

Answer 12

No sé si lo siguiente es pythonic o no, pero utiliza la función de enumerate Python 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

Answer 13

Para imprimir la tupla de (índice, valor) en la lista de comprensión utilizando un bucle for :

ints = [8, 23, 45, 12, 78]
print [(i,ints[i]) for i in range(len(ints))]

Salida:

[(0, 8), (1, 23), (2, 45), (3, 12), (4, 78)]

Answer 14

Puedes hacerlo con este código:

ints = [8, 23, 45, 12, 78]
index = 0
for value in (ints):
index +=1
print index, value

Utilice este código si necesita restablecer el valor del índice al final del bucle:

ints = [8, 23, 45, 12, 78]
index = 0
for value in (ints):
index +=1
print index, value
if index >= len(ints)-1:
index = 0

Answer 15

Puedes usar el método de index

ints = [8, 23, 45, 12, 78]
inds = [ints.index(i) for i in ints]

EDITAR Resaltado en el comentario de que este método no funciona si hay duplicados en ints , el método siguiente debería funcionar para cualquier valor en ints :

ints = [8, 8, 8, 23, 45, 12, 78]
inds = [tup[0] for tup in enumerate(ints)]

O alternativamente

ints = [8, 8, 8, 23, 45, 12, 78]
inds = [tup for tup in enumerate(ints)]

si desea obtener tanto el índice como el valor en ints como una lista de tuplas.

Utiliza el método de enumerate en la respuesta seleccionada a esta pregunta, pero con una lista de comprensión, lo que lo hace más rápido con menos código.

Answer 16

Recibió una serie de respuestas que explican enumerate , pero si solo necesita el índice para acceder a las entradas coincidentes en dos listas, hay otra forma más simple y clara de usar Python 3: zip .

Por ejemplo, si está utilizando el índice para extraer los nombres correspondientes de los números en su lista, podría hacerlo de la siguiente manera:

ints = [8, 23, 45, 12, 78]
names = ["John", "Sue", "Johannes", "Patel", "Ian"]
for int, name = zip(ints, names):
print("{} - {}".format(name, int)

Eso produciría

8 - John
23 - Sue
45 - Johannes
12 - Patel
78 - Ian

Answer 17

Si no hay un valor duplicado en la lista:

for i in ints:
indx=ints.index(i)
print(i,indx)

En su lugar, utilice enumerate.

for counter, value in enumerate(ints):
print(counter, value)

O utilice a continuación:

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

Answer 18

Si tuviera que iterar números = [1,2,3,4,5] lo haría

for i, num in enumerate(nums, start = 1):
print(i, num)

O obtener la longitud como l = len (números)

for i, num in range(1, l + 1):
print(i, nums[i])

Answer 19

También puedes probar esto:

data = [''itemA.ABC'', ''itemB.defg'', ''itemC.drug'', ''itemD.ashok'']
x = []
for (i, item) in enumerate(data):
a = (i, str(item).split(''.''))
x.append(a)
for index, value in x:
print(index, value)

La salida es

0 [''itemA'', ''ABC'']
1 [''itemB'', ''defg'']
2 [''itemC'', ''drug'']
3 [''itemD'', ''ashok'']

Answer 20

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

Answer 21

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 manera puedes ampliar una lista. Extender significa que puede agregar varios valores a la vez.

Para adjuntar esta lista tienes que escribir el código que figura a continuación:

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

De esta manera puede agregar un solo valor a la vez. Si escribe ints.append([1]) esto creará una lista secundaria para este elemento.