Generator Python: Meningkatkan Performa dan Menyederhanakan Kode

Apa Itu Generator Python?

Pada intinya, generator Python adalah jenis fungsi khusus atau bahkan ekspresi ringkas yang menghasilkan deret nilai secara malas (lazy). Bayangkan generator seperti ban berjalan di pabrik: alih-alih menumpuk semua produk di satu tempat hingga kehabisan ruang, Anda memproses setiap item saat ia bergerak di lintasan. Ini membuat generator hemat memori dan menjadi perpanjangan alami dari protokol iterator Python, yang menjadi dasar banyak alat bawaan Python seperti for loop dan comprehension.  

Keajaiban di balik generator terletak pada kata kunci yield. Tidak seperti return, yang mengeluarkan satu nilai dan keluar dari fungsi, yield menghasilkan sebuah nilai, menghentikan eksekusi fungsi sejenak, dan menyimpan keadaannya. Saat generator dipanggil lagi, ia melanjutkan dari titik terakhir. 

Sebagai contoh, bayangkan Anda membaca berkas log raksasa baris demi baris. Generator dapat memproses setiap baris saat dibaca tanpa memuat seluruh berkas ke memori. "Evaluasi malas" inilah yang membedakan generator dari fungsi tradisional dan menjadikannya alat andalan untuk tugas-tugas yang sensitif terhadap performa.  

Contoh Dasar Generator Python

Mari berlatih sedikit untuk memahami idenya. Berikut adalah fungsi generator yang menghasilkan n bilangan bulat pertama.  

def generate_integers(n):
    for i in range(n):
        yield i  # Pauses here and returns i

# Using the generator
for num in generate_integers(5):
    print(num)Didukung oleh

0
1
2
3
4Didukung oleh

Saya membuat visual untuk membantu Anda melihat apa yang terjadi di balik layar:  

Sintaks dan Pola Generator Python  

Generator dapat diimplementasikan dalam beberapa cara. Namun, ada dua cara utama: fungsi generator dan ekspresi generator.

Fungsi generator  

Fungsi generator didefinisikan seperti fungsi biasa tetapi menggunakan kata kunci yield alih-alih return. Saat dipanggil, fungsi ini mengembalikan objek generator yang dapat diiterasi.  

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

# Using the generator
counter = count_up_to(5)
for num in counter:
    print(num)Didukung oleh

1
2
3
4
5Didukung oleh

Dari contoh di atas, kita dapat melihat bahwa ketika fungsi count_up_to dipanggil, ia mengembalikan objek generator. Setiap kali for loop meminta nilai, fungsi berjalan hingga mencapai yield, menghasilkan nilai count saat ini dan mempertahankan keadaannya antar-iterasi sehingga dapat melanjutkan tepat dari titik terakhir.

Ekspresi generator  

Ekspresi generator adalah cara ringkas untuk membuat generator. Mirip dengan list comprehension tetapi menggunakan tanda kurung biasa alih-alih tanda kurung siku.

# List comprehension (eager evaluation)
squares_list = [x**2 for x in range(5)]  # [0, 1, 4, 9, 16]

# Generator expression (lazy evaluation)
squares_gen = (x**2 for x in range(5))

# Using the generator
for square in squares_gen:
    print(square)Didukung oleh

0
1
4
9
16Didukung oleh

Lalu, apa bedanya list comprehension dengan ekspresi generator? List comprehension membuat seluruh daftar di memori, sedangkan ekspresi generator menghasilkan nilai satu per satu, menghemat memori. Jika Anda belum familier dengan list comprehension, Anda dapat membacanya di Tutorial Python List Comprehension kami.

Generator vs. iterator di Python

Iterator tradisional di Python memerlukan kelas dengan metode __iter__() dan __next__() eksplisit, yang melibatkan banyak boilerplate dan pengelolaan state secara manual, sedangkan fungsi generator menyederhanakan proses dengan otomatis mempertahankan state dan menghilangkan kebutuhan akan metode-metode tersebut—sebagaimana ditunjukkan oleh fungsi sederhana yang menghasilkan kuadrat setiap angka hingga n.

Mengapa Kita Menggunakan Generator Python  

