Apa itu generator dan kata kunci yield?

Question

Accepted Answer

Sebuah **generator** adalah fungsi yang menghasilkan nilai **secara lazy, satu per satu**, menggunakan kata kunci `yield` sebagai pengganti `return`. Generator menghitung setiap nilai sesuai permintaan daripada membangun seluruh hasil dalam memori — ideal untuk urutan besar atau tak terbatas.

## yield vs return

```python
# a regular function builds the WHOLE list in memory
def get_squares(n):
    return [i ** 2 for i in range(n)]   # all n values created at once

# a generator yields values ONE AT A TIME, on demand
def gen_squares(n):
    for i in range(n):
        yield i ** 2                     # pause here, return one value, resume on next()

for sq in gen_squares(1_000_000):        # uses almost NO memory
    print(sq)
```

`yield` **menghentikan sementara** fungsi, mengembalikan nilai, dan **melanjutkan** dari titik yang tepat pada iterasi berikutnya — menjaga state lokal antar nilai. Tidak ada yang dihitung sampai diminta.

## Manfaat memori

```python
sum(i ** 2 for i in range(10_000_000))   # generator expression — constant memory
sum([i ** 2 for i in range(10_000_000)]) # list — builds a huge list first (wasteful)
```

Untuk data besar, generator menjaga memori tetap rendah; list comprehension mewujudkan semuanya sekaligus.

## Urutan tak terbatas (tidak mungkin dengan list)

```python
def count_up():
    n = 0
    while True:        # infinite — but lazy, so it's fine
        yield n
        n += 1

gen = count_up()
next(gen)   # 0
next(gen)   # 1  — only computes when asked
```

Karena nilai diproduksi sesuai permintaan, generator dapat mewakili aliran *tak terbatas* — Anda hanya mengambil yang Anda butuhkan.

## Cara iterasi bekerja di balik layar

```python
gen = gen_squares(3)
next(gen)   # 0  — runs until the first yield
next(gen)   # 1  — resumes, runs to the next yield
next(gen)   # 4
next(gen)   # StopIteration — generator exhausted
```

## Ekspresi generator

```python
(x ** 2 for x in range(10))   # like a list comprehension but lazy (parentheses)
```

## Mengapa ini penting

Generator sangat penting untuk **pemrosesan yang hemat memori** dari data besar atau streaming — membaca file besar baris demi baris, memproses dataset besar, pipeline, atau urutan tak terbatas — di mana membangun list lengkap akan menghabiskan memori.

Memahami `yield` (pause/resume dengan state terjaga) dan lazy evaluation memungkinkan Anda menulis kode pemrosesan data yang scalable, dan ekspresi generator memberikan manfaat yang sama dengan ringkas.

Mereka adalah alat penting setiap kali data terlalu besar untuk masuk dalam memori atau Anda ingin memproses item saat diproduksi daripada semuanya di awal.