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` લૂપ `iter()` ને કૉલ કરે છે iterator મેળવવા માટે, પછી બધાર `next()` ને કૉલ કરે છે જ્યાં સુધી `StopIteration` અંત સૂચવે. આ પ્રોટોકોલ જ કોઈપણ iterable ને લૂપ કરવા યોગ્ય બનાવે છે.

## વ્યવહારમાં 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 (યાદી) ને ઘણીવાર લૂપ કરી શકાય છે (દરેક `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)
```

## જનરેટર iterators છે

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

જનરેટર્સ iterators બનાવવાનો સરળ રસ્તો છે — `yield` તમારા માટે `__next__`/`StopIteration` મશીનરી સંભાળે છે.

## શા માટે તે મહત્વપૂર્ણ છે

iterable/iterator તફાવત સમજાવે છે **Python માં `for` લૂપ્સ કેવી રીતે કામ કરે છે** અને iterator protocol દ્વારા તમામ સંગ્રહમાં પુનરાવર્તન કેવી રીતે એકીકૃત છે (યાદીઓ, dicts, ફાઇલો, જનરેટર્સ).
	ેને સમજવું વાસ્તવિક વર્તણૂક સ્પષ્ટ કરે છે — શા માટે iterator ને માત્ર એક વાર વપરાશ કરી શકાય છે (સામાન્ય bug: જનરેટર/zip ને બે વાર લૂપ કરવું બીજી વાર કંઈ આપતું નથી), શા માટે જનરેટર્સ iterators છે, અને તમારી પોતાની વસ્તુઓને iterable બનાવવું કેવી રીતે.

આ પ્રોટોકોલ Python ના મમોહક, સુસંગત પુનરાવર્તન મોડેલનો આધાર છે અને જનરેટર્સ, આલસ મૂલ્યાંકન, અને કસ્ટમ iterable વર્ગો સાથે કામ કરવા માટે આવશ્યક છે.