È possibile implementare un loop Python per range senza una variabile iteratore?

È possibile fare quanto segue senza il i?

for i in range(some_number):
    # do something

Se vuoi solo fare qualcosa N volte e non hai bisogno dell'iteratore.

Fuori dalla mia testa, no.

Penso che il meglio che potresti fare sia qualcosa del genere:

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

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

Ma penso che tu possa semplicemente vivere con la ivariabile extra .

Ecco l'opzione per usare la _variabile, che in realtà è solo un'altra variabile.

for _ in range(n):
    do_something()

Si noti che _viene assegnato l'ultimo risultato restituito in una sessione interattiva di Python:

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

Per questo motivo, non lo userei in questo modo. Non sono a conoscenza di alcun linguaggio come menzionato da Ryan. Può rovinare il tuo interprete.

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

E secondo la grammatica di Python , è un nome variabile accettabile:

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

Forse stai cercando

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

questo è il modo più veloce per ripetere i timestempi in Python.

L'idioma generale per l'assegnazione a un valore non utilizzato è di nominarlo _.

for _ in range(times):
    do_stuff()

Quello che tutti ti suggeriscono di usare _ non sta dicendo che _ è spesso usato come scorciatoia per una delle funzioni di gettext , quindi se vuoi che il tuo software sia disponibile in più di una lingua, è meglio evitare di usarlo per altri scopi.

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

Ecco un'idea casuale che utilizza (abusa?) Il modello di dati ( collegamento Py3 ).

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

Mi chiedo se c'è qualcosa di simile nelle librerie standard?

È possibile utilizzare _11 (o qualsiasi numero o un altro identificatore non valido) per impedire la modifica del nome con gettext. Ogni volta che usi underscore + identificatore non valido ottieni un nome fittizio che può essere usato per il ciclo.

La risposta potrebbe dipendere dal problema che hai con l'utilizzo dell'iteratore? può essere l'uso

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

o

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

loop(100, lambda a:a)

ma francamente non vedo alcun senso nell'utilizzare tali approcci

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

PRODUZIONE:

0
1 
2 
3 
4 
5 
6 
7
8
9

Invece di un contatore non necessario, ora hai un elenco non necessario. La soluzione migliore è utilizzare una variabile che inizia con "_", che indica ai controllori della sintassi che si è consapevoli di non utilizzare la variabile.

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

Sono generalmente d'accordo con le soluzioni sopra indicate. Vale a dire con:

1. Uso del trattino basso in for-loop (2 e più righe)
2. Definizione di un whilecontatore normale (3 e più righe)
3. Dichiarazione di una classe personalizzata con __nonzero__implementazione (molte più righe)

Se uno deve definire un oggetto come in # 3 , consiglierei di implementare il protocollo con la parola chiave o applicare il contestolib .

Inoltre propongo ancora un'altra soluzione. È un 3 liner e non è di suprema eleganza, ma utilizza il pacchetto itertools e quindi potrebbe essere di interesse.

from itertools import (chain, repeat)

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

In questo esempio 2 è il numero di volte per ripetere il ciclo. chain sta avvolgendo due ripetitori iteratori, il primo è limitato ma il secondo è infinito. Ricorda che questi sono veri oggetti iteratori, quindi non richiedono memoria infinita. Ovviamente questo è molto più lento della soluzione n . 1 . A meno che non sia scritto come parte di una funzione, potrebbe richiedere una pulizia per la variabile times .

Ci siamo divertiti con i seguenti, interessanti da condividere così:

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

risultati:

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

Se do_somethingè una funzione semplice o può essere racchiusa in una, una semplice map()può do_something range(some_number)volte:

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

Se vuoi passare argomenti a do_something, potresti anche trovare la ricetta di itertools cherepeatfunc legge bene:

Per passare gli stessi argomenti:

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)

Per passare argomenti diversi:

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

deque(starmap(do_something, argses), 0)

Se vuoi davvero evitare di mettere qualcosa con un nome (o una variabile di iterazione come nell'OP, o elenco indesiderato o generatore indesiderato che restituisce vero il tempo desiderato), puoi farlo se davvero volessi:

for type('', (), {}).x in range(somenumber):
    dosomething()

Il trucco utilizzato è quello di creare una classe anonima type('', (), {})che si traduce in una classe con nome vuoto, ma NB che non è inserito nello spazio dei nomi locale o globale (anche se è stato fornito un nome non vuoto). Quindi si utilizza un membro di quella classe come variabile di iterazione che è irraggiungibile poiché la classe di cui è membro non è raggiungibile.

#Return first n items of the iterable as a list
list(itertools.islice(iterable, n))

Tratto da http://docs.python.org/2/library/itertools.html

Che dire:

while range(some_number):
    #do something