Sadece hataları bulmak için 10 GB’lık bir günlük dosyasını bir listeye yüklediğinizi düşünün. Programınızın belleği bulamadan tükenebilir. Python oluşturucuları, talep üzerine değerleri birer birer üreterek bu sorunu çözer; böylece neredeyse hiç bellek olmadan çok büyük, hatta sonsuz veriler üzerinde çalışabilirsiniz.

Bu kılavuz, bir jeneratör çalıştığında gerçekte ne olduğunu adım adım gösterir. Her örneği Python 3.13’te çalıştırdık ve çıktı bu çalıştırmadan geliyor. Yeni başlayanlar için Python eğitimimizin kapsadığı işlevler ve döngüler konusunda zaten rahat olmanıza yardımcı olur.

Jeneratör nedir?

Jeneratör, yield kullanarak bir fonksiyon yazarak oluşturduğunuz özel bir yineleyici türüdür. İçinde yield bulunan herhangi bir işlev otomatik olarak bir jeneratör işlevi haline gelir ve onu çağırmak, kodu çalıştırmak yerine size bir jeneratör nesnesi verir.

def count_up(limit):
    print("starting")
    n = 1
    while n <= limit:
        yield n
        n += 1
    print("finished")

gen = count_up(2)
print(gen)

# <generator object count_up at 0x...>

“Başlangıç” ifadesinin yazdırılmadığına dikkat edin. Fonksiyonun çağrılması yalnızca jeneratörü yarattı. İçeride henüz hiçbir şey çalışmadı.

Getiri adım adım nasıl çalışır?

next()‘e yapılan her çağrı, yield‘ye ulaşana kadar işlevi çalıştırır, bu değeri geri verir ve yerinde donar. Bir sonraki çağrı, tüm yerel değişkenler bozulmadan bu satırdan hemen sonra devam eder.

print(next(gen))
# starting
# 1

print(next(gen))
# 2

next(gen)
# finished
# StopIteration

Çıktıyı dikkatlice takip edin. “başlıyor” yalnızca ilk next()‘de görünür. İkincisinde, yürütme kaldığı yerden devam eder, yani n hala kullanılabilir durumdadır ve 2 olur. Üçüncüsünde, döngü biter, “bitti” yazdırılır, işlev sondan düşer ve Python hiçbir şeyin kalmadığının sinyalini vermek için StopIteration‘ü yükseltir.

Nadiren kendiniz next()‘i ararsınız. Bir for döngüsü bunu sizin için yapar ve StopIteration‘ü sessizce işler; aynı şekilde list(), sum() ve benzer işlevler de bunu yapar:

print(list(count_up(3)))

# starting
# finished
# [1, 2, 3]

getiri vs getiri

Bu gecikme, tembel değerlendirme olarak bilinir: değerler yalnızca ihtiyaç duyulduğunda hesaplanır. Jeneratörün içindeki bir düz return basitçe onu bitirir ve bu da StopIteration‘ü tetikler.

Ölçülen hafıza farkı

Bir milyon karelik listeyi eşdeğer bir oluşturucuyla sys.getsizeof kullanarak karşılaştırdık:

import sys

squares_list = [n * n for n in range(1_000_000)]
squares_gen = (n * n for n in range(1_000_000))

print(sys.getsizeof(squares_list), sys.getsizeof(squares_gen))

# 8448728 200

Listenin kendi yapısı yaklaşık 8,4 MB yer kaplarken, oluşturucu sistemimizde yalnızca 200 bayt yer kapladı. getsizeof listedeki tamsayı nesneleri saymadığı için gerçek boşluk daha da büyüktür. Jeneratörün boyutu da bir milyar öğe için aynı kalıyor çünkü sonuçları değil yalnızca mevcut durumunu saklıyor.

