en utilisant un pour boucle, comment accéder à l'index de boucle, de 1 à 5 dans ce cas?

utilisez enumerate pour obtenir l'index avec l'élément que vous itérez:

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

et notez que les index de Python commencent à zéro, donc vous obtiendriez 0 à 4 avec ce qui précède. Si vous voulez le compte, 1 à 5, Faites ceci:

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

flux de contrôle Unidiomatique

Ce que vous demandons, c'est la Pythonic équivalent de la suivante, qui est l'algorithme de la plupart des programmeurs de niveau inférieur langues:

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

Ou dans des langues qui n'ont pas de boucle for-each:

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

ou parfois plus communément (mais unidiomatiquement) trouvé en Python:

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

utilisez L'énumération Fonction

Python's enumerate function réduit l'encombrement visuel en masquant la comptabilisation des index, et en encapsulant le itérable dans un autre itérable (un objet enumerate ) qui produit un tuple de deux articles de l'index et l'article que le itérable original fournirait. Cela ressemble à ceci:

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

cet échantillon de code est assez bien le canonique exemple de la différence entre le code qui est idiomatiques de Python et le code qui ne l'est pas. Le code idiomatique est un Python sophistiqué (mais pas compliqué), écrit de la façon dont il était destiné à être utilisé. Le code idiomatique est attendu par les concepteurs de la langue, ce qui signifie que généralement ce code est non seulement plus lisible, mais aussi plus efficace.

Obtenir un nombre

Même si vous n'avez pas besoin d'indices que vous allez, mais vous avez besoin d'un nombre d'itérations (parfois souhaitable) vous pouvez commencer par 1 et le nombre final sera votre compte.

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

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

Le comte semble être plus que vous avez l'intention de demander (par opposition à l'index) quand vous avez dit que vous vouliez de 1 à 5.

Casser vers le bas - une explication étape par étape

pour décomposer ces exemples, disons que nous avons une liste d'éléments que nous voulons itérer avec un index:

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

maintenant nous passons ce itérable pour énumérer, créant un objet enumerate:

enumerate_object = enumerate(items) # the enumerate object

nous pouvons tirer le premier élément de ce iterable que nous aurions dans une boucle avec la fonction next :

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

et nous voyons que nous obtenons un tuple de 0 , le premier index, et 'a' , le premier article:

(0, 'a')

nous pouvons utiliser ce qui est appelé " déballage séquentiel "pour extraire les éléments de ce double-tuple:

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

et quand nous inspectons index , nous trouvons qu'il se réfère au premier index, 0, et item se réfère au premier article, 'a' .

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

Conclusion

• les indices Python commencent à zéro
• pour obtenir ces index à partir d'un itérable que vous itérez sur elle, utilisez la fonction d'énumération
• en utilisant enumerate de manière idiomatique (avec tuple unpacking) crée un code qui est plus lisible et maintenable:

alors faites ceci:

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

il est assez simple de commencer à partir de 1 autre que 0 :

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

Note

indice Important, bien qu'un peu trompeur depuis index sera un tuple (idx, item) ici. Bon pour aller.

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

Comme c'est la norme en Python il y a plusieurs façons de le faire. Dans tous les exemples, supposons: lst = [1, 2, 3, 4, 5]

1. En utilisant enumerate ( considéré comme le plus idiomatique )

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

C'est aussi l'option la plus sûre à mon avis parce que la chance d'aller dans la récursion infinie a été éliminée. L'article et son index sont tous deux détenus dans des variables et il n'est pas nécessaire d'écrire un autre code pour accéder à l'élément.

2. Création d'une variable pour maintenir l'indice ( en utilisant for )

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

3. Création d'une variable pour maintenir l'indice ( en utilisant while )

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

4. Il y a toujours un autre chemin

comme nous l'avons expliqué plus haut, il existe d'autres façons de le faire qui n'ont pas été expliquées ici et qui peuvent même s'appliquer davantage dans d'autres situations. E. g utilisant itertools.chain Avec for. Il gère les boucles imbriquées mieux que les autres exemples.

à l'Ancienne manière:

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

liste de compréhension:

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

le moyen le plus rapide d'accéder aux index de liste dans une boucle en Python 2.7 est d'utiliser la méthode de portée 151980920" pour les petites listes et la méthode d'énumération pour les listes de taille moyenne et énorme.

s'il vous Plaît voir différentes approches qui peut être utilisé pour parcourir la liste et l'accès de l'indice de valeur et leurs mesures de performance (qui, je suppose, serait utile pour vous) dans les exemples de code ci-dessous:

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

voir paramètres de performance pour chaque méthode ci-dessous:

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

comme résultat, en utilisant la méthode range est le plus rapide jusqu'à la liste avec 1000 articles. Pour la liste avec la taille > 10 000 articles enumerate est le gagnant.

ajouter quelques liens utiles ci-dessous:

• Quelle est la différence entre la portée et fonctions xrange en Python 2.X?

