Qual é a diferença entre um iterable e um iterator?

Question

Accepted Answer

Um **iterable** é tudo aquilo sobre o qual você pode fazer um loop (uma lista, string, dict); um **iterator** é o objeto que faz a iteração real, produzindo valores um de cada vez e rastreando sua posição. Essa distinção fundamenta como os loops `for` funcionam em Python.

## Os dois protocolos

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

## Como um loop for realmente funciona

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

Um loop `for` chama `iter()` para obter um iterator, depois chama `next()` repetidamente até que `StopIteration` sinalize o fim. Esse protocolo é o que torna qualquer iterable iterável.

## Iterable vs iterator na prática

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

Diferença chave: um iterable (lista) pode ser iterado muitas vezes (cada `for` obtém um iterator fresco); um iterator é **de uso único** — uma vez esgotado, está vazio.

## Construindo um iterator customizado

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

## Geradores são iterators

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

Geradores são a maneira fácil de criar iterators — `yield` lida com a maquinaria `__next__`/`StopIteration` para você.

## Por que isso importa

A distinção iterable/iterator explica **como os loops `for` funcionam** em Python e como a iteração é unificada em todas as coleções (listas, dicts, arquivos, geradores) via o protocolo iterator.

Entender isso esclarece comportamentos reais — por que um iterator pode ser consumido apenas uma vez (um bug comum: iterando um generator/zip duas vezes não retorna nada na segunda vez), por que geradores são iterators e como criar seus próprios objetos iterable.

Esse protocolo é a base do elegante e consistente modelo de iteração do Python e é essencial para trabalhar com geradores, avaliação preguiçosa e classes iterable customizadas.