Accéder à l'index dans les boucles 'pour'?
Comment puis-je accéder à l'index lui-même pour une liste comme celle-ci?
ints = [8, 23, 45, 12, 78]
Lorsque je le parcours à l'aide d'une boucle for, comment puis-je accéder à l'index de la boucle, de 1 à 5 dans ce cas?
L'utilisation d'une variable d'état supplémentaire, telle qu'une variable d'index (que vous utiliseriez normalement dans des langages tels que C ou PHP), est considérée comme n'étant pas Pythonic.
La meilleure option consiste à utiliser la fonction intégrée enumerate() , disponible à la fois en Python 2 et 3:
for idx, val in enumerate(ints):
print(idx, val)
Départ PEP 279 pour plus.
À l'aide d'une boucle for, comment accéder à l'index de la boucle, de 1 à 5 dans ce cas?
Utilisez enumerate pour obtenir l'index avec l'élément au fur et à mesure de votre itération:
for index, item in enumerate(items):
print(index, item)
Et notez que les index de Python commencent à zéro, vous obtiendrez donc 0 à 4 avec ce qui précède. Si vous voulez le nombre, 1 à 5, procédez comme suit:
for count, item in enumerate(items, start=1):
print(count, item)
Flux de contrôle unidiomatique
Ce que vous demandez, c'est l'équivalent Pythonic de ce qui suit, qui est l'algorithme que la plupart des programmeurs de langages de bas niveau utiliseraient:
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é dans Python:
for index in range(len(items)): print(index, items[index])
Utiliser la fonction énumérer
La fonction enumerate de Python réduit l'encombrement visuel en masquant la comptabilisation des index et en encapsulant l'itérable dans un autre objet itérable (un objet enumerate) qui produit un tuple à deux éléments de l'index et l'article que l'itéré d'origine fournirait. . Cela ressemble à ceci:
for index, item in enumerate(items, start=0): # default is zero
print(index, item)
Cet exemple de code est assez bien l’exemple canonical de la différence entre un code idiomatique de Python et un code qui ne l’est pas. Le code idiomatique est sophistiqué (mais pas compliqué) en Python, écrit de la manière dont il était destiné. Le code idiomatique est attendu par les concepteurs du langage, ce qui signifie que ce code est généralement non seulement plus lisible, mais également plus efficace.
Obtenir un compte
Même si vous n'avez pas besoin d'index au fur et à mesure, mais vous avez besoin d'un décompte des itérations (parfois souhaitable), vous pouvez commencer par 1 et le nombre final sera votre décompte.
for count, item in enumerate(items, start=1): # default is zero
print(item)
print('there were {0} items printed'.format(count))
Le nombre semble être plus ce que vous avez l'intention de demander (par opposition à index) lorsque vous avez dit que vous vouliez de 1 à 5.
Décomposer - une explication étape par étape
Pour décomposer ces exemples, supposons que nous ayons une liste d’items que nous souhaitons parcourir avec un index:
items = ['a', 'b', 'c', 'd', 'e']
Nous passons maintenant cet itératif à énumérer, créant un objet énuméré:
enumerate_object = enumerate(items) # the enumerate object
Nous pouvons extraire le premier élément de cette variable 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 nuplet de 0, le premier index, et 'a', le premier élément:
(0, 'a')
nous pouvons utiliser ce que nous appelons " sequence unpacking " pour extraire les éléments de ce deux -uple:
index, item = iteration
# 0, 'a' = (0, 'a') # essentially this.
et lorsque nous inspectons index, nous constatons qu'il fait référence au premier index, 0 et item au premier élément, 'a'.
>>> print(index)
0
>>> print(item)
a
Conclusion
- Les index Python commencent à zéro
- Pour obtenir ces index à partir d'un itérable lorsque vous le parcourez, utilisez la fonction énumérer
- Utiliser énumérer de manière idiomatique (avec le décompression de Tuple) crée un code plus lisible et maintenable:
Alors faites ceci:
for index, item in enumerate(items, start=0): # Python indexes start at zero
print(index, item)
C'est assez simple de le démarrer depuis 1 autre que 0:
for index, item in enumerate(iterable, start=1):
print index, item
Remarque
Conseil important, bien qu'un peu trompeur puisque index sera un Tuple(idx, item) ici .
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. Utiliser énumérer ( 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 car les chances d'entrer dans une récursion infinie ont été éliminées. L'élément et son index sont tous deux contenus dans des variables et il n'est pas nécessaire d'écrire d'autre codepour accéder à l'élément.
2. Créer une variable pour contenir l’index ( en utilisant for)
for index in range(len(lst)): # or xrange
# you will have to write extra code to get the element
3. Créer une variable pour contenir l’index ( 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 moyen
Comme expliqué précédemment, il existe d'autres moyens de le faire qui n'ont pas été expliqués ici et ils peuvent même s'appliquer davantage dans d'autres situations. par exemple en utilisant itertools.chain avec pour. Il gère mieux les boucles imbriquées que les autres exemples.
Manière ancienne:
for ix in range(len(ints)):
print ints[ix]
Compréhension de la liste:
[ (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)
>>>
Je ne sais pas si ce qui suit est Pythonic ou non, mais il utilise la fonction Python enumerate et affiche 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
Le moyen le plus rapide d’accéder aux index de liste dans une boucle dans Python 2.7 consiste à utiliser la méthode range pour les petites listes et la méthode enumerate pour les listes de taille moyenne et énorme.
Veuillez consulter différentes approches qui peuvent être utilisées pour parcourir la liste et la valeur d'index d'accès et leurs métriques de performance (qui, je suppose, vous seraient utiles) 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 les mesures 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
En conséquence, utiliser la méthode range est la plus rapide avec une liste de 1 000 éléments. Pour les listes de taille> 10 000 éléments, enumerate est le gagnant.
Ajout de quelques liens utiles ci-dessous:
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. Étendre signifie que vous pouvez ajouter plusieurs valeurs à la fois.
Pour ajouter cette liste, vous devez écrire le code donné ci-dessous:
ints = [9, 23, 45, 12, 78]
ints.append([1])
for idx, val in enumerate(ints):
print(idx,val)
De cette façon, vous pouvez ajouter une seule valeur à la fois. Si vous écrivez ints.append([1]), cela créera une sous-liste pour cet élément.
Premièrement, les index vont de 0 à 4. Les langages de programmation commencent à compter à partir de 0; N'oubliez pas cela sinon vous rencontrerez une exception d'index hors limites. Tout ce dont vous avez besoin dans la boucle for est une variable comptant de 0 à 4 comme ceci:
for x in range(0, 5):
N'oubliez pas que j'ai écrit 0 à 5 car la boucle arrête un nombre avant le maximum. :)
Pour obtenir la valeur d'un index, utilisez
list[index]
Vous pouvez le faire avec ce code:
ints = [8, 23, 45, 12, 78]
index = 0
for value in (ints):
index +=1
print index, value
Utilisez ce code si vous devez réinitialiser la valeur d'index à 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
Selon cette discussion: http://bytes.com/topic/python/answers/464012-objects-list-index
Boucle compteur itération
L'idiome actuel pour la boucle sur les index utilise la fonction intégrée "range":
for i in range(len(sequence)):
# work with index i
Le bouclage sur les éléments et les indices peut être réalisé soit par l'ancien langage, soit en utilisant la nouvelle fonction intégrée 'Zip' [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
La meilleure solution à ce problème consiste à utiliser énumérer la fonction python en construction.
énumérer retourner Tuple
première valeur est index
seconde valeur est élément du tableau à cet index
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)
S'il n'y a pas de valeur en double dans la liste:
for i in ints:
indx = ints.index(i)
print(i,indx)
Sinon, utilisez enumerate.
for counter, value in enumerate(ints):
print(counter, value)
OU utiliser ci-dessous:
for counter in range(len(ints)):
print(counter, ints[counter])
Voici ce que vous obtenez lorsque vous accédez à l'index dans les boucles for:
for i in enumerate(items): print(i)
for i, val in enumerate(items): print(i, val)
for i, val in enumerate(items): print(i)
J'espère que cela t'aides.
Dans votre question, vous écrivez "comment puis-je accéder à l'index de la boucle, de 1 à 5 dans ce cas?"
Cependant, l'index d'une liste commence à zéro. Nous devons donc savoir si vous souhaitez réellement obtenir l’index et l’élément de chaque élément d’une liste, ou si vous souhaitez réellement que les nombres commencent par 1. Heureusement, en python, il est facile de faire l’un ou les deux.
Tout d'abord, pour clarifier, la fonction énumérer renvoie de manière itérative l'index et l'élément correspondant pour chaque élément d'une liste.
alist = [ 1, 2, 3, 4, 5 ]
for n,a in enumerate(alist):
print( "%d %d"%(n,a) )
La sortie pour ce qui précède est alors,
0 1
1 2
2 3
3 4
4 5
Notez que l'index va de 0. Ce type d'indexation est commun aux langages de programmation modernes, notamment python et c.
Si vous souhaitez que votre boucle couvre une partie de la liste, vous pouvez utiliser la syntaxe python standard pour une partie de la liste. Par exemple, pour faire une boucle à partir du deuxième élément de la liste sans inclure le dernier élément, vous pouvez utiliser
for n,a in enumerate(alist[1:-1]):
print( "%d %d"%(n,a) )
Notez que, une fois encore, l’index de sortie court de 0,
0 2
1 3
2 4
Cela nous amène au début = n commutateur pour enumerate (). Cela compense simplement l'index, vous pouvez simplement ajouter un nombre équivalent à l'index à l'intérieur de la boucle.
for n,a in enumerate(alist,start=1):
print( "%d %d"%(n,a) )
pour lequel la sortie est
1 1
2 2
3 3
4 4
5 5
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']
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 obtenez la longueur comme l = len (nums)
for i in range(1, l + 1):
print(i, nums[i])
Vous pouvez utiliser la méthode index
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 existe 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 bien
ints = [8, 8, 8, 23, 45, 12, 78]
inds = [tup for tup in enumerate(ints)]
si vous voulez obtenir à la fois l'index et la valeur dans ints sous forme de liste de tuples.
Il utilise la méthode enumerate dans la réponse sélectionnée à cette question, mais avec une compréhension de liste, ce qui le rend plus rapide avec moins de code.
Pour imprimer le tuple de (index, valeur) en compréhension de liste à l'aide d'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)
Cela peut aussi être fait en utilisant la méthode index()
for i in ints:
print(ints.index(i), i)
Ici, l'indexation commence à 0. Mais au cas où vous auriez besoin de le démarrer à partir de 1, ajoutez simplement 1 à la méthode index() comme suit
for i in int:
print(int.index(i) + 1, i)