Saat menjelaskan apa itu generator Python, saya juga menyampaikan sebagian alasan mengapa generator digunakan. Di bagian ini, saya ingin membahas sedikit lebih detail. Karena generator bukan sekadar fitur Python yang canggih—generator benar-benar menyelesaikan masalah nyata.

Efisiensi memori  

Tidak seperti list atau array, yang menyimpan semua elemennya di memori secara bersamaan, generator menghasilkan nilai saat dibutuhkan, sehingga hanya menahan satu item di memori pada satu waktu.  

Sebagai contoh, perhatikan perbedaan antara range() dan xrange() di Python 2:  

•  range() membuat list di memori, yang bisa bermasalah untuk rentang besar.

•  xrange() bertindak seperti generator, menghasilkan nilai secara malas.

Karena perilaku xrange() lebih berguna, sekarang, di Python 3, range() juga berperilaku seperti generator, sehingga menghindari overhead memori untuk menyimpan semua nilai secara bersamaan.  

Untuk menunjukkan idenya, mari bandingkan penggunaan memori saat menghasilkan deret 10 juta angka:  

import sys

# Using a list
numbers_list = [x for x in range(10_000_000)]
print(f"Memory used by list: {sys.getsizeof(numbers_list) / 1_000_000:.2f} MB")

# Using a generator
numbers_gen = (x for x in range(10_000_000))
print(f"Memory used by generator: {sys.getsizeof(numbers_gen)} bytes")Didukung oleh

Memory used by list: 89.48 MB
Memory used by the generator: 112 bytesDidukung oleh

Seperti yang Anda lihat, generator hampir tidak menggunakan memori dibandingkan list, dan perbedaan ini sangat signifikan.  

Peningkatan performa  

Berkat evaluasi malas, nilai dihitung hanya saat diperlukan. Artinya, Anda bisa mulai memproses data segera tanpa menunggu seluruh deret dihasilkan.  

Misalnya, bayangkan menjumlahkan kuadrat dari 1 juta angka pertama:

# Using a list (eager evaluation)
sum_of_squares_list = sum([x**2 for x in range(1_000_000)])

# Using a generator (lazy evaluation)
sum_of_squares_gen = sum(x**2 for x in range(1_000_000))Didukung oleh

Walau kedua pendekatan memberi hasil yang sama, versi generator menghindari pembuatan list masif, sehingga hasilnya didapat lebih cepat. 

Kesederhanaan dan keterbacaan  

Generator menyederhanakan implementasi iterator dengan menghilangkan kode boilerplate. Bandingkan iterator berbasis kelas dengan fungsi generator:  

Berikut iterator berbasis kelas:

class SquaresIterator:
    def __init__(self, n):
        self.n = n
        self.current = 0
    def __iter__(self):
        return self
    def __next__(self):
        if self.current >= self.n:
            raise StopIteration
        result = self.current ** 2
        self.current += 1
        return result

# Usage
squares = SquaresIterator(5)
for square in squares:
    print(square)Didukung oleh

Berikut fungsi generatornya:

def squares_generator(n):
    for i in range(n):
        yield i ** 2

# Usage
squares = squares_generator(5)
for square in squares:
    print(square)Didukung oleh

Versi generator lebih singkat, mudah dibaca, dan tidak memerlukan kode boilerplate. Ini contoh sempurna dari filosofi Python: yang sederhana lebih baik.  

Menangani deret tak hingga  

Terakhir, saya ingin menekankan bahwa generator sangat cocok merepresentasikan deret tak hingga—sesuatu yang mustahil dilakukan dengan list. Misalnya, pertimbangkan deret Fibonacci:  

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

# Usage
fib = fibonacci()
for _ in range(10):
    print(next(fib))Didukung oleh

0
1
1
2
3
5
8
13
21
34Didukung oleh

Generator ini dapat menghasilkan bilangan Fibonacci tanpa batas tanpa kehabisan memori. Contoh lain termasuk memproses aliran data langsung atau bekerja dengan data deret waktu.  

Konsep Lanjutan Generator Python  

Sekarang, mari lihat beberapa gagasan yang lebih sulit. Di bagian ini, kita akan mengeksplorasi cara menggabungkan generator dan menggunakan metode khusus generator seperti .send(), .throw(), dan .close().  

Merantai generator

Generator dapat dikombinasikan. Anda dapat mentransformasi, memfilter, dan memproses data secara modular dengan merantai generator. 

