Sonsuz bir üretici için bir ifade var mı?

Sonsuz elemanlar üretebilen düz bir üreteç ifadesi var mı?

Bu tamamen teorik bir sorudur. Burada "pratik" bir cevaba gerek yok :)

Örneğin, sonlu bir üretici yapmak kolaydır:

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

Bununla birlikte, sonsuz bir tane yapmak için ad alanımı sahte bir işlevle "kirletmem" gerekiyor:

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

İşleri ayrı bir dosyada yapmak ve importdaha sonra yapmak sayılmaz.

Bunun itertools.repeattam olarak bunu yaptığını da biliyorum . O olmadan tek satırlık bir çözüm olup olmadığını merak ediyorum.

for x in iter(int, 1): pass

• İki bağımsız değişken iter= sıfır bağımsız değişken çağrılabilir + sentinel değer
• int() her zaman geri döner 0

Bu nedenle, iter(int, 1)sonsuz bir yineleyicidir. Açıkçası, bu özel tema üzerinde çok sayıda varyasyon var (özellikle lambdakarışıma eklediğinizde ). Özel notun bir varyantı, iter(f, object())yeni oluşturulmuş bir nesnenin, sentinel değerin, ilk argüman olarak kullanılan çağrılabilir özellikten bağımsız olarak neredeyse sonsuz bir yineleyiciyi garanti ettiği gibi kullanılmasıdır.

itertools üç sonsuz jeneratör sağlar:

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

Standart kitaplıkta başka birini bilmiyorum.

Tek satırlık istediğinden beri:

__import__("itertools").count()

iter () 'in gözcüsünden her zaman farklı bir sabit döndüren bir çağrılabilir üzerinde yineleme yapabilirsiniz

g1=iter(lambda:0, 1)

İşletim sisteminiz sonsuz bir jeneratör olarak kullanılabilecek bir şey sağlayabilir. Örn. Linux üzerinde

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

açıkçası bu kadar verimli değil

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

Hiçbiri, sınıf / işlev / oluşturucu olarak tanımlanan başka bir sonsuz yineleyiciyi dahili olarak kullanmayan (ifade değil, bir işlev yield). Bir üreteç ifadesi her zaman yinelenebilir bir düzenleyiciden yararlanır ve öğelerini filtrelemek ve eşlemek dışında hiçbir şey yapmaz. Yalnızca mapve ile sonlu öğelerden sonsuz öğelere geçemezsiniz filter, ihtiyacınız olan while(veya forbu sona ermeyen, tam olarak yalnızca kullanamayacağımız şeydir)for ve sonlu yineleyicileri ).

Trivia: PEP 3142 yüzeysel olarak benzerdir, ancak daha yakından incelendiğinde hala formaddeyi gerektirdiği görülüyor (yani (0 while True)sizin için hayır ), yani sadece kısayol sağlıyor itertools.takewhile.

Oldukça çirkin ve çılgınca (yine de çok komik), ancak bazı hileler kullanarak bir ifadeden kendi yineleyicinizi oluşturabilirsiniz (ad alanınızı gerektiği gibi "kirletmeden"):

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

Belki bunun gibi dekoratörleri kullanabilirsiniz, örneğin:

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

Kullanım (1):

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

for i in blah():
    print i

Kullanım (2)

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

Bu çirkinlerden kurtulmanın daha da geliştirilebileceğini düşünüyorum (). Bununla birlikte, yaratmak istediğiniz dizinin karmaşıklığına bağlıdır. Genel olarak konuşursak, eğer sekansınız fonksiyonlar kullanılarak ifade edilebiliyorsa, jeneratörlerin tüm karmaşıklığı ve sözdizimsel şekeri bir dekoratör veya dekoratör benzeri bir fonksiyon içinde gizlenebilir.