Esiste un'espressione per un generatore infinito?

Esiste un'espressione generatrice diretta che può produrre infiniti elementi?

Questa è una domanda puramente teorica. Non c'è bisogno di una risposta "pratica" qui :)

Ad esempio, è facile creare un generatore finito:

my_gen = (0 for i in xrange(42))

Tuttavia, per crearne uno infinito ho bisogno di "inquinare" il mio spazio dei nomi con una funzione fasulla:

def _my_gen():
    while True:
        yield 0
my_gen = _my_gen()

Fare le cose in un file separato e in importseguito non conta.

So anche che itertools.repeatfa esattamente questo. Sono curioso di sapere se esiste una soluzione a una riga senza di essa.

for x in iter(int, 1): pass

• Due argomenti iter= chiamabile senza argomenti + valore sentinella
• int() ritorna sempre 0

Pertanto, iter(int, 1)è un iteratore infinito. Ci sono ovviamente un numero enorme di variazioni su questo particolare tema (specialmente una volta aggiunto lambdaal mix). Una variante di particolare nota è iter(f, object())che l'utilizzo di un oggetto appena creato come valore sentinella garantisce quasi un iteratore infinito indipendentemente dal chiamabile utilizzato come primo argomento.

itertools fornisce tre generatori infiniti:

• count(start=0, step=1): 0, 1, 2, 3, 4, ...

• cycle(p): p [0], p [1], ..., p [-1], p [0], ...

• repeat(x, times=∞): x, x, x, x, ...

Non conosco nessun altro nella libreria standard.

Dato che hai chiesto una battuta:

__import__("itertools").count()

è possibile iterare su un richiamabile restituendo una costante sempre diversa dalla sentinella di iter ()

g1=iter(lambda:0, 1)

Il tuo sistema operativo potrebbe fornire qualcosa che può essere utilizzato come generatore infinito. Ad esempio su Linux

for i in (0 for x in open('/dev/urandom')):
    print i

ovviamente questo non è efficiente come

for i in __import__('itertools').repeat(0)
    print i

Nessuno che non utilizzi internamente un altro iteratore infinito definito come classe / funzione / generatore (non -expression, una funzione con yield). Un'espressione generatore attinge sempre da un oggetto iterabile e non fa altro che filtrare e mappare i suoi elementi. Non puoi passare da elementi finiti a infiniti con solo mape filter, di cui hai bisogno while(o un forche non termina, che è esattamente ciò che non possiamo avere usando solo fore finiti iteratori).

Curiosità: PEP 3142 è superficialmente simile, ma a un esame più attento sembra che richieda ancora la forclausola (quindi no (0 while True)per te), ovvero fornisce solo una scorciatoia per itertools.takewhile.

Abbastanza brutto e folle (molto divertente comunque), ma puoi costruire il tuo iteratore da un'espressione usando alcuni trucchi (senza "inquinare" il tuo spazio dei nomi come richiesto):

{ print("Hello world") for _ in
    (lambda o: setattr(o, '__iter__', lambda x:x)
            or setattr(o, '__next__', lambda x:True)
            or o)
    (type("EvilIterator", (object,), {}))() } 

Forse potresti usare decoratori come questo, ad esempio:

def generator(first):
    def wrap(func):
        def seq():
            x = first
            while True:
                yield x
                x = func(x)
        return seq
    return wrap

Utilizzo (1):

@generator(0)
def blah(x):
    return x + 1

for i in blah():
    print i

Utilizzo (2)

for i in generator(0)(lambda x: x + 1)():
    print i

Penso che potrebbe essere ulteriormente migliorato per sbarazzarsi di quelli brutti (). Tuttavia dipende dalla complessità della sequenza che si desidera poter creare. In generale, se la tua sequenza può essere espressa utilizzando le funzioni, tutta la complessità e lo zucchero sintattico dei generatori possono essere nascosti all'interno di un decoratore o di una funzione simile a un decoratore.