Vad är skillnaden mellan ett iterable och en iterator?

Question

Accepted Answer

Ett **iterable** är något du kan loopa över (en list, sträng, dict); en **iterator** är objektet som utför själva iterationen, producerar värden ett i taget och spårar sin position. Denna distinktion ligger till grund för hur `for`-loopar fungerar i Python.

## De två protokollen

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

## Hur en for-loop verkligen fungerar

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

En `for`-loop anropar `iter()` för att få en iterator, och anropar sedan upprepade gånger `next()` tills `StopIteration` signalerar slutet. Detta protokoll är det som gör ett iterable loopbart.

## Iterable vs iterator i praktiken

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

Huvudskillnad: ett iterable (list) kan loopas många gånger (varje `for` får en ny iterator); en iterator är **engångs** — när den är uttömd är den tom.

## Bygga en egen 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 är iterators

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

Generators är det enkla sättet att skapa iterators — `yield` hanterar `__next__`/`StopIteration`-mekaniken åt dig.

## Varför det är viktigt

Distinktionen iterable/iterator förklarar **hur `for`-loopar fungerar** i Python och hur iteration är enhetlig över alla collections (lists, dicts, filer, generators) via iteratorprotokollet.

Att förstå det klargör verkligt beteende — varför en iterator bara kan konsumeras en gång (en vanlig bugg: loopa en generator/zip två gånger ger ingenting andra gången), varför generators är iterators, och hur du gör dina egna objekt iterable.

Detta protokoll är grunden för Pythons eleganta, konsekventa iterationsmodell och är väsentligt när du arbetar med generators, lat evaluering och egna iterable-klasser.