Iteradores do Python

Iteradores são objetos iteráveis. Neste tutorial, você aprenderá o funcionamento dos iteradores e como construir seus próprios iteradores usando os métodos __iter__ e __next__.

O que é um iterador no Python?

Os iteradores no Python estão em todas as partes. Eles são implementados de forma elegante em loops for, compreensões, geradores, etc., mas escondidos sob a superfície.

Um Iterator no Python é apenas um objeto iterávelobjeto. Um objeto que retorna dados, um elemento de cada vez.

Tecnicamente, o Python objeto iteradorDeve ser implementado dois métodos especiais, __iter__() e __next__(), chamados decontrato de iterador.

Se conseguirmos obter um iterador de um objeto, esse objeto é chamado deiteráveliteração. A maioria dos contêineres internos do Python (por exemplo:list,tuple,stringetc.) são iteráveis.

A função iter() (ou o método __iter__() também conhecido como) retorna um iterador a partir deles.

Iterando com iteradores no Python

Usamos a função next() para percorrer manualmente todos os itens do iterador. Quando chegamos ao final e não há mais dados a serem retornados, ele lança StopIteration. Abaixo está um exemplo.

# Definir uma lista
my_list = [4,　7, 0,　3]
# Obter iterador usando iter()
my_iter = iter(my_list)
## Obter iterador usando iter()　
# Saída　4
print(next(my_iter))
# Saída　7
print(next(my_iter))
## next(obj) é o mesmo que obj.__next__()
# Saída 0
print(my_iter.__next__())
# Saída　3
print(my_iter.__next__())
## Isso causará um erro, não há mais itens
next(my_iter)

Uma maneira mais elegante de iterar automaticamente é usarloop forCom este método, podemos iterar sobre qualquer objeto que possa retornar um iterador, como listas, strings, arquivos, etc.

>>> for element in my_list:
... print(element)
...　　　　　
4
7
0
3

Como funciona o loop for na verdade?

Como vimos no exemplo acima, o loop for pode percorrer automaticamente uma lista.

Na verdade, o loop for pode iterar sobre qualquer objeto iterável. Vamos ver com atenção como o loop for é implementado na prática no Python.

for　element　in　iterable:
　　　　#　Faça algo com o elemento

na verdade é implementado como.

#　Cria um objeto iterador iterable
iter_obj　=　iter(iterable)
#　Loop infinito
while　True:
　　　　try:
　　　　　　　　#　Obtenha o próximo item
　　　　　　　　element　=　next(iter_obj)
　　　　　　　　#　Faça algo com o elemento
　　　　except　StopIteration:
　　　　　　　　#　Se StopIteration for lançado, sai do loop
　　　　　　　　break

Portanto, internamente, o loop 'for' cria um objeto iterador iter_obj chamando iter() no iterable.

Ironicamente, esse loop 'for' é realmente infinitoLoop 'while'.

Dentro do loop, ele chama next() para obter o próximo elemento e usa esse valor para executar o corpo do loop 'for'. Quando todos os itens forem usados, StopIteration é lançado, capturado internamente e o loop termina. Note que qualquer outro tipo de exceção passará.

Construir iteradores próprios com Python

É fácil construir iteradores do zero em Python. Precisamos apenas implementar esses métodos __iter__() e __next__().

O método __iter__() retorna o objeto iterador em si. Pode executar algumas inicializações, se necessário.

O método __next__() deve retornar o próximo item da sequência. Ele deve levantar StopIteration quando alcançar o final e em chamadas subsequentes.

Aqui, mostramos um exemplo que fornecerá2potência. O expoente de potência varia de 0 até o número definido pelo usuário.

class　PowTwo:
　　　　"Classe para implementar iteradores"
　　　　　　　　　　　　　"potência de dois"
　　　　def　__init__(self,　max　=　0):
　　　　　　　　self.max　=　max
　　　　def __iter__(self):
　　　　　　　　self.n　=　0
　　　　　　　　return self
　　　　def __next__(self):
　　　　　　　　if　self.n　<=　self.max:
　　　　　　　　　　　　result　=　2　**　self.n
　　　　　　　　　　　　self.n　+=　1
　　　　　　　　　　　　return　result
　　　　　　　　else:
　　　　　　　　　　　　raise　StopIteration

Agora, podemos criar um iterador e iterar da seguinte forma.

>>>　a　=　PowTwo(4)
>>>　i　=　iter(a)
>>>　next(i)
1
>>>　next(i)
2
>>>　next(i)
4
>>>　next(i)
8
>>>　next(i)
16
>>>　next(i)
Traceback　(most　recent　call　last):
...
StopIteration

Podemos usar um loop 'for' para iterar sobre um iterador de classe.

>>>　for　i　in　PowTwo(5):
...　　　　　print(i)
...　　　　　
1
2
4
8
16
32

Iterador infinito do Python

Os itens no objeto do iterador não precisam ser esgotados. Pode haver iteradores infinitos (que nunca terminam). Ao lidar com esses iteradores, devemos ser cuidadosos.

Este é um exemplo simples de demonstração de iterador infinito.

Funções integradas O iter() pode ser chamado com dois parâmetros, onde o primeiro parâmetro deve ser um objeto callable (função) e o segundo parâmetro é o marcador. O iterador chama essa função até que o valor retornado seja igual ao valor marcador.

>>> int()
0
>>> inf = iter(int,1)
>>> next(inf)
0
>>> next(inf)
0

Podemos ver que a função int() sempre retorna 0. Portanto, a usamos como iter(int,1)Passar retornará um iterador que chama int() até que o valor retornado seja igual a1. Isso nunca acontecerá e obteremos um iterador infinito.

Também podemos construir nosso próprio iterador infinito. Teoricamente, o seguinte iterador retornará todos os números ímpares.

class InfIter:
　　　　"O iterador infinito retorna todos"
　　　　　　　　　　　　　　　　　"ímpares"
　　　　def __iter__(self):
　　　　　　　　self.num =　1
　　　　　　　　return self
　　　　def __next__(self):
　　　　　　　　num = self.num
　　　　　　　　self.num　+=　2
　　　　　　　　return num

Execute conforme所示.

>>> a = iter(InfIter())
>>> next(a)
1
>>> next(a)
3
>>> next(a)
5
>>> next(a)
7

etc...

Tenha cuidado ao iterar sobre esses tipos de iteradores infinitos, incluindo condições de terminação.

As vantagens de usar iteradores são a economia de recursos. Como mostrado acima, podemos obter todos os números ímpares sem precisar armazenar todo o sistema numérico na memória. Teoricamente, podemos incluir itens infinitos em memória limitada.

Iteradores também fazem nosso código parecer mais legal.

Existe uma maneira conveniente de criar iteradores em Python. Para obter mais informações, acesse:Gerações do Python yield.