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 utilizar la función incorporada enumerate(), disponible en Python 2 y 3:

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

Fin del retiro PEP 279 para más.

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

Utilice la herramienta enumerate para obtener el índice con el elemento mientras 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 de 0 a 4 con lo anterior. Si desea el recuento, de 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 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 for-each:

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

oa veces más comúnmente (pero unidiomáticamente) que se encuentra en Python:

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

Usar 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 object) que produce una tupla de dos elementos del índice y el elemento 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 idiomático de Python y el código que no lo es. El código idiomático es Python sofisticado (pero no complicado), escrito de la forma en que fue diseñado para ser utilizado. Los diseñadores del lenguaje esperan código idiomático, lo que significa que normalmente este código no solo es más legible, sino también más eficiente.

Conseguir un recuento

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

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 pretendes pedir (a diferencia del índice) cuando dijiste que querías de 1 a 5.

Desglosando: una explicación paso a paso

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

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

Ahora pasamos este iterable a enumerar, creando un objeto enumerado:

enumerate_object = enumerate(items) # the enumerate object

Podemos sacar el primer elemento de este 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 elemento:

(0, 'a')

podemos utilizar lo que se denomina "desempaque de secuencia"para extraer los elementos de esta tupla de dos:

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 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 lo recorre, use la función enumerar
• El uso de enumerate de forma idiomática (junto con el desempaquetado de tuplas) crea un código que es más legible y fácil de mantener:

Entonces haz esto:

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

Es bastante sencillo empezar desde 1 que no sea 0:

for index, item in enumerate(iterable, start=1):
   print index, item  # Used to print in python<3.x
   print(index, item) # Mirate print() after 3.x+
   

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

Como es la norma en Python, hay varias formas de hacer esto. En todos los ejemplos, suponga: 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 se ha eliminado la posibilidad de entrar en recursividad 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. Crear una variable para contener el índice (usar for)

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

3. Crear una variable para contener el índice (usar 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 forma

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

Acceso a índices y evaluación comparativa de rendimiento de enfoques

La forma más rápida de acceder a índices de lista dentro del bucle en 3.7 Python es usar el enumerar método para listas pequeñas, medianas y grandes.

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

# Using range
def range_loop(iterable):
    for i in range(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

Consulte las métricas de rendimiento de 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("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 speed for list with 1000 items
measure(range(1000))
# range:  1.161622366
# enumerate:  0.5661940879999996
# manual_indexing:  0.610455682

# Measure speed for list with 100000 items
measure(range(10000))
# range:  11.794482958
# enumerate:  6.197628574000001
# manual_indexing:  6.935181098000001

# Measure speed for list with 10000000 items
measure(range(10000000), number=100)
# range:  121.416859069
# enumerate:  62.718909123
# manual_indexing:  69.59575057400002

Como resultado, el uso enumerate El método es el método más rápido para la iteración cuando el índice lo necesita.

Añadiendo algunos enlaces útiles a continuación:

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

• ¿Qué es más rápido para bucle usando enumerate o for bucle usando xrange en Python?

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

De forma anticuada:

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

Comprensión de listas:

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

Esto es lo que obtiene cuando accede al índice en for bucles:

for i in enumerate(items): print(i)

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

for i in enumerate(items):
    print("index/value", i)

Resultado:

# index/value (0, 8)
# index/value (1, 23)
# index/value (2, 45)
# index/value (3, 12)
# index/value (4, 78)

for i, val in enumerate(items): print(i, val)

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

for i, val in enumerate(items):
    print("index", i, "for value", val)

Resultado:

# index 0 for value 8
# index 1 for value 23
# index 2 for value 45
# index 3 for value 12
# index 4 for value 78

for i, val in enumerate(items): print(i)

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

for i, val in enumerate(items):
    print("index", i)

Resultado:

# index 0
# index 1
# index 2
# index 3
# index 4

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 ciclo for es una variable que cuente de 0 a 4 así:

for x in range(0, 5):

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

Para obtener el valor de un índice, utilice

list[index]

Según esta discusión: http://bytes.com/topic/python/answers/464012-objects-list-index

Iteración del contador de bucles

El idioma actual para recorrer los índices hace uso de la función incorporada range función:

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

El bucle sobre los elementos y los índices se puede lograr mediante el antiguo idioma o utilizando el nuevo zip función incorporada:

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

or

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

vía http://www.python.org/dev/peps/pep-0212/

Puedes hacerlo con este código:

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

for value in (ints):
    index +=1
    print index, value

Use este código si necesita restablecer el valor del índice al final del ciclo:

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

for value in (ints):
    index +=1
    print index, value
    if index >= len(ints)-1:
        index = 0

Si tuviera que iterar nums = [1, 2, 3, 4, 5] yo lo haría

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

O obtenga la longitud como l = len(nums)

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

La mejor solución para este problema es utilizar el enumerate función incorporada.

enumerate devuelve un tuple, donde el primer valor es el índice y el segundo valor es el elemento de la lista 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)

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

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

Primero, para aclarar, el enumerate La función devuelve iterativamente el índice y el elemento correspondiente para cada elemento de una lista.

alist = [1, 2, 3, 4, 5]

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

El resultado de 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 estándar de Python para una parte de la lista. Por ejemplo, para recorrer desde el segundo elemento de una lista hasta el último elemento, pero sin incluirlo, puede utilizar

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 va desde 0,

0 2
1 3
2 4

Eso nos lleva a la start=n cambiar por enumerate(). Esto simplemente compensa el índice, de manera equivalente, puede simplemente agregar un número al índice dentro del ciclo.

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

Si no hay un valor duplicado en la lista:

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

También puede intentar lo siguiente:

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']

Puede utilizar el index Método

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

EDITAR Destacado en el comentario 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 comprensión de la lista, lo que la hace más rápida con menos código.

Respuesta simple usando While Loop:

arr = [8, 23, 45, 12, 78]
i = 0
while i < len(arr):
    print("Item ", i + 1, " = ", arr[i])
    i += 1

Salida:

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

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

Esto sirve al propósito bastante bien:

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