Istruttore: Ciao e bentornato.
In questo video parliamo
di classi generatore e iteratori.
Qui vi mostrerò una classe che implementa il generatore
di numeri 100 che abbiamo realizzato nell'ultimo video.
Quindi lo chiamerò FirstHundredGenerator.
In questo modo e poi definiremo un metodo init.
Che inizierà con un numero pari a zero e
poi definirà un metodo successivo, underscore,
underscore, next.
Quando si definisce un metodo next in una classe, qualsiasi
oggetto può essere chiamato next del mio oggetto, in questo modo.
Quindi questo è di nuovo un metodo dunder
che consente di chiamare next.
Inoltre, dice a Python qualcosa di molto importante.
Lo vedremo tra poco.
Quindi, se vogliamo generare 100 numeri, tutto ciò che
dobbiamo fare è ottenere self. restituisce il numero
e lo incrementa di uno.
Quindi, se self. Il numero è inferiore a 100. A
proposito, non useremo la parola chiave yield,
perché non è necessario in un generatore di classi.
Scusa, in una di queste cose. (ride) Non dirò nulla
che possa essere interpretato
come sbagliato.
Solo per non confondervi le idee.
Se il numero è inferiore a 100, lo inseriamo
in una variabile, incrementiamo
il numero di uno e restituiamo il numero corrente,
che era il valore precedente, quindi zero.
Incrementiamo l'autostima. di uno, restituiamo zero.
Ok.
Ora, se vogliamo smettere
di restituire numeri, è importante
per la classe, come
in questo caso, non stiamo utilizzando un ciclo per
fermarci quando raggiungiamo 100.
Pertanto, quando si raggiunge il valore 100, si deve generare
un errore speciale, chiamato Stop Iteration.
L'errore Stop Iteration indica a Python
che abbiamo raggiunto la fine di questo generatore.
Sto dicendo generatore e sto indietreggiando leggermente, ehm, qui.
Perché si tratta essenzialmente di un generatore: si
parte da zero, poi
si decide se si vuole restituire un nuovo numero, si ottiene quel
numero, lo si restituisce e poi il
programma si ferma.
Ma il vostro oggetto rimane, e si ricorda di sé. numero.
Quindi, se abbiamo il mio gen, e questo è il nostro primo centinaio
di generatori.
Il mio gen. è ovviamente pari
a zero all'inizio.
Giusto?
Ve lo dimostriamo.
Il mio gen il numero zero all'inizio.
Se fai la mia gen. successivo, in questo modo,
e poi stampare il
mio gen. numero di nuovo, si
ottiene uno.
Ha senso, no?
Perché il metodo successivo controlla se il numero
è inferiore a 100 e lo incrementa
di uno.
Quindi tutto questo ha senso.
Ora, per far sì che si comporti come
un generatore, basta dire next of my gen, in questo
modo.
Poi possiamo eseguire di nuovo questa operazione e viene fuori la stessa cosa.
Naturalmente, next of my gen
restituisce il numero che aveva prima di essere incrementato.
Quindi, invece di stampare il mio gen. possiamo stampare il numero
successivo del mio gen e anche qui possiamo stampare il
numero successivo del mio gen e otterremo lo
stesso risultato, zero e uno.
La prima volta che chiamiamo next, otteniamo il valore corrente,
che è zero, ma abbiamo incrementato self. numero di uno.
La volta successiva che chiamiamo
next, incrementiamo di nuovo il numero di uno, ma
restituiamo il valore precedente, che è uno.
Quindi ora si comporta esattamente come un generatore,
e in effetti si tratta di un generatore.
Non si tratta di memorizzare tutti i valori fino a 100 in un elenco.
Ve li dà uno per uno.
Li genera quando si chiama la funzione successiva.
Scusate, il metodo successivo.
A proposito, dunder next è una novità in Python 3.
Quindi, se si utilizza
Python 2, si dovrà definire next senza il trattino basso.
Questo solo per Python 2.
Se si utilizza Python 3, utilizzare dunder next.
Ok, tutti gli
oggetti che hanno questo metodo dunder next sono chiamati
iteratori.
Tutti i generatori, come questo, sono iteratori,
ma non il contrario.
Quindi si possono avere iteratori che non generano numeri.
Per esempio, se si modifica il generatore
di primi numeri per restituire parte di una lista,
come iteratore di primi cento, non generatore,
si può avere un metodo init qui, che dice
self. I numeri sono: uno,
due, tre, quattro, cinque.
Ovviamente non è, non è il primo
centinaio, è il primo cinque iteratore, self I è zero.
Questo è l'indice che si inizierà a restituire.
Zero, e i numeri che restituiamo
vanno da uno a cinque.
Anche in questo caso il metodo successivo dirà solo se I è inferiore
a len di sé. numeri, restituire
self. numeri I.
Giusto?
In caso contrario, interrompere l'iterazione.
Mi spiace, non si vede bene, ma
ci siamo.
Quindi tutto quello che stiamo facendo qui è che non stiamo generando nulla.
Stiamo dicendo che se I è minore
di, tra l'altro dobbiamo, ovviamente, farlo, I più
uguale a uno e restituire
la corrente.
Dobbiamo incrementare di uno, e naturalmente
dobbiamo incrementare I di uno.
Anche in questo caso, non stiamo generando nuovi numeri.
Stiamo tenendo traccia di I, l'indice in cui ci troviamo attualmente,
e questo deve essere fatto in qualche modo per, questo dovrebbe
essere autonomo. A proposito.
Si può notare che non ho preparato questo esempio, ma volevo solo
mostrarvi rapidamente che non
tutti i generatori, né tutti gli iteratori, devono
essere generatori.
In questo caso, non si generano i numeri,
ma li si restituisce da un elenco.
Quindi, solo un rapido esempio.
Lo troverete nel codice di esempio della sezione,
se mi ricordo di aggiungerlo.
Quindi, qui, ciò che facciamo quando definiamo il metodo next, è
definire un iteratore,
qualcosa che si può esaminare uno per uno,
chiamando la funzione next.
Non deve necessariamente generare tutti i suoi numeri, ma può farlo,
ma ancora una volta può anche restituirli da un elenco, da un invio
o da qualsiasi altro luogo.
Quindi, in Python è importante.
Gli iteratori sono quegli oggetti che
hanno un metodo dunder next.
È possibile chiamare il prossimo su di loro.
Abbiamo un iteratore, ma
non possiamo
fare per I nel mio
gen, nel mio
gen.
Non è possibile farlo.
Lasciate che ve lo dica subito.
Se lo si esegue, si ottiene un errore che dice: "L'oggetto
generatore 100 non è iterabile", ma
io ho appena detto che è un iteratore, e lo è.
Il significato di un iteratore è che si
può chiamare la funzione next su
di esso e questo darà il valore successivo.
Ma un iteratore e un iterabile sono cose diverse.
È possibile iterare su un iterabile e l'iteratore
viene utilizzato per ottenere il valore successivo da una sequenza
o da valori generati.
Quindi abbiamo un iteratore,
non un iterabile.
Nel prossimo video impareremo
a creare un'iterabile,
in modo da poter fare un ciclo
su di essa o fare cose come la somma dei miei gen,
o qualsiasi altra cosa vogliate fare.
Elenco della mia gen.
Queste cose qui hanno bisogno di un iterabile, non di un iteratore.
Lo faremo nel prossimo video.
Ci vediamo lì.