Yine de bir takas var. Bir liste len() ile yeniden kullanılabilir, indekslenebilir ve ölçülebilir. Bir jeneratör bunların hiçbirini sunmaz. Rastgele erişime ihtiyacınız varsa veya az miktarda veri üzerinde birkaç kez döngü yapacaksanız liste daha basittir. Bu türler hakkında daha fazla bilgi için Python list vs Tuple vs set kılavuzumuza bakın.

Jeneratör ifadeleri

Basit durumlar için bir fonksiyona ihtiyacınız yoktur. Bir oluşturucu ifadesi, kare parantezlerin yerine yuvarlak parantezlerin bulunduğu bir liste kavrama‘ya benzer:

squares = [n * n for n in range(5)]   # builds a list now
squares = (n * n for n in range(5))   # produces values on demand

print(sum(n * n for n in range(5)))

# 30

sum()‘de olduğu gibi bir fonksiyonun tek argümanı bir üreteç ifadesi olduğunda, fazladan parantezleri dışarıda bırakabilirsiniz. Bu, büyük veriler üzerindeki toplamlar için düzenli bir alışkanlıktır çünkü geçici bir liste oluşturulmaz.

Bir veri hattı oluşturun

Jeneratörlerin gerçekten parladığı yer burasıdır. Küçük jeneratörler, her bir öğenin her adımda birer birer akacağı şekilde zincirlenebilir:

def read_lines(lines):
    for line in lines:
        yield line.strip()

def only_errors(lines):
    for line in lines:
        if line.startswith("ERROR"):
            yield line

def messages(lines):
    for line in lines:
        yield line.split(" ", 1)[1]

log = ["INFO started\n", "ERROR db down\n",
       "ERROR disk full\n", "INFO stopped\n"]

print(list(messages(only_errors(read_lines(log)))))

# ['db down', 'disk full']

Her adım küçük bir iş yapar ve kendi başına test edilebilir. Gerçek kullanımda, örnek listeyi açık bir dosyayla değiştirin, çünkü Python dosya işleme kılavuzumuzun gösterdiği gibi dosya nesneleri satır satır okunabilir. Çok gigabaytlık bir günlük bile çok az bellekle iletilecektir.

Sonsuz diziler

Bir liste sonsuz olamaz, ancak bir oluşturucu bunu yapabilir çünkü yalnızca bir sonraki değeri hesaplar. İhtiyacınız kadarını almak için itertools.islice‘i kullanın:

import itertools

def fibonacci():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

print(list(itertools.islice(fibonacci(), 8)))

# [0, 1, 1, 2, 3, 5, 8, 13]

Ancak dikkatli olun: list(fibonacci())‘i sınırsız olarak çağırmak, hafızanız bitene kadar devam eder. Aynı model kimlik oluşturuculara, yoklama döngülerine ve sayfalandırılmış API sonuçlarına uygundur; burada bir sonraki sayfayı yalnızca mevcut sayfa bittiğinde getirirsiniz.

verim ve partiler

yield from başka bir yinelenebilire geçerek iç içe geçmiş bir döngüden tasarruf etmenizi sağlar:

def chain_all(*groups):
    for group in groups:
        yield from group

print(list(chain_all([1, 2], (3, 4))))

# [1, 2, 3, 4]

Çok pratik bir model, verileri sabit boyutlu gruplara bölmektir; örneğin bir veritabanına her seferinde bin satır eklemek için:

def batches(items, size):
    batch = []
    for item in items:
        batch.append(item)
        if len(batch) == size:
            yield batch
            batch = []
    if batch:
        yield batch

print(list(batches(range(7), 3)))

# [[0, 1, 2], [3, 4, 5], [6]]

Son if batch, daha küçük bir kalan grubun kaybolmamasını sağlar. Python 3.12 ve üzeri aynı işi yapan itertools.batched‘yi de içerir.

gönder, kapat ve temizle

Jeneratörler de değer alabilir. send() jeneratörü sürdürür ve değer, yield ifadesinin sonucu olur. İlk yield‘e ulaşmak için önce next()‘ü bir kez aramalısınız:

def running_total():
    total = 0
    while True:
        value = yield total
        total += value

t = running_total()
next(t)
print(t.send(10), t.send(5))

# 10 15

Çoğu insan buna nadiren ihtiyaç duyar. Daha yaygın bir endişe ise temizliktir. Erken durursanız, jeneratör kapatıldığında bir finally bloğu çalışmaya devam eder:

def tracked():
    try:
        yield 1
        yield 2
    finally:
        print("cleanup ran")

tr = tracked()
next(tr)
tr.close()

# cleanup ran

Pytest tam da bu fikri kullanır: pytest eğitimimizin gösterdiği gibi, yield‘li bir fikstür, temizleme işlemini daha sonra gerçekleştirir. Benzer şekilde, standart kütüphanenin contextmanager dekoratörü bir oluşturucuyu with bloğa dönüştürür.

Sınıflardaki jeneratörler

Bir __iter__ yöntemini oluşturucu olarak yazmak, kendi sınıfınızı yinelenebilir hale getirmenin en kolay yoludur. Bir bonus, her döngünün yeni bir oluşturucuya sahip olmasıdır, böylece nesne tekrar tekrar döngüye alınabilir:

class Countdown:
    def __init__(self, start):
        self.start = start

    def __iter__(self):
        n = self.start
        while n > 0:
            yield n
            n -= 1

c = Countdown(3)
print(list(c), list(c))

# [3, 2, 1] [3, 2, 1]

Jeneratör ne zaman kullanılmalı

Bir jeneratör genel olarak her zaman daha hızlı değildir. Her değeri kullanırsanız, toplam iş benzer olur ve öğe başına daha az ek yüke sahip olduğundan listenin anlaşılması küçük veriler için daha hızlı olabilir. Başlıca faydaları hafıza kullanımı ve ilk sonuçların daha erken alınmasıdır.

Yaygın hatalar

Bitmiş bir jeneratörün yeniden kullanılması

Bu bir noktada neredeyse herkesi yakalar. Bir jeneratör bittiğini hatırlar:

g = count_up(2)
print(list(g), list(g))

# [1, 2] []

İkinci çağrı hiçbir hatasız boş bir liste alır. Yeni bir oluşturucu almak için işlevi tekrar çağırın veya yukarıda gösterilen sınıf yaklaşımını kullanın.

Kodun hemen çalıştırılması bekleniyor

def noisy():
    print("body runs")
    yield 1

n = noisy()        # nothing is printed
print(next(n))     # body runs, then 1

Jeneratörün tepesindeki bağımsız değişken kontrolleri ilk next()‘e kadar çalışmaz, bu nedenle hatalar, onlara neden olan çağrıdan uzakta görünebilir.

Diğer tuzaklar

• len()‘yi çağırmak veya dizine eklemek. Jeneratörler ikisini de desteklemez ve bir TypeError‘ü yükseltir.
• Bir dosyayı çok erken kapatmak. Bir oluşturucuyu with bloğunun içinden döndürmek, dosyanın herhangi bir satır okunmadan kapanması anlamına gelebilir. yield‘ü with bloğunun içine yerleştirin.
• Her şeyi list()‘ye sarmak. Bu, hafıza avantajını ortadan kaldırır.
• Küçük veriler için bir tane kullanmak. Düz bir liste genellikle daha anlaşılırdır.

Son sözler

Jeneratör duraklatabilen bir fonksiyondur. Bu fikir size düşük bellek kullanımı, sonsuz diziler ve temiz işlem hatları sağlar. Bunu uygulamaya koymak için, kodunuzda yalnızca bir kez döngü oluşturacak büyük bir liste oluşturan bir yer bulun ve bunu bir oluşturucuya dönüştürün. Daha sonra iki küçük jeneratörü gerçek bir günlük dosyası üzerinde birbirine zincirlemeyi deneyin.

Sık sorulan sorular

Öğrenmeye devam et