Apakah ada ekspresi untuk generator tak terbatas?

Apakah ada ekspresi generator lurus ke depan yang dapat menghasilkan elemen tak hingga?

Ini adalah pertanyaan teoritis murni. Tidak perlu jawaban "praktis" di sini :)

Misalnya, mudah membuat generator terbatas:

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

Namun, untuk membuat yang tak terbatas, saya perlu "mencemari" namespace saya dengan fungsi palsu:

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

Melakukan sesuatu dalam file terpisah dan import-ing nanti tidak dihitung.

Saya juga tahu bahwa itertools.repeatitulah tepatnya. Saya ingin tahu apakah ada solusi satu baris tanpa itu.

for x in iter(int, 1): pass

• Dua-argumen iter= nilai callable + sentinel nol-argumen
• int() selalu kembali 0

Oleh karena itu, iter(int, 1)merupakan iterator tak terbatas. Jelas ada sejumlah besar variasi pada tema khusus ini (terutama setelah Anda menambahkannya lambdake dalam campuran). Salah satu varian dari catatan tertentu adalah iter(f, object()), karena menggunakan objek yang baru dibuat sebagai nilai sentinel hampir menjamin iterator tak terbatas terlepas dari callable yang digunakan sebagai argumen pertama.

itertools menyediakan tiga generator tak terbatas:

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

Saya tidak tahu ada orang lain di perpustakaan standar.

Karena Anda meminta satu baris:

__import__("itertools").count()

Anda dapat mengulangi callable yang mengembalikan konstanta yang selalu berbeda dari sentinel iter ()

g1=iter(lambda:0, 1)

OS Anda mungkin menyediakan sesuatu yang dapat digunakan sebagai generator tak terbatas. Misal di linux

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

jelas ini tidak seefisien

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

Tidak ada yang tidak secara internal menggunakan iterator tak terbatas lainnya yang didefinisikan sebagai kelas / fungsi / generator (bukan -ekspresi, fungsi dengan yield). Ekspresi generator selalu diambil dari iterable anoter dan tidak melakukan apa pun selain memfilter dan memetakan itemnya. Anda tidak dapat beralih dari item terbatas ke item tak terbatas hanya dengan mapdan filter, Anda perlu while(atau foryang tidak berakhir, itulah yang sebenarnya tidak dapat kita gunakan hanyafor dan iterator terbatas).

Trivia: PEP 3142 secara dangkal mirip, tetapi setelah diperiksa lebih dekat tampaknya masih memerlukan forklausa (jadi tidak (0 while True)untuk Anda), yaitu hanya menyediakan pintasan untuk itertools.takewhile.

Cukup jelek dan gila (namun sangat lucu), tetapi Anda dapat membuat iterator Anda sendiri dari ekspresi dengan menggunakan beberapa trik (tanpa "mengotori" namespace Anda seperti yang diperlukan):

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

Mungkin Anda bisa menggunakan dekorator seperti ini misalnya:

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

Penggunaan (1):

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

for i in blah():
    print i

Penggunaan (2)

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

Saya pikir itu bisa lebih ditingkatkan untuk menyingkirkan mereka yang jelek (). Namun itu tergantung pada kompleksitas urutan yang ingin Anda buat. Secara umum jika urutan Anda dapat diekspresikan menggunakan fungsi, maka semua kerumitan dan sintaksis generator dapat disembunyikan di dalam dekorator atau fungsi seperti dekorator.