Python Academy · Aula

O protocolo de iteradores

Entenda __iter__ e __next__

O protocolo de iteradores é uma aula grátis de Python Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Python Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Python Academy inclui 4 aulas no total.

O que é iteração?

Sempre que você escreve um laço for sobre uma lista, string ou dicionário, o Python usa o protocolo de iteração nos bastidores.

Um objeto sobre o qual você pode fazer um laço é chamado de iterável. O elemento que realmente produz valores um de cada vez é chamado de iterador.

for ch in 'abc':
    print(ch)

iter() e next()

Duas funções integradas conduzem a iteração:

iter(obj) solicita o iterador de um iterável.
next(it) solicita o próximo valor ao iterador.

Quando não há mais valores, next() gera StopIteration.

it = iter([10, 20, 30])
print(next(it))
print(next(it))
print(next(it))

StopIteration

Chamar next() uma vez além do necessário gera StopIteration. Um laço for captura isso automaticamente e para de forma limpa.

it = iter([1])
print(next(it))
try:
    next(it)
except StopIteration:
    print('No more items')

Os dois métodos especiais

Para criar seu próprio iterador, você implementa dois métodos:

__iter__ retorna o próprio objeto iterador.
__next__ retorna o próximo valor ou gera StopIteration.

class Count:
    def __init__(self, n):
        self.i = 0
        self.n = n
    def __iter__(self):
        return self
    def __next__(self):
        if self.i >= self.n:
            raise StopIteration
        self.i += 1
        return self.i

for x in Count(3):
    print(x)

Iterável versus iterador

Um iterável precisa apenas de __iter__. Um iterador precisa de __iter__ e __next__.

Listas são iteráveis, mas não são iteradores: cada chamada a iter() fornece um iterador novo.

nums = [1, 2, 3]
print(iter(nums) is iter(nums))
it = iter(nums)
print(it is iter(it))

Iteradores se esgotam uma vez

Um iterador pode ser consumido apenas uma vez. Depois que você chega ao final, ele permanece vazio. Para fazer o laço novamente, crie um iterador novo.

it = iter([1, 2])
print(list(it))
print(list(it))

Um iterador semelhante a um intervalo

Vamos criar um iterador personalizado que se comporta como um contador simples. Observe como o estado fica na instância.

class EvenUpTo:
    def __init__(self, limit):
        self.cur = 0
        self.limit = limit
    def __iter__(self):
        return self
    def __next__(self):
        if self.cur > self.limit:
            raise StopIteration
        value = self.cur
        self.cur += 2
        return value

print(list(EvenUpTo(8)))

Separando iterável e iterador

Um design mais limpo mantém o contêiner e o iterador separados, para que o contêiner possa ser percorrido várias vezes.

class Bag:
    def __init__(self, items):
        self.items = items
    def __iter__(self):
        return BagIterator(self.items)

class BagIterator:
    def __init__(self, items):
        self.items = items
        self.i = 0
    def __iter__(self):
        return self
    def __next__(self):
        if self.i >= len(self.items):
            raise StopIteration
        v = self.items[self.i]
        self.i += 1
        return v

b = Bag(['x', 'y'])
print(list(b))
print(list(b))

Usando next() com um valor padrão

next(it, default) retorna o valor padrão em vez de gerar StopIteration quando o iterador está vazio. É útil para consultar com segurança.

it = iter([42])
print(next(it, 'done'))
print(next(it, 'done'))

Iteradores economizam memória

Iteradores fornecem um item de cada vez, portanto não precisam manter toda a sequência na memória. É por isso que conseguem lidar com fluxos enormes ou até infinitos.

class Naturals:
    def __init__(self):
        self.n = 0
    def __iter__(self):
        return self
    def __next__(self):
        self.n += 1
        return self.n

it = iter(Naturals())
print(next(it), next(it), next(it))

Funções integradas que consomem iteradores

Muitas funções integradas aceitam qualquer iterador: sum, max, min, sorted, list, tuple. Elas extraem valores até StopIteration.

class Count:
    def __init__(self, n):
        self.i = 0
        self.n = n
    def __iter__(self):
        return self
    def __next__(self):
        if self.i >= self.n:
            raise StopIteration
        self.i += 1
        return self.i

print(sum(Count(5)))
print(max(Count(5)))

Verificação rápida

Teste sua compreensão do protocolo de iteradores.

Recapitulação

Você aprendeu o protocolo de iteradores:

iter() obtém um iterador; next() extrai valores.
StopIteration sinaliza o fim, e for trata essa situação.
Iteradores personalizados implementam __iter__ e __next__.
Iteradores são de uso único e econômicos no consumo de memória.

Em seguida, você deixará o Python escrever iteradores para você com yield.

Perguntas Frequentes

A aula “O protocolo de iteradores” é grátis?

Sim — o texto completo de “O protocolo de iteradores” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Python Academy, atualize para CoddyKit PRO. O curso de Python Academy inclui 4 aulas no total.

O que vou aprender em “O protocolo de iteradores”?

Entenda __iter__ e __next__ Você pratica Python Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Python Academy?

Nenhuma experiência prévia é necessária. Python Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “O protocolo de iteradores”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Python Academy?

Sim. Cada aula de Python Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Python Academy