iterable మరియు iterator మధ్య వ్యత్యాసం ఏమిటి?

Question

Accepted Answer

ఒక **iterable** అనేది మీరు లూప్ చేయగల ఏదైనా (జాబితా, స్ట్రింగ్, dict); ఒక **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
```

ఒక `for` loop iterator పొందడానికి `iter()` ను కాల్ చేస్తుంది, ఆపై `StopIteration` ముగింపును సూచించే వరకు పదే పదే `next()` ను కాల్ చేస్తుంది. ఈ ప్రోటోకాల్ ఏదైనా 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` loops ఎలా పనిచేస్తుందో** వివరిస్తుంది మరియు iterator ప్రోటోకాల్ ద్వారా అన్ని సంગ్రహాలు (జాబితాలు, dicts, ఫైళ్లు, జనరేటర్‌లు) పునరావృత్తి ఎలా ఏకీకృతమైనదో విశదీకరిస్తుంది.

ఇది అర్థం చేసుకోవడం వాస్తవ ప్రవర్తనలను స్పష్టం చేస్తుంది — iterator ఎందుకు ఒక్కసారి మాత్రమే వినియోగించబడుతుంది (సాధారణ బగ్: జనరేటర్/zip ను రెండుసార్లు లూప్ చేయడం రెండవ సారి ఏమీ ఇవ్వదు), జనరేటర్‌లు iterators ఎందుకు, మరియు మీ స్వంత ఆబ్జెక్ట్‌లను iterable చేయాలి ఎలా చేయాలి.

ఈ ప్రోటోకాల్ Python యొక్క సుందర, సంగత పునరావృత్తి నమూనాకు ఆధారం మరియు జనరేటర్‌లు, సున్నితమైన మూల్యాంకనం, మరియు కస్టమ్ iterable తరగతులతో పనిచేయడానికి అవసరమైనది.