Question Accéder à l'index dans les boucles 'for'?


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

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

Quand je boucle en utilisant un for boucle, comment puis-je accéder à l'index de boucle, de 1 à 5 dans ce cas?


2560
2018-02-06 22:47


origine


Réponses:


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 non-pythonique.

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

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

Check-out PEP 279 pour plus.


4444
2018-02-06 22:52



En utilisant une boucle for, comment accéder à l'index de boucle, de 1 à 5 dans ce cas?

Utilisation enumerate pour obtenir l'index avec l'élément pendant 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 nombre, 1 à 5, faites ceci:

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

Flux de contrôle unidomatique

Ce que vous demandez est l'équivalent Pythonic de ce qui suit, qui est l'algorithme que la plupart des programmeurs des 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 les langues qui n'ont pas de boucle pour chaque:

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

ou parfois plus souvent (mais unidiomatically) trouvé dans Python:

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

Utilisez la fonction Enumerate

Python enumerate fonction réduit l'encombrement visuel en cachant la comptabilité pour les index, et en encapsulant l'itérable dans un autre itérable (un enumerate object) qui fournit un tuple à deux items de l'index et l'item que l'itérable original 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 le canonique exemple de la différence entre le code idiomatique de Python et le code qui ne l'est pas. Le code idiomatique est sophistiqué (mais pas compliqué) Python, é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 n'est pas seulement plus lisible, mais aussi plus efficace.

Obtenir un compte

Même si vous n'avez pas besoin d'index au fur et à mesure, mais que vous avez besoin du 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 compte semble être plus ce que vous avez l'intention de demander (par opposition à l'index) quand vous avez dit que vous vouliez de 1 à 5.


Briser - une explication étape par étape

Pour résumer ces exemples, disons que nous avons une liste d'éléments que nous voulons parcourir avec un index:

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

Maintenant, nous passons ce itérable à énumérer, en créant un objet énumération:

enumerate_object = enumerate(items) # the enumerate object

Nous pouvons tirer le premier élément de cette itérable que nous aurions dans une boucle avec le next fonction:

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 que l'on appelle "séquence déballage"pour extraire les éléments de ce deux-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 é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 pendant que vous le survolez, utilisez la fonction enumerate
  • Utiliser enumerate de la manière idiomatique (avec tuple unpacking) 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)

516
2018-01-21 17:11



C'est assez simple de le démarrer à partir de 1 autre que 0:

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

Remarque

Conseil important, mais un peu trompeur depuis index va etre un tuple  (idx, item) ici. Bon à faire.


105
2018-05-27 10:04



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

67
2018-02-06 22:49



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

1. En utilisant é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 parce que la chance d'entrer dans la récurrence infinie a été éliminée. L'élément et son index sont détenus dans des variables et il n'est pas nécessaire d'écrire du code supplémentaire pour accéder à l'article.

2. Création d'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éation d'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 plus dans d'autres situations. par exemple en utilisant itertools.chain avec pour. Il gère mieux les boucles imbriquées que les autres exemples.


34
2017-08-15 02:17



Façon à l'ancienne:

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

20
2018-02-06 22:52



Le moyen le plus rapide d'accéder aux index de la liste dans la boucle Python 2.7 est d'utiliser le méthode de gamme pour les petites listes et énumérer la méthode pour les listes de taille moyenne et énorme.

S'il te plait regarde différentes approches qui peut être utilisé pour itérer sur la liste et la valeur de l'index d'accès et leurs métriques de performance (ce que 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

Consultez les statistiques 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, en utilisant range méthode est la plus rapide jusqu'à la liste avec 1000 articles. Pour liste avec taille> 10 000 articles enumerate est le gagnant.

Ajout de quelques liens utiles ci-dessous:


16
2017-08-04 09:49



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
2017-10-28 18:17



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 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 va créer une sous-liste pour cet élément.


15
2018-02-05 17:28