Accéder à l'index des boucles "pour"?

comment accéder à l'index lui-même pour une liste comme celle-ci?

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

quand je boucle à travers elle en utilisant une boucle for , comment accéder à l'index de boucle, de 1 à 5 dans ce cas?

2657
demandé sur martineau 2009-02-07 01:47:54
la source

21 ответов

utilisant une variable d'état supplémentaire, telle qu'une variable index (que vous utiliseriez normalement dans des langues telles que c ou PHP), est considéré non-pythonic.

La meilleure option est d'utiliser la fonction intégrée enumerate() , disponible en Python 2 et 3:

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

Check out PEP 279 for more.

4598
répondu Mike Hordecki 2016-09-17 13:13:51
la source

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)
536
répondu Aaron Hall 2018-03-09 18:37:27
la source

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.

106
répondu Clayton 2018-07-25 13:55:22
la source
for i in range(len(ints)):
   print i, ints[i]
70
répondu David Hanak 2009-02-07 01:49:23
la source

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.

37
répondu Charitoo 2018-02-10 23:05:16
la source

à 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)
>>> 
21
répondu Charlie Martin 2009-02-07 01:57:26
la source

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:

16
répondu Andriy Ivaneyko 2017-05-23 15:34:48
la source

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
16
répondu user2912389 2018-02-14 07:41:06
la source
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.

15
répondu iamjayp 2015-09-19 21:44:59
la source

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]
11
répondu ytpillai 2015-05-26 02:05:19
la source

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 /

9
répondu thinker007 2012-05-25 00:03:12
la source

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
9
répondu Liam 2015-05-26 13:39:28
la source

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)
8
répondu Anurag Misra 2017-08-24 09:15:31
la source

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']
3
répondu Ashok Kumar Jayaraman 2018-02-07 17:04:10
la source

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.

1
répondu killerT2333 2018-05-31 09:09:09
la source

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])
1
répondu Ankur Kothari 2018-06-04 05:10:17
la source

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])
1
répondu RIshu 2018-06-10 07:07:25
la source

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
0
répondu Gary R. 2018-02-14 22:20:43
la source

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
0
répondu DrM 2018-08-15 20:52:50
la source

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)]
-1
répondu lola 2018-04-24 13:53:56
la source

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)
-1
répondu Sumit Kumar 2018-05-15 08:41:27
la source

Autres questions sur python list loops