Gli iteratori Python: funzionamento e utilità in breve

Gli iteratori Python sono oggetti nativi con una quantità calcolabile di elementi che implementano il protocollo degli iteratori costituito dalle due funzioni iter() e next().

Cosa sono esattamente gli iteratori Python?

Gli iteratori Python sono innanzitutto una forma speciale di oggetti Python. Si contraddistinguono per essere composti da una serie di elementi conteggiabili. Permettono quindi di contare gli elementi di un iteratore e di iterare su tutti gli elementi di un iteratore Python.

Iteratori e iterabili

Anche se sono strettamente correlati fra loro, gli iteratori e gli iterabili Python non devono essere confusi. I diversi iterabili come la lista Python si contraddistinguono per il metodo iter(), che permette l’iterazione su di essi. La regola generale è che tutto ciò che si trova sul lato destro dell’intestazione del ciclo quando si chiama un ciclo for è un iterabile.

l = [1, 2, 3]
for x in l:
	print(x)

Come potete vedere, chiamando il ciclo for in Python la lista inserita nella variabile “l” compare nella parte destra dell’intestazione del ciclo dopo la parola chiave “in”, pertanto è un iterabile.

Da un iterabile potete derivare un iteratore Python. Di seguito vi riportiamo un esempio di codice per chiarire e mostrare le differenze:

string = "test"
iteratorobject = iter(string)
next(iteratorobject)
iter(iteratorobject)

Per prima cosa nel codice viene inserita una stringa Python con il valore “test” nella variabile chiamata “string”. Anche le stringhe rientrano nella categoria degli iterabili, perché possono iterare su ciascuna lettera della stringa.

Poter iterare sulle stringhe non significa nient’altro che una stringa supporta anche la funzione iter(). Lo vedete anche nella riga di codice successiva, in cui creiamo un iteratore Python per chiamare la funzione iter insieme alla stringa precedentemente creata. Viene restituito un puntatore nelle stringhe, che viene salvato nella variabile chiamata “iteratorobject”. L’iteratore Python si trova quindi in uno stato che possiamo modificare chiamando il metodo next() sull’iteratore Python. Fa in modo che il puntatore sia spostato di un carattere, in modo che “iteratorobject” dopo la chiamata di funzione punti sulla prima lettera della stringa.

La chiamata di funzione di iter(), che come parametro di trasferimento riceve l’iteratore Python, restituisce un riferimento sullo stesso. Gli iteratori Python sono dunque auto-iterabili.

Iteratori e generatori

È importante anche distinguere gli iteratori dai generatori Python. Ciascun generatore Python è anche un iteratore, ma non viceversa. A differenza di un generatore, un iteratore non è formato necessariamente con una funzione che contiene un’espressione yield.

Per cosa e perché si usano gli iteratori Python?

Il campo d’applicazione principale degli iteratori è naturalmente l’iterazione stessa. Il grande vantaggio degli iteratori Python è che funzionano secondo il principio della “valutazione pigra”. In altre parole, ciascun elemento di un iteratore Python può essere elaborato singolarmente, senza dover caricare in memoria l’intera struttura di dati. Questo comportamento risulta particolarmente efficiente in presenza di grandi quantità di dati, perché così in ogni momento si deve caricare un solo elemento.

Come creare iteratori Python

Creare un proprio iteratore Python non è difficile. Basta aggiungere a un oggetto Python le funzioni iter() e next(). Potete così creare molto facilmente un iteratore che restituisce tutti i numeri pari. L’esempio di codice mostra l’esatto funzionamento:

class numeripari:
	def __iter__(self):
		self.x = 0
		return self
	def __next__(self):
		a = self.x
		self.x += 2
		return a
testobject = numeripari()
testiterator = iter(testobject)
print(next(testiterator))
print(next(testiterator))
print(next(testiterator))
print(next(testiterator))

Per realizzare un iteratore Python, prima si crea una classe che qui reca il nome “numeripari”. All’interno della classe si implementano le due funzioni iter() e next() con il comportamento desiderato.

Nel nostro caso, la funzione iter() restituisce solo un riferimento all’iteratore, che deve ospitare la sequenza numerica completa a partire da 0. La logica dell’iterazione, cioè che viene restituito solo un numero su due (quindi solo i numeri pari), si trova all’interno della funzione next().

Una volta definita la classe, si crea un oggetto della classe da inserire nella variabile chiamata “testobject”. L’oggetto diventa un iteratore Python chiamando la funzione iter(), come abbiamo già mostrato nell’esempio di codice precedente. Seguono quattro chiamate di next(), i cui risultati sono restituiti sullo schermo. L’output della sezione di codice sopra si presenta come segue:

0
2
4
6

Limitazione degli iteratori Python

Senza una limitazione, l’iteratore che itera sui numeri pari girerebbe all’infinito, proprio come la quantità di numeri pari. È possibile impedirlo con un’istruzione “StopIteration” abbinata a un’istruzione if-else in Python. Se volete che il vostro iteratore Python restituisca ad esempio tutti i numeri pari fino a 100 compreso, dovete modificare l’esempio di codice sopra come segue:

class numeripari:
	def __iter__(self):
		self.x = 0
		return self
	def __next__(self):
		if self.x <= 100:
			a = self.x
			self.x += 2
			return a	
		else:
			StopIteration
testobject = numeripari()
testiterator = iter(testobject)
print(next(testiterator))
print(next(testiterator))
print(next(testiterator))
print(next(testiterator))

Nel codice, a parte l’implementazione della funzione next(), non è cambiato nulla. Qui è stata integrata un’ulteriore istruzione if-else che verifica se il numero corrente è inferiore o pari a 100. Solo a questa condizione si continua a iterare sulla quantità di numeri pari. Se il numero supera 100, chiamando StopIteration viene generato un errore.