Bayangkan memuat file log 10 GB ke dalam daftar hanya untuk menemukan kesalahannya. Program Anda mungkin kehabisan memori sebelum dapat menemukannya. Generator Python menyelesaikan masalah tersebut dengan menghasilkan nilai sesuai permintaan, satu per satu, sehingga Anda dapat mengerjakan data yang sangat besar atau bahkan tanpa akhir dengan hampir tanpa memori.

Panduan ini menunjukkan apa yang sebenarnya terjadi ketika generator bekerja, langkah demi langkah. Kami menjalankan setiap contoh di Python 3.13, dan output berasal dari proses tersebut. Akan sangat membantu jika Anda sudah terbiasa dengan fungsi dan loop, yang dibahas dalam tutorial Python untuk pemula kami.

Apa itu generator?

Generator adalah jenis iterator khusus yang Anda buat dengan menulis fungsi menggunakan yield. Fungsi apa pun dengan yield di dalamnya secara otomatis menjadi fungsi generator, dan memanggilnya memberi Anda objek generator daripada menjalankan kode.

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

Perhatikan bahwa “mulai” tidak dicetak. Memanggil fungsi tersebut hanya membuat generator. Belum ada apa pun di dalam yang berjalan.

Cara kerja hasil, langkah demi langkah

Setiap panggilan ke next() menjalankan fungsi hingga mencapai yield, mengembalikan nilai tersebut, dan berhenti di tempatnya. Panggilan berikutnya dilanjutkan tepat setelah baris itu, dengan setiap variabel lokal tetap utuh.

print(next(gen))
# starting
# 1

print(next(gen))
# 2

next(gen)
# finished
# StopIteration

Ikuti hasilnya dengan cermat. “mulai” hanya muncul pada next() pertama. Pada putaran kedua, eksekusi dilanjutkan dari titik berhentinya, sehingga n masih tersedia dan menjadi 2. Pada putaran ketiga, perulangan berakhir, cetakan “selesai”, fungsi tersebut hilang, dan Python memunculkan StopIteration untuk menandakan bahwa tidak ada lagi yang tersisa.

Anda jarang menelepon next() diri Anda sendiri. Perulangan for melakukannya untuk Anda dan menangani StopIteration dengan tenang, begitu pula list(), sum() dan fungsi serupa:

print(list(count_up(3)))

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

hasil vs pengembalian

Penundaan ini dikenal sebagai evaluasi malas: nilai dihitung hanya jika diperlukan. Sebuah return biasa di dalam generator mengakhirinya, yang memicu StopIteration.

Perbedaan memori, diukur

Kami membandingkan daftar satu juta kotak dengan generator yang setara, menggunakan sys.getsizeof:

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

Struktur daftarnya sendiri memakan waktu sekitar 8,4 MB, sedangkan generatornya hanya membutuhkan 200 byte di sistem kami. Kesenjangan sebenarnya bahkan lebih besar, karena getsizeof tidak menghitung objek bilangan bulat di dalam daftar. Ukuran generator juga tetap sama untuk satu miliar item, karena generator hanya menyimpan keadaan saat ini dan bukan hasilnya.

Namun ada trade-off. Daftar dapat digunakan kembali, diindeks, dan diukur dengan len(). Generator tidak menawarkan semua ini. Jika Anda memerlukan akses acak, atau Anda akan mengulang beberapa kali pada sejumlah kecil data, daftarnya lebih sederhana. Lihat panduan kami untuk Daftar Python vs Tuple vs Set untuk mengetahui lebih lanjut tentang jenis-jenis tersebut.

Ekspresi pembangkit

Untuk kasus sederhana, Anda tidak memerlukan suatu fungsi. Ekspresi generator terlihat seperti pemahaman daftar dengan tanda kurung bulat sebagai ganti tanda kurung siku:

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

Ketika ekspresi generator adalah satu-satunya argumen untuk suatu fungsi, seperti pada sum(), Anda dapat mengabaikan tanda kurung tambahan. Ini adalah kebiasaan yang rapi untuk menjumlahkan data yang besar, karena tidak ada daftar sementara yang dibuat.

Bangun saluran data

Di sinilah generator benar-benar bersinar. Generator kecil dapat dirangkai sehingga setiap item mengalir melalui setiap langkah, satu per satu:

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']