• qu'est-ce qui est plus rapide pour loop en utilisant enumerate ou pour loop en utilisant xrange en Python?

• échelle(Len (list)) ou énumérer(list)?

Je ne sais pas si ce qui suit est pythonique ou non, mais il utilise la fonction Python enumerate et imprime l'index et la valeur.

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

sortie:

0 8
1 23
2 45
3 12
4 78

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 cette façon, vous pouvez étendre une liste. Prolonger signifie que vous pouvez ajouter plusieurs valeurs à la fois.

pour ajouter cette liste vous devez écrire le code ci-dessous:

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

ainsi vous pouvez ajouter une valeur unique à la fois. Si vous écrivez ints.append([1]) , cela créera une sous-liste pour cet élément.

tout d'Abord, les indices vont de 0 à 4. Les langages de programmation commencent à compter à partir de 0; ne l'oubliez pas ou vous tomberez sur une exception hors limites de l'index. Tout ce dont vous avez besoin dans la boucle for Est une variable de comptage de 0 à 4 comme ceci:

for x in range(0, 5):

gardez à l'esprit que j'ai écrit 0 à 5 parce que la boucle s'arrête un nombre avant le max. :)

pour obtenir la valeur d'un indice, utilisez

list[index]

selon cette discussion: http://bytes.com/topic/python/answers/464012-objects-list-index

compteur de Boucle d'itération

l'idiome courant pour la boucle au-dessus des indices fait usage de la fonction intégrée 'range':

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

en Boucle sur les deux éléments et indices peut être réalisé soit par le vieil idiome ou à l'aide de la nouvelle 'zip' de la fonction intégrée dans[2]:

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

ou

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

via http://www.python.org/dev/peps/pep-0212 /

vous pouvez le faire avec ce code:

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

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

Utiliser ce code si vous avez besoin de réinitialiser la valeur de l'indice à la fin de la boucle:

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

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

la meilleure solution pour ce problème est d'utiliser énumérer fonction Python in-build.

énumérer retour tuple

la première valeur est index

deuxième valeur est élément de tableau à cet indice

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)

vous pouvez aussi essayer ceci:

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 sortie est

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

vous pouvez utiliser la "méthode 151930920

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

EDIT Souligné dans le commentaire que cette méthode ne fonctionne pas s'il ya des doublons dans ints , la méthode ci-dessous devrait fonctionner pour toutes les valeurs dans ints :

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

ou alternativement

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

si vous voulez obtenir à la fois l'indice et la valeur de ints comme une liste de tuples.

il utilise la méthode de enumerate dans la réponse choisie à cette question, mais avec la compréhension de liste, ce qui le rend plus rapide avec moins de code.

si je devais itérer nums = [1,2,3,4,5] Je le ferais

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

Ou d'obtenir la longueur de l = len(nums)

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

S'il n'y a pas de valeur dupliquée dans la liste:

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

utilisez plutôt enumerate.

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

ou utiliser en dessous de:

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

vous avez reçu un certain nombre de réponses expliquant enumerate , mais si vous avez seulement besoin de l'index pour accéder aux entrées correspondantes dans deux listes, il y a une autre façon plus propre et plus simple en Python 3: zip .

par exemple, si vous utilisez l'index pour extraire les noms correspondants pour les nombres dans votre liste, vous pouvez le faire comme ceci:

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

qui produirait

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

dans votre question, vous écrivez " comment accéder à l'index de boucle, de 1 à 5 dans ce cas?"

cependant, l'index d'une liste, va de zéro. Donc, nous avons besoin de savoir si ce que vous voulez réellement est l'index et l'élément pour chaque élément dans une liste, ou si vous voulez vraiment des nombres à partir de 1. Heureusement, en python, il est facile de faire l'un ou l'autre ou les deux.

D'abord, pour clarifier, la fonction énumérer, itérativement renvoie l'index et l'item correspondant pour chaque item d'une liste.

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

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

La sortie pour le ci-dessus est alors,

0 1
1 2
2 3
3 4
4 5

notez que l'index s'exécute à partir de 0. Ce type d'indexation est commun parmi les langages de programmation modernes, y compris python et C.

si vous voulez que votre boucle couvre une partie de la liste, vous pouvez utiliser la syntaxe standard de python pour une partie de la liste. Par exemple, pour boucler la boucle à partir du deuxième élément dans un jusqu'à, mais sans le dernier article, vous pouvez utiliser

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

notez qu'une fois de plus, l'indice de sortie s'exécute à partir de 0,

0 2
1 3
2 4

qui nous amène au commutateur start=n Pour enumerate(). Cela compense simplement l'index, vous pouvez également simplement ajouter un nombre à l'index à l'intérieur de la boucle.

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

, dont la sortie est

1 1
2 2
3 3
4 4
5 5

pour imprimer un tuple de (indice, valeur) dans la liste de compréhension en utilisant une boucle for :

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

sortie:

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

cela sert assez bien le but:

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