¿Existe una expresión para un generador infinito?

¿Existe una expresión generadora sencilla que pueda producir elementos infinitos?

Ésta es una cuestión puramente teórica. No hay necesidad de una respuesta "práctica" aquí :)

Por ejemplo, es fácil hacer un generador finito:

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

Sin embargo, para hacer uno infinito, necesito "contaminar" mi espacio de nombres con una función falsa:

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

Hacer las cosas en un archivo separado y importhacerlas más tarde no cuenta.

También sé que itertools.repeathace exactamente esto. Tengo curiosidad por saber si hay una solución de una sola línea sin eso.

for x in iter(int, 1): pass

• Dos argumentos iter= cero argumentos invocables + valor centinela
• int() siempre vuelve 0

Por tanto, iter(int, 1)es un iterador infinito. Obviamente, hay una gran cantidad de variaciones sobre este tema en particular (especialmente una vez que lo agregas lambdaa la mezcla). Una variante de particular interés es iter(f, object())que el uso de un objeto recién creado como valor centinela casi garantiza un iterador infinito independientemente del invocable utilizado como primer argumento.

itertools proporciona tres generadores infinitos:

• 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, ...

No conozco a ningún otro en la biblioteca estándar.

Ya que pediste una sola línea:

__import__("itertools").count()

puede iterar sobre un invocable devolviendo una constante siempre diferente al centinela de iter ()

g1=iter(lambda:0, 1)

Su sistema operativo puede proporcionar algo que se puede utilizar como un generador infinito. Por ejemplo, en linux

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

obviamente esto no es tan eficiente como

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

Ninguno que no use internamente otro iterador infinito definido como una clase / función / generador (no -expresión, una función con yield). Una expresión generadora siempre se basa en otro iterable y no hace más que filtrar y mapear sus elementos. No puede pasar de elementos finitos a infinitos con solo mapy filter, lo necesita while(o un forque no termina, que es exactamente lo que no podemos tener usando solo foriteradores finitos).

Trivia: PEP 3142 es superficialmente similar, pero tras una inspección más cercana parece que todavía requiere la forcláusula (así que no (0 while True)para usted), es decir, solo proporciona un atajo para itertools.takewhile.

Bastante feo y loco (sin embargo, muy divertido), pero puedes construir tu propio iterador a partir de una expresión usando algunos trucos (sin "contaminar" tu espacio de nombres como sea necesario):

{ 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,), {}))() } 

Tal vez podrías usar decoradores como este, por ejemplo:

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

Uso (1):

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

for i in blah():
    print i

Uso (2)

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

Creo que se podría mejorar aún más para deshacernos de esos feos (). Sin embargo, depende de la complejidad de la secuencia que desee poder crear. En términos generales, si su secuencia se puede expresar usando funciones, entonces toda la complejidad y el azúcar sintáctico de los generadores se puede ocultar dentro de un decorador o una función similar al decorador.