Wat is het verschil tussen een iterable en een iterator?

Question

Accepted Answer

An **iterable** is alles wat je kunt doorlopen (een list, string, dict); an **iterator** is het object dat de daadwerkelijke iteratie uitvoert, waarden één voor één produceert en de positie bijhoudt. Dit onderscheid vormt de basis van hoe `for` loops in Python werken.

## De twee protocollen

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

## Hoe een for loop werkelijk werkt

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

Een `for` loop roept `iter()` aan om een iterator te krijgen, roept vervolgens herhaaldelijk `next()` aan totdat `StopIteration` het einde aangeeft. Dit protocol is wat elke iterable doorloopbaar maakt.

## Iterable vs iterator in de praktijk

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

Kern verschil: een iterable (list) kan meerdere keren worden doorlopen (elke `for` krijgt een verse iterator); een iterator is **eenmalig gebruik** — eenmaal uitgeput, is het leeg.

## Een aangepaste iterator bouwen

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

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

Generators zijn de gemakkelijke manier om iterators te maken — `yield` handelt het `__next__`/`StopIteration` mechanisme voor je af.

## Waarom het belangrijk is

Het iterable/iterator onderscheid legt uit **hoe `for` loops in Python werken** en hoe iteratie is unified over alle collecties (lists, dicts, files, generators) via het iterator protocol.

Het begrijpen ervan verduidelijkt echt gedrag — waarom een iterator maar eenmaal kan worden verbruikt (een veelvoorkomende fout: een generator/zip tweemaal doorlopen geeft niets de tweede keer), waarom generators iterators zijn, en hoe je je eigen objecten iterable maakt.

Dit protocol is de basis van Pythons elegante, consistente iteratiemodel en is essentieel voor het werken met generators, lazy evaluation en aangepaste iterable klassen.