È possibile implementare un loop Python per range senza una variabile iteratore?
Domanda
È possibile fare quanto segue senza i
?
for i in range(some_number):
# do something
Se vuoi semplicemente fare qualcosa N volte e non hai bisogno dell'iteratore.
Soluzione
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 variabile extra i
.
Ecco l'opzione per usare la variabile _
, che in realtà è solo un'altra variabile.
for _ in range(n):
do_something()
Nota che a _
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 grammatica Python , è un nome variabile accettabile :
identifier ::= (letter|"_") (letter | digit | "_")*
Altri suggerimenti
Forse stai cercando
for _ in itertools.repeat(None, times): ...
questo è IL modo più veloce per ripetere volte
volte in Python.
L'idioma generale per l'assegnazione a un valore non utilizzato è chiamarlo _
.
for _ in range(times):
do_stuff()
Ciò che tutti suggeriscono di usare _ non sta dicendo che _ viene spesso usato come scorciatoia per uno dei 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 ( Link 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 ci sia 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 + identificativo 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 utilizzato
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
USCITA:
0
1
2
3
4
5
6
7
8
9
Sono generalmente d'accordo con le soluzioni sopra indicate. Vale a dire con:
- Uso del trattino basso in
per
-loop (2 e più righe) - Definizione di un normale
mentre
contatore (3 e più righe) - Dichiarazione di una classe personalizzata con l'implementazione
__nonzero__
(molte più righe)
Se si vuole definire un oggetto come in # 3 consiglierei di implementare il protocollo per con parola chiave o applica contextlib .
Inoltre propongo ancora un'altra soluzione. È una linea 3 e non è di suprema eleganza, ma usa 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. catena racchiude due iteratori ripeti , 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 # 1 . A meno che non sia scritto come parte di una funzione, potrebbe richiedere una pulizia per volte variabile.
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
, puoi trovare anche la rel itertools repeatfunc
ricetta 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)
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 sei consapevole di non utilizzare la variabile.
x = range(5)
while x:
x.pop()
print "Work!"
Se davvero vuoi evitare di inserire 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 volevi davvero:
for type('', (), {}).x in range(somenumber):
dosomething()
Il trucco usato è creare una classe anonima type ('', (), {})
che si traduce in una classe con nome vuoto, ma NB che non è inserito nel locale o spazio dei nomi globale (anche se è stato fornito un nome non vuoto). Quindi usi 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))
Che dire di:
while range(some_number):
#do something