Jeneratörler ve yield anahtar kelimesi nedir?

Question

Accepted Answer

**Jeneratör**, `return` yerine `yield` anahtar kelimesini kullanarak **tembelce, bir seferde bir tane** değerler üreten bir fonksiyondur. Tüm sonucu bellekte inşa etmek yerine her bir değeri talep üzerine hesaplar — büyük veya sonsuz diziler için ideal.

## 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` fonksiyonu **durdurur**, bir değer döndürür ve sonraki yinelemede tam o noktadan **devam eder** — değerler arasında yerel durumu korur. Talep edilene kadar hiçbir şey hesaplanmaz.

## Bellek avantajı

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

Büyük veriler için jeneratörler belleği düz tutarken; bir liste anlayışı her şeyi bir kerede somutlaştırır.

## Sonsuz diziler (bir liste ile imkansız)

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

Değerler talep üzerine üretildiği için, bir jeneratör *sonsuz* bir akışı temsil edebilir — sadece ihtiyacınız olanı alırsınız.

## Yineleme motorun altında nasıl çalışır

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

## Jeneratör ifadeleri

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

## Neden önemli

Jeneratörler, büyük veya akan verinin **bellek açısından verimli** işlenmesi için gereklidir — dev dosyaları satır satır okumak, büyük veri setlerini işlemek, ardışık düzen veya sonsuz diziler — tam bir liste oluşturmak belleği tüketecek yerlerde.

`yield` (koruma altında durumu ile duraklatma/devam etme) ve tembel değerlendirmesini anlamak, ölçeklenebilir veri işleme kodu yazmanızı sağlar ve jeneratör ifadeleri aynı faydayı kısaca sağlar.

Veriler bellekle sığmayacak kadar büyük olduğunda veya önceden hepsi yerine üretildikçe öğeleri işlemek istediğinizde, bunlar önemli bir araçtır.