Comment puis-je limiter le nombre d'itérations d'une boucle en Python?

Comment puis-je limiter le nombre d'itérations d'une boucle en Python?

for index, item in enumerate(items):
    print(item)
    if index == limit:
        break

Est-il plus court, idiomatiques façon d'écrire ci-dessus? Comment?

Y compris l'indice

zip s'arrête sur la plus courte de itératif de ses arguments. (En contraste avec le comportement de zip_longest, qui utilise la plus longue itératif.)

range peut fournir un limitées itératif que nous pouvons passer à zip avec notre principal objet iterable.

Afin que nous puissions passer un range objet (avec ses stop argument) pour zip et l'utiliser comme un limitées énumérer.

zip(range(limit), items)

À l'aide de Python 3, zip et range retour iterables, qui pipeline de données au lieu de matérialiser les données dans les listes pour les étapes intermédiaires.

for index, item in zip(range(limit), items):
    print(index, item)

Pour obtenir le même comportement en Python 2, en remplaçant simplement l' xrange pour range et itertools.izip pour zip.

from itertools import izip
for index, item in izip(xrange(limit), items):
    print(item)

Si ne nécessitant pas l'indice, itertools.islice

Vous pouvez utiliser itertools.islice:

for item in itertools.islice(items, 0, stop):
    print(item)

qui ne nécessite pas d'assigner à l'index.

La composition enumerate(islice(items, stop)) pour obtenir l'index

Comme Pablo Ruiz Ruiz points, nous pouvons également composer islice avec énumérer.

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

Pourquoi n'est-ce pas intégré dans enumerate?

Ici la liste de mises en œuvre en pur Python (avec des modifications possibles pour obtenir le comportement souhaité dans les commentaires):

def enumerate(collection, start=0):  # could add stop=None
    i = start
    it = iter(collection)
    while 1:                         # could modify to `while i != stop:`
        yield (i, next(it))
        i += 1

Ci-dessus serait moins performant pour ceux qui utilisent les énumérer déjà, parce qu'il aurait pour vérifier si il est temps de s'arrêter à chaque itération. Il nous suffit de vérifier et utiliser l'ancien énumérer si vous n'obtenez pas un arrêt argument:

_enumerate = enumerate

def enumerate(collection, start=0, stop=None):
    if stop is not None:
        return zip(range(start, stop), collection)
    return _enumerate(collection, start)

Cette vérification supplémentaire aurait une légère négligeable l'impact sur les performances.

À pourquoi énumérer ne dispose pas d'un arrêt d'argument, il a été proposé à l'origine (voir PEP 279):

Cette fonction a été proposé à l'origine avec l'option de démarrage
et arrêter arguments. GvR [Guido van Rossum], a souligné que l'appel de la fonction
enumerate(seqn, 4, 6) avait une autre interprétation plausible
une tranche qui permettraient de redonner à la quatrième et cinquième éléments de la
la séquence. Pour éviter l'ambiguïté, les arguments facultatifs ont été
abandonné, même s'il devait perdre de la souplesse, comme un compteur de boucle.
De flexibilité, ce qui était le plus important pour le cas courant d'
en comptant à partir de l'un, comme dans:

for linenum, line in enumerate(source,1):  print linenum, line

Donc, apparemment, start a été maintenu, car il a été très précieux, et stop a été abandonné car il a eu moins de cas d'utilisation et contribué à la confusion sur l'utilisation de la nouvelle fonction.

Éviter de trancher avec indice de notation

Une autre réponse dit:

Pourquoi ne pas simplement utiliser

for item in items[:limit]: # or limit+1, depends

Voici quelques-uns:

• Elle ne fonctionne que pour iterables qui acceptent de découpage, il est donc plus limitée.
• Si ils acceptent de découpage, il crée une nouvelle structure de données en mémoire, au lieu de parcourir les données de référence de la structure, donc il gaspille de mémoire (Tous les builtin objets en faire des copies lors de la tranchée, mais, par exemple, des tableaux numpy faire une vue lorsque tranches).
• Unsliceable iterables nécessiterait l'autre type de manipulation. Si vous passez à un paresseux modèle d'évaluation, vous devrez modifier le code avec le découpage en tant que bien.

Vous devez uniquement utiliser le découpage indice de notation lorsque vous comprendre les limites et s'il rend une copie ou d'un point de vue.

Conclusion

Je présume que maintenant la communauté Python sait l'utilisation d'énumérer, la confusion des coûts serait compensé par la valeur de l'argument.

Jusqu'à ce que le temps, vous pouvez utiliser:

for index, element in zip(range(limit), items):
    ...

ou

for index, item in enumerate(islice(items, limit)):
    ...

ou, si vous n'avez pas besoin de l'indice à tous:

for element in islice(items, 0, limit):
    ...

Et d'éviter de trancher avec indice de notation, à moins de comprendre les limites.

Pourquoi ne pas simplement utiliser

for item in items[:limit]: # or limit+1, depends
    print(item)    # or whatever function of that item.

Cela ne fonctionne que pour certains iterables, mais depuis que vous avez spécifié les Listes, il fonctionne.

Il ne fonctionne pas si vous utilisez des Ensembles ou des dicts etc.

Pourquoi ne pas en boucle jusqu'à la limite ou la fin de la liste, selon la première éventualité, comme ceci:

items = range(10)
limit = 5
for i in range(min(limit, len(items))):
  print items[i]

De sortie:

0
1
2
3
4