Setiap langkah melakukan satu pekerjaan kecil dan dapat diuji sendiri. Dalam penggunaan nyata, tukar daftar sampel dengan file yang terbuka, karena objek file dapat dibaca baris demi baris, seperti yang ditunjukkan oleh panduan kami untuk penanganan file Python. Bahkan log multi-gigabyte akan melewatinya dengan memori yang sangat sedikit.

Urutan tak terbatas

Daftar tidak boleh tak terbatas, namun generator bisa, karena ia hanya menghitung nilai berikutnya. Gunakan itertools.islice untuk mengambil sebanyak yang Anda perlukan:

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]

Namun berhati-hatilah: pemanggilan list(fibonacci()) tanpa batas akan dijalankan hingga memori Anda hilang. Pola yang sama sesuai dengan generator ID, loop polling, dan hasil API yang diberi nomor halaman, di mana Anda mengambil halaman berikutnya hanya ketika halaman saat ini habis.

hasil dari dan batch

yield from beralih ke iterable lain, sehingga menghemat loop bersarang:

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

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

# [1, 2, 3, 4]

Pola yang sangat praktis adalah membagi data menjadi kumpulan berukuran tetap, misalnya memasukkan ribuan baris ke dalam database sekaligus:

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]]

if batch terakhir memastikan bahwa kelompok sisa yang lebih kecil tidak hilang. Python 3.12 dan yang lebih baru juga menyertakan itertools.batched, yang melakukan pekerjaan serupa.

kirim, tutup, dan bersihkan

Generator juga dapat menerima nilai. send() melanjutkan generator, dan nilainya menjadi hasil dari ekspresi yield. Anda harus menelepon next() terlebih dahulu untuk mencapai yield pertama:

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

Kebanyakan orang jarang membutuhkan ini. Kekhawatiran yang lebih umum adalah pembersihan. Jika Anda berhenti lebih awal, blok finally masih berjalan ketika generator ditutup:

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

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

# cleanup ran

Pytest menggunakan ide ini: perlengkapan dengan yield menjalankan pembersihannya setelahnya, seperti yang ditunjukkan oleh tutorial pytest kami. Demikian pula, dekorator contextmanager perpustakaan standar mengubah generator menjadi blok with.

Generator di kelas

Menulis metode __iter__ sebagai generator adalah cara termudah untuk membuat kelas sendiri Anda dapat diubah. Bonusnya adalah setiap perulangan mendapat generator baru, sehingga objek dapat diulang berulang kali:

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]

Kapan menggunakan generator

Generator secara keseluruhan tidak selalu lebih cepat. Jika Anda akhirnya menggunakan setiap nilai, total pekerjaannya akan serupa, dan pemahaman daftar bahkan bisa lebih cepat untuk data kecil karena overhead per itemnya lebih sedikit. Manfaat utamanya adalah penggunaan memori, dan mendapatkan hasil pertama lebih cepat.

Kesalahan umum

Menggunakan kembali generator yang sudah habis

Ini menangkap hampir semua orang pada suatu saat. Generator mengingat bahwa ia telah selesai:

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

# [1, 2] []

Panggilan kedua mendapat daftar kosong tanpa kesalahan sama sekali. Panggil kembali fungsi tersebut untuk mendapatkan generator baru, atau gunakan pendekatan kelas yang ditunjukkan di atas.

Mengharapkan kode untuk segera dijalankan

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

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

Pemeriksaan argumen di bagian atas generator tidak berjalan hingga next() pertama, sehingga kesalahan dapat muncul jauh dari panggilan yang menyebabkannya.

Perangkap lainnya

• Memanggil len() atau mengindeks. Generator tidak mendukung keduanya, dan menaikkan TypeError.
• Menutup file terlalu cepat. Mengembalikan generator dari dalam blok with dapat berarti file ditutup sebelum baris apa pun dibaca. Letakkan yield di dalam blok with.
• Menggabungkan semuanya ke dalam list(). Hal ini membuang manfaat memori.
• Menggunakan satu untuk data kecil. Daftar biasa seringkali lebih jelas.

Penutup

Generator adalah fungsi yang dapat menjeda. Ide yang satu itu memberi Anda penggunaan memori yang rendah, urutan tanpa akhir, dan saluran pipa yang bersih. Untuk mempraktikkannya, temukan tempat dalam kode Anda yang membuat daftar besar hanya untuk mengulanginya satu kali, dan mengubahnya menjadi generator. Kemudian coba gabungkan dua generator kecil menjadi satu pada file log asli.

Pertanyaan yang sering diajukan

Teruslah belajar