Apakah penjana dan kata kunci yield?

Question

Accepted Answer

A **generator** ialah fungsi yang menghasilkan nilai **dengan malas, satu per satu**, menggunakan kata kunci `yield` bukannya `return`. Ia mengira setiap nilai atas permintaan dan bukannya membina keseluruhan hasil dalam memori — ideal untuk urutan besar atau tak terhingga.

## 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** fungsi, mengembalikan nilai, dan **melanjutkan** dari titik tepat itu pada lelaran seterusnya — mengekalkan keadaan tempatan antara nilai. Tidak ada yang dikira sehingga 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, penjana mengekalkan memori rata; pemahaman senarai melaksana semuanya sekaligus.

## Urutan tak terhingga (mustahil dengan senarai)

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

Kerana nilai dihasilkan atas permintaan, penjana dapat mewakili aliran *tak terhingga* — anda hanya mengambil apa yang anda perlukan.

## Bagaimana lelaran berfungsi di bawah penutup

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

## Ungkapan penjana

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

## Mengapa penting

Penjana penting untuk pemprosesan data besar atau penstriman yang **cekap memori** — membaca fail besar baris demi baris, memproses set data besar, saluran, atau urutan tak terhingga — di mana membina senarai lengkap akan menghabiskan memori.

Memahami `yield` (henti/sambung dengan keadaan terpelihara) dan penilaian malas memungkinkan anda menulis kod pemprosesan data yang boleh diskalakan, dan ungkapan penjana memberikan manfaat yang sama secara ringkas.

Mereka adalah alat utama apabila data terlalu besar untuk muat dalam memori atau anda ingin memproses item semasa ia dihasilkan dan bukannya semuanya didahulukan.