Generator di Python: yield, iterasi lazy, dan generator expression

Fungsi yang bisa berhenti sejenak

Generator terlihat seperti fungsi biasa, tapi alih-alih menghitung seluruh hasil lalu mengembalikannya, generator menghasilkan (yield) satu nilai setiap kali, lalu berhenti sejenak di antara yield sampai pihak yang meminta menginginkan nilai berikutnya.

Contoh paling sederhana:

def count_up_to(n):
    current = 1
    while current <= n:
        yield current
        current += 1

for number in count_up_to(5):
    print(number)

Perhatikan yield, bukan return. Saat for pertama kali meminta nilai, Python menjalankan badan fungsi sampai bertemu yield 1. Fungsi itu berhenti tepat di situ, menyerahkan 1 ke perulangan, dan mengingat persis di mana ia berhenti, lengkap dengan variabelnya. Iterasi berikutnya melanjutkan dari titik itu: current += 1, kembali ke while, yield 2. Begitu seterusnya sampai kondisi perulangan gagal, dan saat itu generator berhenti dengan sendirinya.

Berhenti lalu melanjutkan, itulah seluruh triknya.

Kenapa tidak membuat list saja?

Karena versi list menyiapkan semua nilainya di awal:

def count_up_to_list(n):
    return list(range(1, n + 1))

print(count_up_to_list(5))

Tidak masalah untuk 5 item. Sekarang bayangkan kamu ingin 50 juta integer, dan kamu hanya peduli pada yang pertama yang cocok dengan suatu kondisi. Versi list menyiapkan 50 juta int lalu sebagian besarnya kamu buang. Versi generator hanya membuat sebanyak yang dipakai pemanggil. Saat for loop menemukan yang dicarinya lalu break, generator berhenti dengan sendirinya.

Itulah pola yang perlu kamu pahami: generator memungkinkan kamu menulis kode iterasi tanpa harus memutuskan di awal seberapa banyak hasil yang akan kamu butuhkan.

Generator expression

Kalau kamu pernah menulis list comprehension, kamu sudah tahu sintaksnya: ganti kurung siku dengan kurung biasa:

# List comprehension: allocates the whole result.
squares_list = [n * n for n in range(10)]

# Generator expression: computes on demand.
squares_gen = (n * n for n in range(10))

print(squares_list)
print(squares_gen)

for s in squares_gen:
    print(s)

squares_gen belum menghitung apa pun. Ia hanyalah resep. Melakukan iterasi padanya menjalankan resep itu selangkah demi selangkah.

Generator expression sangat cocok sebagai argumen untuk fungsi yang memakai iterable:

numbers = [3, 8, 1, 5, 4, 9, 2]

print(sum(n * n for n in numbers))
print(max(n for n in numbers if n % 2 == 0))
print(any(n > 7 for n in numbers))

Tidak ada list perantara. sum, max, dan any membaca nilai satu per satu, persis seperti yang mereka butuhkan.

Membaca file besar baris per baris

Inilah kasus nyata yang paling klasik untuk generator: memproses file yang terlalu besar untuk dimuat ke memori:

def parse_log_lines(path):
    with open(path) as f:
        for line in f:
            if line.startswith("ERROR"):
                yield line.rstrip()

for error in parse_log_lines("app.log"):
    print(error)

File-nya dibaca secara lazy. Setiap kali generator dipanggil, ia mengambil satu baris dari disk, menyaringnya, lalu melakukan yield. Pemakaian memori tetap datar berapa pun ukuran filenya.

Sekali pakai lalu habis

Generator hanya bisa dilalui sekali. Setelah kamu melakukan iterasi sampai akhir, generator itu habis:

def first_three():
    yield 1
    yield 2
    yield 3

gen = first_three()

for n in gen:
    print("first time:", n)

for n in gen:
    print("second time:", n)

Perulangan kedua tidak mencetak apa pun. Generator itu sudah tidak punya sisa.

Kalau kamu perlu iterasi lebih dari sekali, panggil lagi fungsi generator-nya untuk mendapat generator baru, atau simpan deretannya dengan list(...) lalu lakukan iterasi pada list itu berkali-kali. Pilih berdasarkan biayanya: membuat ulang tidak masalah kalau pekerjaannya ringan; list tidak masalah kalau deretannya kecil.

next() dan iterasi manual

Kamu tidak harus memakai for loop. next() mengambil satu nilai setiap kali:

def ticks():
    yield "first"
    yield "second"
    yield "third"

gen = ticks()

print(next(gen))
print(next(gen))
print(next(gen))

# A fourth call would raise StopIteration.

StopIteration adalah cara generator memberi tanda "aku sudah selesai." for loop menangkapnya diam-diam. Di kode manual, kamu bisa memberikan nilai default ke next(gen, default) untuk menghindari exception itu.

Generator tak terbatas

Karena nilai dihasilkan saat dibutuhkan, generator bisa mewakili deretan yang tidak ada ujungnya, selama pemakainya berhenti meminta:

def naturals():
    n = 1
    while True:
        yield n
        n += 1

for n in naturals():
    if n > 5:
        break
    print(n)

while True dengan yield di dalamnya tidak membuat program macet: artinya hanya "kalau ada yang terus meminta, terus hasilkan." Pemakainya yang memutuskan kapan berhenti.

Pola ini muncul di streaming data, event loop, dan di mana pun kamu mengambil nilai dari sumber yang panjangnya tidak tentu.

yield from: mendelegasikan ke iterable lain

Kalau generator-mu ingin melakukan yield untuk setiap nilai dari iterable lain, yield from melakukannya dalam satu baris:

def chain(*iterables):
    for it in iterables:
        yield from it

combined = chain([1, 2, 3], (4, 5, 6), "ab")
for x in combined:
    print(x)

Tanpa yield from, kamu akan menulis for loop bersarang dengan yield x di dalamnya. Ia juga meneruskan pemanggilan send() dan throw() dengan benar kalau kamu memakainya, tapi untuk kode sehari-hari, anggap saja artinya "yield setiap nilai dari benda ini."

Kapan memakai generator

Tiga tanda bahwa generator adalah alat yang tepat:

1. Deretannya besar, mungkin tak terbatas, atau mahal untuk dihasilkan seluruhnya.
2. Pemakainya mungkin berhenti sebelum akhir (misalnya break pada kecocokan pertama).
3. Kamu ingin merangkai beberapa transformasi, seperti filter, map, dan take, tanpa membuat list perantara.

Dan kapan tidak memakainya:

• Kamu butuh akses acak (seq[42]). Generator hanya bisa maju.
• Kamu perlu melakukan iterasi pada deretan yang sama beberapa kali. Pakai list.
• Deretannya kecil dan sudah kamu punya. List comprehension lebih sederhana.

Generator, list comprehension, dan list biasa masing-masing adalah jawaban yang tepat untuk pekerjaan yang berbeda. Keterampilannya adalah memilih salah satu tanpa terlalu banyak berpikir, dan cara tercepat membangun naluri itu adalah memperhatikan, untuk setiap iterasi yang kamu tulis, apakah "hasilkan semuanya dulu" atau "hasilkan satu per satu" yang lebih cocok.

Berikutnya: context manager lebih dalam

Sekarang kamu sudah melihat sebagian besar idiom yang dipakai Python untuk iterasi. Context manager, yaitu pernyataan with, adalah pembahasan berikutnya, dan context manager cocok dipadukan dengan generator untuk mengalirkan data dari file dan koneksi jaringan.