Iteratore di Python

Gli iteratori sono oggetti iterabili. In questo tutorial, imparerai il funzionamento degli iteratori e come costruire i tuoi iteratori con i metodi __iter__ e __next__.

Cos'è l'iteratore in Python?

Gli iteratori sono onnipresenti in Python. Vengono implementati elegantemente nei cicli for, comprehension e generatori, ma sono nascosti sotto i nostri occhi.

L'iteratore in Python è solo qualcosa che può essere iteratoOggetto. Un oggetto che restituisce i dati, uno per volta.

In sostanza, Python Oggetto iteratoreDeve implementare due metodi speciali, __iter__() e __next__(), noto anche comeContratto dell'iteratore.

Se possiamo ottenere un iteratore dall'oggetto, allora l'oggetto viene chiamatoIterabileIterare. La maggior parte delle container integrati in Python (ad esempio:list,tuple,stringecc.) sono iterabili.

La funzione iter() (ovvero il metodo __iter__()) restituisce un iteratore.

Iterare con iteratori in Python

Usiamo la funzione next() per esplorare manualmente tutti gli elementi dell'iteratore. Quando raggiungiamo la fine e non ci sono più dati da restituire, solleva StopIteration. Ecco un esempio...

# Definire una lista
my_list = [4, 7, 0, 3]
# Ottenere un iteratore utilizzando iter()
my_iter = iter(my_list)
## Ottenere un iteratore utilizzando iter()　
# Output 4
print(next(my_iter))
# Output 7
print(next(my_iter))
## next(obj) è lo stesso di obj.__next__()
# Output 0
print(my_iter.__next__())
# Output 3
print(my_iter.__next__())
## Questo causerà un errore, non ci sono più elementi
next(my_iter)

Un metodo più elegante per l'iterazione automatica è l'uso diCiclo for. Con questo metodo, possiamo iterare qualsiasi oggetto che può restituire un iteratore, come liste, stringhe, file, ecc.

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

Come funziona effettivamente il ciclo for?

Come abbiamo visto nell'esempio sopra, il ciclo for può attraversare automaticamente una lista.

In realtà, il ciclo for può iterare qualsiasi oggetto iterabile. Vediamo come il ciclo for viene implementato effettivamente in Python.

for element in iterable:
　　　　#　Fai qualcosa con l'elemento

In realtà, è implementato come.

# Creare un oggetto iteratore iterable
iter_obj　=　iter(iterable)
#　Ciclo infinito
while　True:
　　　　try:
　　　　　　　　#　Ottieni il prossimo elemento
　　　　　　　　element　=　next(iter_obj)
　　　　　　　　#　Fai qualcosa con l'elemento
　　　　except　StopIteration:
　　　　　　　　#　Se solleva StopIteration, esce dal ciclo
　　　　　　　　break

Quindi, internamente, il ciclo for crea un oggetto iteratore iter_obj chiamando iter() sull'iterabile.

Sarà sorprendente, ma questo ciclo for è in realtà infinitoCiclo while.

All'interno del ciclo, chiama next() per ottenere l'elemento successivo e utilizza questo valore per eseguire il corpo del ciclo for. Quando tutti gli elementi sono stati utilizzati, viene sollevato StopIteration, che viene catturato internamente e il ciclo termina. Nota che qualsiasi altro tipo di eccezione passa.

Costruire il proprio iteratore con Python

È facile costruire un iteratore da zero in Python. Dobbiamo solo implementare questi metodi __iter__() e __next__().

Il metodo __iter__() restituisce l'oggetto iteratore stesso. Può eseguire alcune inizializzazioni se necessario.

Il metodo __next__() deve restituire il prossimo elemento della sequenza. Deve sollevare StopIteration quando si raggiunge la fine e in chiamate successive.

Qui, mostriamo un esempio che ci fornirà la potenza di 2 in ogni iterazione. L'esponente parte da 0 fino al numero impostato dall'utente.

class　PowTwo:
　　　　"Classe che implementa l'iteratore"
　　　　　　　　　　　　　"Potenza di 2"
　　　　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

Ora, possiamo creare un iteratore e iterarlo come segue.

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

Possiamo anche utilizzare un ciclo for per iterare attraverso l'iteratore della classe.

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

Iteratore infinito Python

Gli elementi dell'oggetto iteratore non devono essere esauriti. Potrebbero esserci iteratori infiniti (che non finiscono mai). Quando si gestiscono questi iteratori, si deve fare attenzione.

Questo è un esempio semplice di demo dell'iteratore infinito.

Funzioni incorporate L'iter() può essere chiamato con due parametri, dove il primo parametro deve essere un oggetto callable (funzione), il secondo parametro è il marcatore. L'iteratore chiama questa funzione fino a quando il valore restituito è uguale al valore del marcatore.

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

Possiamo vedere che la funzione int() restituisce sempre 0. Pertanto, passare int() come iter(int, 1) restituirà un iteratore che chiama int() fino a quando il valore restituito è uguale a 1. Questo non accadrà mai e otterremo un iteratore infinito.

Possiamo anche costruire i nostri own iteratori infiniti. Teoricamente, l'iteratore seguente restituirà tutti i numeri dispari.

class InfIter:
　　　　"""L'iteratore infinito di Python restituisce tutti
　　　　　　　　　　　　　　　　　Numeri dispari
　　　　def __iter__(self):
　　　　　　　　self.num = 1
　　　　　　　　return self
　　　　def __next__(self):
　　　　　　　　num = self.num
　　　　　　　　self.num += 2
　　　　　　　　return num

Esegui il seguente.

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

E così via...

Quando si itera su questi tipi di iteratori infiniti, prestare attenzione a includere la condizione di terminazione.

I vantaggi dell'uso degli iteratori sono la risparmio di risorse. Come mostrato, possiamo ottenere tutti i numeri dispari senza dover memorizzare l'intero sistema numerico in memoria. Teoricamente, possiamo includere un numero infinito di elementi in memoria limitata.

Gli iteratori rendono il nostro codice molto accattivante.

C'è un modo semplice per creare iteratori in Python. Per ulteriori informazioni, visitare:Generatore yield di Python.