Czy istnieje wyrażenie na nieskończony generator?

Czy istnieje proste wyrażenie generatora, które może dać nieskończone elementy?

To jest kwestia czysto teoretyczna. Nie ma tu potrzeby "praktycznej" odpowiedzi :)

Na przykład łatwo jest utworzyć skończony generator:

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

Jednak aby stworzyć nieskończoną, muszę „zanieczyścić” moją przestrzeń nazw fałszywą funkcją:

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

Robienie rzeczy w osobnym pliku i importpóźniejsze nie liczą się.

Wiem też, że itertools.repeatto właśnie robi. Ciekawi mnie, czy bez tego istnieje jednoliniowe rozwiązanie.

for x in iter(int, 1): pass

• Dwa argumenty iter= wywoływalne zeroargumentowe + wartość wartownika
• int() zawsze wraca 0

Dlatego iter(int, 1)jest nieskończoną iteratorem. Oczywiście istnieje ogromna liczba odmian tego konkretnego tematu (szczególnie po dodaniu lambdado miksu). Jednym z wariantów szczególnej uwagi jest to iter(f, object()), że użycie świeżo utworzonego obiektu jako wartości wartowniczej prawie gwarantuje nieskończony iterator, niezależnie od wywołania używanego jako pierwszy argument.

itertools zapewnia trzy nieskończone generatory:

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

Nie znam innych w standardowej bibliotece.

Ponieważ poprosiłeś o jedną linijkę:

__import__("itertools").count()

możesz iterować po wywołanym zwracaniu stałej zawsze innej niż wartownik iter ()

g1=iter(lambda:0, 1)

Twój system operacyjny może udostępniać coś, co może być używane jako nieskończony generator. Np. Na Linuksie

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

oczywiście nie jest to tak wydajne jak

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

Żaden, który nie używa wewnętrznie innego nieskończonego iteratora zdefiniowanego jako klasa / funkcja / generator (nie -wyrażenie, funkcja z yield). Wyrażenie generatora zawsze pobiera z innego iterowalnego i nie robi nic poza filtrowaniem i mapowaniem jego elementów. Nie możesz przejść od elementów skończonych do nieskończonych, mając tylko mapi filter, czego potrzebujesz while(lub coś for, co się nie kończy, co jest dokładnie tym, czego nie możemy mieć przy użyciu tylko fori skończonych iteratorów).

Ciekawostka: PEP 3142 jest pozornie podobny, ale po bliższym przyjrzeniu się wydaje się, że nadal wymaga forklauzuli (więc nie (0 while True)dla ciebie), tj. Zapewnia tylko skrót do itertools.takewhile.

Dość brzydki i szalony (jednak bardzo zabawny), ale możesz zbudować swój własny iterator z wyrażenia, używając kilku sztuczek (bez "zanieczyszczania" przestrzeni nazw zgodnie z wymaganiami):

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

Może przydałbyś się na przykład dekoratorów takich jak ten:

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

Użycie (1):

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

for i in blah():
    print i

Zastosowanie (2)

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

Myślę, że można by jeszcze bardziej ulepszyć pozbycie się tych brzydkich (). Jednak zależy to od złożoności sekwencji, którą chcesz móc utworzyć. Mówiąc ogólnie, jeśli twoja sekwencja może być wyrażona za pomocą funkcji, wówczas cała złożoność i cukier składniowy generatorów może być ukryta wewnątrz dekoratora lub funkcji podobnej do dekoratora.