iterable आणि iterator मध्ये काय फरक आहे?

Question

Accepted Answer

An **iterable** हे कोणतेही आहे जे तुम्ही लूप करू शकता (list, string, dict); an **iterator** ही ऑब्जेक्ट आहे जी वास्तविक पुनरावृत्ती करते, एक वेळी मूल्ये तयार करते आणि त्याची स्थिती ट्रॅक करते. हा फरक Python मध्ये `for` loops कसे काम करते हे स्पष्ट करते.

## दोन प्रोटोकॉल

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

## for loop खरोखर कसे काम करते

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

A `for` loop iterator मिळवण्यासाठी `iter()` कॉल करते, नंतर `StopIteration` पर्यंत शेवटचा सिग्नल दिला तोपर्यंत `next()` पुन्हा पुन्हा कॉल करते. ही प्रोटोकॉल आहे जी कोणतेही iterable loopable बनवते.

## व्यवहारात Iterable vs 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 (list) कितनीही वेळा लूप केले जाऊ शकते (प्रत्येक `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 फरक **`for` loops Python मध्ये कसे काम करते** हे स्पष्ट करते आणि iterator protocol द्वारे सर्व संग्रह (lists, dicts, files, generators) मध्ये पुनरावृत्ती कसे एकीकृत केली जाते.

हे समजणे वास्तविक वर्तन स्पष्ट करते — का एक iterator फक्त एकदाच वापरला जाऊ शकतो (एक सामान्य बग: generator/zip दोनदा लूप करणे दुसऱ्या वेळी काहीही देत नाही), का generators iterators आहेत, आणि तुमच्या स्वतःच्या ऑब्जेक्ट्सला iterable कसे बनवता येते.

ही protocol Python च्या मोहक, सुसंगत पुनरावृत्ती मॉडेलचा पाया आहे आणि generators, lazy evaluation, आणि कस्टम iterable classes सह काम करण्यासाठी आवश्यक आहे.