Existe uma expressão para um gerador infinito?

Existe uma expressão geradora direta que pode produzir elementos infinitos?

Esta é uma questão puramente teórica. Não há necessidade de uma resposta "prática" aqui :)

Por exemplo, é fácil fazer um gerador finito:

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

No entanto, para fazer um infinito, preciso "poluir" meu namespace com uma função falsa:

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

Fazer as coisas em um arquivo separado e fazer importmais tarde não conta.

Eu também sei que itertools.repeatfaz exatamente isso. Estou curioso para saber se existe uma solução de uma linha sem isso.

for x in iter(int, 1): pass

• Dois argumentos iter= zero argumento chamável + valor sentinela
• int() sempre retorna 0

Portanto, iter(int, 1)é um iterador infinito. Obviamente, há um grande número de variações sobre este tema em particular (especialmente quando você adiciona lambdaà mistura). Uma variante de nota particular é iter(f, object()), como usar um objeto recém-criado como o valor sentinela quase garante um iterador infinito, independentemente do chamável usado como o primeiro argumento.

itertools fornece três geradores 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, ...

Não conheço nenhum outro na biblioteca padrão.

Já que você pediu um one-liner:

__import__("itertools").count()

você pode iterar sobre um callable retornando uma constante sempre diferente da sentinela de iter ()

g1=iter(lambda:0, 1)

Seu sistema operacional pode fornecer algo que pode ser usado como um gerador infinito. Por exemplo, no Linux

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

obviamente, isso não é tão eficiente quanto

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

Nenhum que não use internamente outro iterador infinito definido como uma classe / função / gerador (não -expressão, uma função com yield). Uma expressão geradora sempre extrai de outra iterável e não faz nada além de filtrar e mapear seus itens. Você não pode ir de itens finitos para infinitos com apenas mape filter, você precisa while(ou um forque não termina, que é exatamente o que não podemos ter usando apenasfor iteradores e finitos).

Curiosidades: PEP 3142 é superficialmente semelhante, mas após uma inspeção mais detalhada, parece que ainda requer a forcláusula (portanto, não (0 while True)para você), ou seja, fornece apenas um atalho para itertools.takewhile.

Bastante feio e louco (muito engraçado no entanto), mas você pode construir seu próprio iterador a partir de uma expressão usando alguns truques (sem "poluir" seu namespace conforme necessário):

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

Talvez você possa usar decoradores como este, por exemplo:

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

Acho que poderia ser melhorado para se livrar dessas coisas feias (). No entanto, depende da complexidade da sequência que você deseja criar. Falando de maneira geral, se sua sequência pode ser expressa usando funções, então toda a complexidade e açúcar sintático dos geradores podem ser escondidos dentro de um decorador ou de uma função do tipo decorador.