ਜਨਰੇਟਰ ਅਤੇ yield ਕੀਵਰਡ ਕੀ ਹਨ?

Question

Accepted Answer

**ਜਨਰੇਟਰ** ਇੱਕ ਫੰਕਸ਼ਨ ਹੈ ਜੋ ਮੁੱਲਾਂ ਨੂੰ **ਆਲਸੀ ਤਰੀਕੇ ਨਾਲ, ਇੱਕ ਵਾਰ ਇੱਕ**, `yield` ਕੀਵਰਡ ਦੀ ਵਰਤੋਂ ਕਰਕੇ `return` ਦੀ ਥਾਂ ਤੇ ਪੈਦਾ ਕਰਦਾ ਹੈ। ਇਹ ਪੂਰੇ ਨਤੀਜੇ ਨੂੰ ਮੈਮੋਰੀ ਵਿੱਚ ਬਣਾਉਣ ਦੀ ਬਜਾਏ ਹਰ ਮੁੱਲ ਨੂੰ ਮੰਗ ਅਨੁਸਾਰ ਗਣਨਾ ਕਰਦਾ ਹੈ — ਵੱਡੇ ਜਾਂ ਅਨੰਤ ਕ੍ਰਮ ਲਈ ਆਦਰਸ਼।

## 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` ਫੰਕਸ਼ਨ ਨੂੰ **ਰੋਕਦਾ** ਹੈ, ਇੱਕ ਮੁੱਲ ਵਾਪਸ ਕਰਦਾ ਹੈ, ਅਤੇ ਅਗਲੀ ਵਾਰ **ਉਸੇ ਥਾਂ ਤੋਂ ਦੁਬਾਰਾ ਸ਼ੁਰੂ ਕਰਦਾ** ਹੈ — ਮੁੱਲਾਂ ਦੇ ਵਿੱਚ ਸਥਾਨਕ ਅਵਸਥਾ ਨੂੰ ਸੁਰੱਖਿਤ ਰੱਖਦਾ ਹੈ। ਜਦੋਂ ਤੱਕ ਮੰਗੀ ਨਾ ਜਾਵੇ ਤਾਂ ਕੁਝ ਵੀ ਗਣਨਾ ਨਹੀਂ ਕੀਤੀ ਜਾਂਦੀ।

## ਮੈਮੋਰੀ ਦਾ ਲਾਭ

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

ਵੱਡੇ ਡੇਟਾ ਲਈ, ਜਨਰੇਟਰ ਮੈਮੋਰੀ ਨੂੰ ਸਮਤਲ ਰੱਖਦੇ ਹਨ; ਲਿਸਟ ਸਮਝ ਸਭ ਕੁਝ ਇੱਕ ਵਾਰ ਵਿੱਚ ਭੌਤਿਕ ਕਰਦੀ ਹੈ।

## ਅਨੰਤ ਕ੍ਰਮ (ਲਿਸਟ ਨਾਲ ਅਸੰਭਵ)

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

ਕਿਉਂਕਿ ਮੁੱਲਾਂ ਨੂੰ ਮੰਗ ਅਨੁਸਾਰ ਪੈਦਾ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਇੱਕ ਜਨਰੇਟਰ *ਅਨੰਤ* ਸਟ੍ਰੀਮ ਨੂੰ ਦਰਸਾ ਸਕਦਾ ਹੈ — ਤੁਸੀਂ ਸਿਰਫ ਉਹੋ ਲੈਂਦੇ ਹੋ ਜੋ ਤੁਹਾਨੂੰ ਲੋੜ ਹੈ।

## ਦੇ ਅੰਦਰ ਕਿਵੇਂ ਦੁਹਰਾਉ ਕੰਮ ਕਰਦਾ ਹੈ

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

## ਜਨਰੇਟਰ ਸਮੀਕਰਨ

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

## ਇਸ ਦਾ ਮਾਇਨਾ

ਜਨਰੇਟਰ ਵੱਡੇ ਜਾਂ ਸਟ੍ਰੀਮਿੰਗ ਡੇਟਾ ਦੀ **ਮੈਮੋਰੀ-ਲਾਭਦਾਇਕ** ਪ੍ਰਕਿਰਿਆ ਲਈ ਜ਼ਰੂਰੀ ਹਨ — ਵਿਸ਼ਾਲ ਫਾਇਲਾਂ ਨੂੰ ਲਾਈਨ ਦਰ ਲਾਈਨ ਪੜ੍ਹਨਾ, ਵੱਡੇ ਡੇਟਾਸੈਟਾਂ ਦੀ ਪ੍ਰਕਿਰਿਆ, ਪਾਈਪਲਾਈਨ, ਜਾਂ ਅਨੰਤ ਕ੍ਰਮ — ਜਿੱਥੇ ਪੂਰੀ ਲਿਸਟ ਬਣਾਉਣਾ ਮੈਮੋਰੀ ਨੂੰ ਖਤਮ ਕਰ ਦੇਵੇ।

`yield` ਨੂੰ ਸਮਝਣਾ (ਅਵਸਥਾ ਸੁਰੱਖਿਤ ਨਾਲ ਰੋਕਣਾ/ਸ਼ੁਰੂ ਕਰਨਾ) ਅਤੇ ਆਲਸੀ ਮੁਲਾਂਕਣ ਤੁਹਾਨੂੰ ਸਕੇਲਯੋਗ ਡੇਟਾ-ਪ੍ਰਕਿਰਿਆ ਕੋਡ ਲਿਖਣ ਦਿੰਦਾ ਹੈ, ਅਤੇ ਜਨਰੇਟਰ ਸਮੀਕਰਨ ਅਭਾਸ ਤਰੀਕੇ ਨਾਲ ਇਹੀ ਲਾਭ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ।

ਉਹ ਜ਼ਰੂਰੀ ਸਾਧਨ ਹਨ ਜਦੋਂ ਡੇਟਾ ਮੈਮੋਰੀ ਵਿੱਚ ਫਿੱਟ ਕਰਨ ਲਈ ਬਹੁਤ ਵੱਡਾ ਹੋਵੇ ਜਾਂ ਤੁਸੀਂ ਆਈਟਮ ਪ੍ਰਕਿਰਿਆ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ ਜਿਵੇਂ ਉਹ ਉਤਪਾਦਿਤ ਹੋਣ ਬਜਾਏ ਸਭ ਆਗੇ।