Misalkan Anda memiliki deret angka tak hingga dan ingin menguadratkan setiap angka lalu menyaring hasil ganjil:

def infinite_sequence():
    num = 0
    while True:
        yield num
        num += 1
def square_numbers(sequence):
    for num in sequence:
        yield num ** 2
def filter_evens(sequence):
    for num in sequence:
        if num % 2 == 0:
            yield num

# Compose the generators
numbers = infinite_sequence()
squared = square_numbers(numbers)
evens = filter_evens(squared)

# Print the first 10 even squares
for _ in range(10):
    print(next(evens))Didukung oleh

0
4
16
36
64
100
144
196
256
324Didukung oleh

Prosesnya melibatkan fungsi infinite_sequence yang menghasilkan angka tanpa batas, sementara square_numbers menghasilkan kuadrat tiap angka, lalu filter_evens menyaring angka ganjil untuk hanya menghasilkan kuadrat genap. Career track Associate Python Developer kami membahas hal seperti ini, sehingga Anda dapat melihat cara membangun dan men-debug pipeline kompleks menggunakan generator, juga iterator dan list comprehension. 

Metode khusus generator  

Generator memiliki metode lanjutan yang memungkinkan komunikasi dua arah dan penghentian terkontrol.

send()

Metode .send() memungkinkan Anda mengirim nilai kembali ke dalam generator, menjadikannya coroutine. Ini berguna untuk membuat generator interaktif atau yang menyimpan state.  

def accumulator():
    total = 0
    while True:
        value = yield total
        if value is not None:
            total += value

# Using the generator
acc = accumulator()
next(acc)  # Start the generator
print(acc.send(10))  # Output: 10
print(acc.send(5))   # Output: 15
print(acc.send(20))  # Output: 35Didukung oleh

Begini cara kerjanya: 

• Generator dimulai dengan next(acc) untuk menginisialisasinya.  

• Setiap pemanggilan .send(value) mengirim nilai ke generator, yang ditetapkan ke value di pernyataan yield.  

• Generator memperbarui state-nya (total) dan menghasilkan hasil baru.

throw()

Metode .throw() memungkinkan Anda melempar exception di dalam generator, yang berguna untuk penanganan error atau memberi sinyal kondisi tertentu.  

def resilient_generator():
    try:
        for i in range(5):
            yield i
    except ValueError:
        yield "Error occurred!"

# Using the generator
gen = resilient_generator()
print(next(gen))  # Output: 0
print(next(gen))  # Output: 1
print(gen.throw(ValueError))  # Output: "Error occurred!"Didukung oleh

Begini cara kerjanya: 

• Generator biasanya berjalan hingga .throw() dipanggil.  

•  Exception dilempar di dalam generator, yang dapat ditangani menggunakan blok try-except.

close()

Metode .close() menghentikan generator dengan melempar exception GeneratorExit. Ini berguna untuk membersihkan resource atau menghentikan generator tak hingga.  

def infinite_counter():
    count = 0
    try:
        while True:
            yield count
            count += 1
    except GeneratorExit:
        print("Generator closed!")

# Using the generator
counter = infinite_counter()

print(next(counter))  # Output: 0
print(next(counter))  # Output: 1
counter.close()       # Output: "Generator closed!"Didukung oleh

Dan begini cara kerjanya: 

• Generator berjalan hingga .close() dipanggil.  

•  Exception GeneratorExit dilempar, memungkinkan generator untuk membersihkan atau mencatat pesan sebelum berhenti.

Aplikasi Dunia Nyata dalam Data Science  

Saya harap Anda mulai melihat bahwa generator itu bermanfaat. Di bagian ini, saya akan menonjolkan use case agar Anda dapat membayangkan bagaimana generator benar-benar bekerja untuk Anda dalam pekerjaan sehari-hari. 

Memproses dataset besar  

Salah satu tantangan paling umum dalam data science adalah bekerja dengan dataset yang terlalu besar untuk dimuat ke memori. Generator menyediakan cara untuk memproses data seperti ini baris demi baris.  

Bayangkan Anda memiliki berkas CSV 10 GB berisi data penjualan dan perlu memfilter catatan untuk wilayah tertentu. Berikut cara menggunakan pipeline generator untuk mencapainya:  

