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

Consiglio Python è un eccellente linguaggio di programmazione per i progetti web. [Deploy Now](https://www.ionos.it/hosting/deploy-now "Deploy Now di IONOS"), grazie alla compilazione e alla distribuzione automatica tramite GitHub, vi fornisce supporto per i vostri progetti internet, così avete sempre tutto sotto controllo.

### 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](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/liste-in-python/ "Liste in 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.

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

Come potete vedere, chiamando il [ciclo for in Python](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/ciclo-for-su-python/ "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:

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

Per prima cosa nel codice viene inserita una [stringa Python](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/stringhe-in-python/ "Stringhe in 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](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/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.

Consiglio Gli iteratori Python sono un costrutto di programma piuttosto avanzato, non trattato da tutti i [tutorial di Python](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/tutorial-python/ "Tutorial di Python"). Se volete conoscere aspetti avanzati di Python, vi consigliamo gli articoli seguenti:

- [Decoratori Python](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/decoratori-python/)
- [Property in Python](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/property-in-python/)
- [RegEx in Python](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/regex-in-python/)

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

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

```none
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](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/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:

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


This is a markdown version of: [https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/iteratori-python/](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/iteratori-python/) for AI/LLM consumption.