Mikä on ero iteraation ja iteraattorin välillä?

Question

Accepted Answer

**Iterable** on mitä tahansa, jonka yli voit iteroida (lista, merkkijono, dict); **iterator** on objekti, joka suorittaa varsinaisen iteraation, tuottaa arvoja yksi kerrallaan ja seuraa paikkaa. Tämä ero on `for`-silmukoiden toiminnan perusta Pythonissa.

## Kaksi protokollaa

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

## Kuinka for-silmukka todella toimii

```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`-silmukka kutsuu `iter()`:ia saadakseen iteraattorin, sitten kutsuu `next()`:ia toistuvasti kunnes `StopIteration` ilmoittaa lopusta. Tämä protokolla tekee mistä tahansa iterablen silmukaksi.

## Iterable vs iterator käytännössä

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

Pääero: iterable (lista) voidaan iteroida monta kertaa (jokainen `for` saa uuden iteraattorin); iterator on **kertakäyttöinen** — kerran kulutuksi se on tyhjä.

## Mukautetun iteraattorin rakentaminen

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

## Generaattorit ovat iteraattoreita

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

Generaattorit ovat helppo tapa luoda iteraattoreita — `yield` hoitaa `__next__`/`StopIteration`-mekanismin puolestasi.

## Miksi se on tärkeää

iterable/iterator-ero selittää **kuinka `for`-silmukat toimivat** Pythonissa ja kuinka iteraatio on yhtenäistetty kaikkien kokoelmien (listat, dictit, tiedostot, generaattorit) välillä iterator-protokollan kautta.

Ymmärtäminen selventää todellisen käyttäytymisen — miksi iteraattoria voidaan käyttää vain kerran (yleinen virhe: generaattorin/zip:in iterointi kahdesti ei tuota mitään toisen kerran), miksi generaattorit ovat iteraattoreita, ja kuinka tehdä omista objekteista iterablet.

Tämä protokolla on Pythonin tyylikkään, johdonmukaisen iteraatiomallin perusta ja on välttämätön työskennellessä generaattoreiden, laiskasti evaluoitavien funktioiden ja mukautettujen iterable-luokkien kanssa.