import csv
def read_large_csv(file_path):
    """ Generator to read a large CSV file line by line."""
    with open(file_path, mode="r") as file:
        reader = csv.DictReader(file)
        for row in reader:
            yield row

def filter_by_region(data, region):
    """ Generator to filter rows by a specific region."""
    for row in data:
        if row["Region"] == region:
            yield row

# Generator pipeline
file_path = "sales_data.csv"
region = "North America"
data = read_large_csv(file_path)
filtered_data = filter_by_region(data, region)

# Process the filtered data
for record in filtered_data:
    print(record)Didukung oleh

Berikut yang terjadi: 

1. read_large_csv membaca berkas baris demi baris, menghasilkan tiap baris sebagai kamus.  

2. filter_by_region memfilter baris berdasarkan wilayah yang ditentukan.  

3. Pipeline memproses data secara inkremental, menghindari kelebihan beban memori.

Pendekatan ini bermanfaat untuk alur kerja extract, transform, and load, di mana data harus dibersihkan dan ditransformasi sebelum analisis. Anda akan melihat hal semacam ini di kursus ETL and ELT in Python kami.

Streaming dan pipeline  

Terkadang data datang sebagai aliran kontinu. Pikirkan data sensor, feed langsung, atau media sosial.

Misalkan Anda bekerja dengan perangkat IoT yang menghasilkan pembacaan suhu setiap detik. Anda ingin menghitung suhu rata-rata dengan jendela geser berukuran 10 pembacaan:

def sensor_data_stream():
    """Simulate an infinite stream of sensor data."""
    import random
    while True:
        yield random.uniform(0, 100)  # Simulate sensor data

def sliding_window_average(stream, window_size):
    """ Calculate the average over a sliding window of readings."""
    window = []
    for value in stream:
        window.append(value)
        if len(window) > window_size:
            window.pop(0)
        if len(window) == window_size:
            yield sum(window) / window_size

# Generator pipeline
sensor_stream = sensor_data_stream()
averages = sliding_window_average(sensor_stream, window_size=10)

# Print the average every second
for avg in averages:
    print(f"Average temperature: {avg:.2f}")Didukung oleh

Berikut penjelasannya: 

1. sensor_data_stream mensimulasikan aliran tak hingga dari pembacaan sensor.  

2. sliding_window_average mempertahankan jendela geser berisi 10 pembacaan terakhir dan menghasilkan rata-ratanya.  

3. Pipeline memproses data secara real-time, ideal untuk pemantauan dan analitik.

Use case tambahan

Generator juga digunakan dalam situasi di mana ukuran data tidak dapat diprediksi atau ketika datanya terus berdatangan/tak terbatas.  

Web scraping  

Saat melakukan scraping situs web, Anda sering tidak tahu berapa banyak halaman atau item yang perlu diproses. Generator memungkinkan Anda menangani ketidakpastian ini dengan baik:

def scrape_website(url):
    """ Generator to scrape a website page by page."""
    while url:
        # Simulate fetching and parsing a page
        print(f"Scraping {url}")
        data = f"Data from {url}"
        yield data
        url = get_next_page(url)  # Hypothetical function to get the next page

# Usage
scraper = scrape_website("https://example.com/page1")
for data in scraper:
    print(data)Didukung oleh

Tugas simulasi

Dalam simulasi, seperti metode Monte Carlo atau pengembangan gim, generator dapat merepresentasikan deret yang tak hingga atau dinamis:

def monte_carlo_simulation():
    """ Generator to simulate random events for Monte Carlo analysis."""
    import random
    while True:
        yield random.random()

# Usage
simulation = monte_carlo_simulation()
for _ in range(10):
    print(next(simulation))Didukung oleh

Benchmark Memori dan Kecepatan

Karena cara kerjanya, generator unggul dalam skenario di mana efisiensi memori sangat penting, tetapi (mungkin mengejutkan) tidak selalu menjadi opsi tercepat. Mari bandingkan generator dengan list untuk memahami trade-off-nya.  

Sebelumnya, kita menunjukkan bagaimana generator lebih baik daripada list dalam hal memori. Itu bagian saat kita membandingkan penggunaan memori saat menghasilkan deret 10 juta angka. Sekarang mari lakukan hal berbeda, perbandingan kecepatan:

import time

