ਇੱਕ iterable ਅਤੇ ਇੱਕ iterator ਵਿੱਚ ਕੀ ਅੰਤਰ ਹੈ?

Question

Accepted Answer

ਇੱਕ **iterable** ਕੋਈ ਵੀ ਚੀਜ਼ ਹੈ ਜਿਸ ਨੂੰ ਤੁਸੀਂ ਲੂਪ ਕਰ ਸਕਦੇ ਹੋ (ਇੱਕ ਸੂਚੀ, ਸਤਰ, dict); ਇੱਕ **iterator** ਓਹ ਵਸਤੂ ਹੈ ਜੋ ਅਸਲ ਦੀ ਪੁਨਰਾਵਰਤਤਾ ਕਰਦਾ ਹੈ, ਇੱਕ ਸਮੇਂ ਵਿੱਚ ਮੁੱਲ ਪੈਦਾ ਕਰਦਾ ਹੈ ਅਤੇ ਆਪਣੀ ਸਥਿਤੀ ਨੂੰ ਟ੍ਰੈਕ ਕਰਦਾ ਹੈ। ਇਹ ਅੰਤਰ ਇਸ ਗੱਲ ਨੂੰ ਸਮਝਾਉਂਦਾ ਹੈ ਕਿ Python ਵਿੱਚ `for` ਲੂਪ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ।

## ਦੋ ਪ੍ਰੋਟੋਕੋਲ

```text
Iterable → has __iter__()  → returns an iterator
Iterator → has __next__()  → returns the next value (and __iter__ returning itself)
```

## ਇੱਕ for ਲੂਪ ਸਚਮੁੱਚ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ

```python
# this for loop...
for x in [1, 2, 3]:
    print(x)

# ...is roughly equivalent to:
it = iter([1, 2, 3])    # __iter__ → get an iterator from the iterable
while True:
    try:
        x = next(it)     # __next__ → get the next value
        print(x)
    except StopIteration: # raised when exhausted → loop ends
        break
```

ਇੱਕ `for` ਲੂਪ ਇੱਕ iterator ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ `iter()` ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ, ਫਿਰ `next()` ਨੂੰ ਦੁਹਰਾ ਕੇ ਕਾਲ ਕਰਦਾ ਹੈ ਜਦੋਂ ਤੱਕ `StopIteration` ਅੰਤ ਦਾ ਸੰਕੇਤ ਦੇਵੇ। ਇਹ ਪ੍ਰੋਟੋਕੋਲ ਉਹ ਹੈ ਜੋ ਕਿਸੇ ਵੀ iterable ਨੂੰ ਲੂਪ ਕਰਨ ਯੋਗ ਬਣਾਉਂਦਾ ਹੈ।

## Iterable ਬਨਾਮ iterator ਵਿਅਕਤੀ

```python
nums = [1, 2, 3]        # an ITERABLE (a list)
it = iter(nums)         # an ITERATOR over it

next(it)   # 1
next(it)   # 2
next(it)   # 3
next(it)   # StopIteration

# the list is REUSABLE (get a fresh iterator each loop);
# an iterator is CONSUMED ONCE — exhausted after one pass
list(it)   # [] — already used up
```

ਮੁੱਖ ਅੰਤਰ: ਇੱਕ iterable (ਸੂਚੀ) ਨੂੰ ਕਈ ਵਾਰ ਲੂਪ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ (ਹਰ `for` ਨੂੰ ਇੱਕ ਤਾਜ਼ਾ iterator ਮਿਲਦਾ ਹੈ); ਇੱਕ iterator **ਇੱਕ ਵਾਰ ਵਰਤੋਂ** ਹੈ — ਇੱਕ ਵਾਰ ਪੂਰਾ ਹੋਣ ਮਗਰੋਂ, ਇਹ ਖਾਲੀ ਹੁੰਦਾ ਹੈ।

## ਇੱਕ ਕਸਟਮ iterator ਬਣਾਉਣਾ

```python
class Countdown:
    def __init__(self, start): self.n = start
    def __iter__(self): return self          # the iterable returns itself as iterator
    def __next__(self):
        if self.n <= 0:
            raise StopIteration               # signal the end
        self.n -= 1
        return self.n + 1

for x in Countdown(3):   # 3, 2, 1
    print(x)
```

## Generators iterators ਹਨ

```python
def gen(): yield 1; yield 2     # a generator function returns an iterator automatically
```

Generators iterators ਬਣਾਉਣ ਦਾ ਸਮਝਿਆ ਜਾਣ ਵਾਲਾ ਤਰੀਕਾ ਹਨ — `yield` ਤੁਹਾਡੇ ਲਈ `__next__`/`StopIteration` ਤੰਤਰ ਨੂੰ ਸੰਭਾਲਦਾ ਹੈ।

## ਇਹ ਕਿਉਂ ਮਹੱਤਵਪੂਰਨ ਹੈ

Iterable/iterator ਭਿੰਨਤਾ ਸਮਝਾਉਂਦੀ ਹੈ ਕਿ **Python ਵਿੱਚ `for` ਲੂਪ ਕਿਵੇਂ ਕੰਮ ਕਰਦੇ ਹਨ** ਅਤੇ ਕਿਵੇਂ ਪੁਨਰਾਵਰਤਤਾ ਸਮਸਤ ਸੰਗ੍ਰਹਾਂ (ਸੂਚੀਆਂ, dicts, ਫਾਈਲਾਂ, generators) ਵਿੱਚ iterator ਪ੍ਰੋਟੋਕੋਲ ਦੇ ਮਾਧਿਮ ਨਾਲ ਯਕਸਾਂ ਹਨ।

ਇਸ ਨੂੰ ਸਮਝਣਾ ਅਸਲ ਵਿਵਹਾਰਾਂ ਨੂੰ ਸਪੱਸ਼ਟ ਕਰਦਾ ਹੈ — ਕਿਉਂ ਇੱਕ iterator ਸਿਰਫ ਇੱਕ ਵਾਰ ਖਪਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ (ਇੱਕ ਆਮ ਬਗ: ਇੱਕ generator/zip ਨੂੰ ਦੋ ਵਾਰ ਲੂਪ ਕਰਨਾ ਦੂਜੀ ਵਾਰ ਕੁਝ ਨਹੀਂ ਦਿੰਦਾ), ਕਿਉਂ generators iterators ਹਨ, ਅਤੇ ਕਿਵੇਂ ਆਪਣੀਆਂ ਚੀਜ਼ਾਂ ਨੂੰ iterable ਬਣਾ ਸਕਦੇ ਹੋ।

ਇਹ ਪ੍ਰੋਟੋਕੋਲ Python ਦੇ ਸੁੰਦਰ, ਅਨੁਰੂਪ ਪੁਨਰਾਵਰਤਤਾ ਮਾਡਲ ਦੀ ਬਨਿਆਦ ਹੈ ਅਤੇ generators, lazy ਮੁਲਾਂਕਨ, ਅਤੇ ਕਸਟਮ iterable ਕਲਾਸਾਂ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਜ਼ਰੂਰੀ ਹੈ।