web-dev-qa-db-fra.com

Est-il possible d'implémenter une boucle Python) sans variable d'itérateur?

Est-il possible de suivre sans le i?

for i in range(some_number):
    # do something

Si vous voulez juste faire quelque chose N fois et que vous n’avez pas besoin de l’itérateur.

pythonloopsfor-looprange
172
James McMahon

De mémoire, non.

Je pense que le mieux que vous puissiez faire est quelque chose comme ceci:

def loop(f,n):
    for i in xrange(n): f()

loop(lambda: <insert expression here>, 5)

Mais je pense que vous pouvez simplement vivre avec la variable supplémentaire i.

Voici la possibilité d'utiliser le _ variable qui, en réalité, n’est qu’une autre variable.

for _ in range(n):
    do_something()

Notez que _ se voit attribuer le dernier résultat renvoyé dans une session interactive python:

>>> 1+2
3
>>> _
3

Pour cette raison, je ne l'utiliserais pas de cette manière. Je ne suis au courant d'aucun idiome mentionné par Ryan. Cela peut gâcher votre interprète.

>>> for _ in xrange(10): pass
...
>>> _
9
>>> 1+2
3
>>> _
9

Et selon grammaire Python , il s’agit d’un nom de variable acceptable:

identifier ::= (letter|"_") (letter | digit | "_")*
96
Unknown

Vous cherchez peut-être

for _ in itertools.repeat(None, times): ...

c'est LE moyen le plus rapide d'itérer times fois en Python.

68
Alex Martelli

L'idiome général pour assigner une valeur qui n'est pas utilisée est de la nommer _.

for _ in range(times):
    do_stuff()
55
Ryan

Ce que tout le monde vous suggère d’utiliser _ ne dit pas que _ est fréquemment utilisé comme raccourci vers l’une des fonctions gettext , donc si vous voulez que votre logiciel soit disponible dans plus d’une langue, alors vous devez: Il vaut mieux éviter de l'utiliser à d'autres fins.

import gettext
gettext.bindtextdomain('myapplication', '/path/to/my/language/directory')
gettext.textdomain('myapplication')
_ = gettext.gettext
# ...
print _('This is a translatable string.')
18
Ignacio Vazquez-Abrams

Voici une idée aléatoire qui utilise (abuse?) Le modèle de données ( lien Py ).

class Counter(object):
    def __init__(self, val):
        self.val = val

    def __nonzero__(self):
        self.val -= 1
        return self.val >= 0
    __bool__ = __nonzero__  # Alias to Py3 name to make code work unchanged on Py2 and Py3

x = Counter(5)
while x:
    # Do something
    pass

Je me demande s'il y a quelque chose comme ça dans les bibliothèques standard?

9
saffsd

Vous pouvez utiliser _11 (ou un nombre ou un autre identifiant non valide) pour empêcher la coloration de noms avec gettext. Chaque fois que vous utilisez un trait de soulignement + identificateur non valide, vous obtenez un nom factice pouvant être utilisé dans la boucle for.

7
JirkaV

Peut-être que la réponse dépend du problème que vous avez avec l’utilisation de l’itérateur? peut être utiliser

i = 100
while i:
    print i
    i-=1

ou

def loop(N, doSomething):
    if not N:
        return
    print doSomething(N)
    loop(N-1, doSomething)

loop(100, lambda a:a)

mais franchement je ne vois aucun intérêt à utiliser de telles approches

2
Anurag Uniyal
t=0    
for _ in range(10):
    print t
    t = t+1

SORTIE:

0
1 
2 
3 
4 
5 
6 
7
8
9
1
Imran Farid

Si do_something Est une fonction simple ou peut être encapsulé dans une seule fonction, une simple map() peut do_somethingrange(some_number) fois:

# Py2 version - map is eager, so it can be used alone
map(do_something, xrange(some_number))

# Py3 version - map is lazy, so it must be consumed to do the work at all;
# wrapping in list() would be equivalent to Py2, but if you don't use the return
# value, it's wastefully creating a temporary, possibly huge, list of junk.
# collections.deque with maxlen 0 can efficiently run a generator to exhaustion without
# storing any of the results; the itertools consume recipe uses it for that purpose.
from collections import deque

deque(map(do_something, range(some_number)), 0)

Si vous voulez passer des arguments à do_something, Vous pouvez aussi trouver la recette itertools repeatfunc se lit bien:

Pour passer les mêmes arguments:

from collections import deque
from itertools import repeat, starmap

args = (..., my args here, ...)

# Same as Py3 map above, you must consume starmap (it's a lazy generator, even on Py2)
deque(starmap(do_something, repeat(args, some_number)), 0)

Pour passer différents arguments:

argses = [(1, 2), (3, 4), ...]

deque(starmap(do_something, argses), 0)
0
mtd

Je suis généralement d'accord avec les solutions données ci-dessus. À savoir avec:

  1. Utilisation du trait de soulignement dans la boucle for2 lignes ou plus)
  2. Définir un compteur while normal (3 lignes et plus)
  3. Déclarer une classe personnalisée avec __nonzero__ implémentation (beaucoup plus de lignes)

Si l’on veut définir un objet comme dans # 3 , je recommanderais l’implémentation du protocole pour --- ( avec mot-clé. ou appliquer contextlib .

De plus, je propose encore une autre solution. C'est un 3-liner et n'est pas d'une élégance suprême, mais il utilise le package itertools et pourrait donc présenter un intérêt.

from itertools import (chain, repeat)

times = chain(repeat(True, 2), repeat(False))
while next(times):
    print 'do stuff!'

Dans cet exemple 2 est le nombre de fois où itérer la boucle. chain encapsule deux répéteurs , le premier étant limité mais le second est infini. Rappelez-vous que ce sont de vrais objets itérateurs, par conséquent, ils ne nécessitent pas de mémoire infinie. Évidemment, cela est beaucoup plus lent que la solution # 1 . Sauf si elle est écrite en tant que partie d’une fonction, elle peut nécessiter un nettoyage de la variable fois .

0
Yauhen Yakimovich

Au lieu d'un compteur inutile, vous avez maintenant une liste inutile. La meilleure solution consiste à utiliser une variable commençant par "_", qui indique aux vérificateurs de syntaxe que vous savez que vous n'utilisez pas la variable.

x = range(5)
while x:
  x.pop()
  print "Work!"
0
Robert Jacobs

Nous nous sommes amusés avec les éléments suivants, intéressants à partager:

class RepeatFunction:
    def __init__(self,n=1): self.n = n
    def __call__(self,Func):
        for i in xrange(self.n):
            Func()
        return Func


#----usage
k = 0

@RepeatFunction(7)                       #decorator for repeating function
def Job():
    global k
    print k
    k += 1

print '---------'
Job()

Résultats:

0
1
2
3
4
5
6
---------
7
0
Developer