# List comprehension
start_time = time.time()
sum([x**2 for x in range(1_000_000)])
print(f"List comprehension time: {time.time() - start_time:.4f} seconds")

# Generator expression
start_time = time.time()
sum(x**2 for x in range(1_000_000))
print(f"Generator expression time: {time.time() - start_time:.4f} seconds")Didukung oleh

List comprehension time: 0.1234 seconds
Generator expression time: 0.1456 secondsDidukung oleh

Walau generator menghemat memori, dalam kasus ini ia justru lebih lambat daripada list. Ini karena, untuk dataset yang lebih kecil, ada overhead penghentian dan kelanjutan eksekusi.  

Perbedaan performa tidak signifikan untuk dataset kecil, tetapi untuk dataset besar, penghematan memori dari generator sering kali lebih berharga daripada penalti kecepatan yang kecil.  

Masalah yang Sering Muncul

Terakhir, mari lihat beberapa kesalahan atau masalah umum:

Generator dapat habis 

Setelah generator habis, ia tidak dapat digunakan kembali. Anda perlu membuatnya lagi jika ingin mengiterasi ulang.

gen = (x for x in range(5))
print(list(gen))  # Output: [0, 1, 2, 3, 4]
print(list(gen))  # Output: [] (the generator is exhausted)Didukung oleh

Evaluasi malas bisa rumit 

Karena generator menghasilkan nilai sesuai permintaan, error atau efek samping mungkin tidak muncul sampai generator diiterasi.  

Anda bisa berlebihan menggunakan generator 

Untuk dataset kecil atau tugas sederhana, overhead penggunaan generator mungkin tidak sepadan dengan penghematan memori. Pertimbangkan contoh ini saat saya mematerialisasi data untuk beberapa iterasi.

# Generator expression
gen = (x**2 for x in range(10))

# Materialize into a list
squares = list(gen)

# Reuse the list
print(sum(squares))  # Output: 285
print(max(squares))  # Output: 81Didukung oleh

Memilih Kapan Menggunakan Generator

Sebagai rangkuman, saya akan memberikan beberapa aturan umum kapan menggunakan generator. Gunakan untuk:

• Dataset besar: Gunakan generator saat bekerja dengan dataset yang terlalu besar untuk dimuat ke memori.  
• Deret tak hingga: Gunakan generator untuk merepresentasikan deret tak hingga, seperti aliran data langsung atau simulasi.
• Pipeline: Gunakan generator untuk membangun pipeline pemrosesan data modular yang mentransformasi dan memfilter data secara inkremental.  

Kapan sebaiknya mematerialisasi data (mengonversi ke list)  

• Dataset kecil: Jangan gunakan generator jika memori bukan masalah dan Anda perlu akses cepat ke semua elemen; gunakan list sebagai gantinya.  
• Beberapa iterasi: Jangan gunakan generator jika Anda perlu mengiterasi data yang sama beberapa kali; sebagai gantinya, materialisasikan ke list untuk menghindari membuat ulang generator.  

Kesimpulan dan Hal-Hal Penting  

Sepanjang artikel ini, kita telah mengeksplorasi bagaimana generator dapat membantu Anda mengatasi tantangan nyata dalam data science, mulai dari memproses dataset besar hingga membangun pipeline data real-time. Teruslah berlatih. Cara terbaik menguasai generator adalah menggunakannya dalam pekerjaan Anda sendiri. Sebagai awal, cobalah mengganti list comprehension dengan ekspresi generator atau memfaktorkan ulang loop menjadi fungsi generator. 

Setelah Anda menguasai dasarnya, Anda dapat mengeksplorasi topik baru dan lebih lanjut yang dibangun di atas konsep generator:  

• Coroutine: Gunakan .send() dan .throw() untuk membuat generator yang dapat menerima dan memproses data, memungkinkan komunikasi dua arah.  

• Pemrograman asinkron: Gabungkan generator dengan pustaka asyncio Python untuk membangun aplikasi yang efisien dan non-blocking.  

• Concurrency: Pelajari bagaimana generator dapat mengimplementasikan multitasking kooperatif dan concurrency yang ringan.  

Terus belajar dan jadilah ahli. Ikuti career track Python Developer atau skill track Python Programming kami hari ini. Klik tautan di bawah untuk memulai.