Bentornato, voglio che capiamo come funzionano le cose sotto il cofano, quindi
ti mostrerò due esempi di implementazione del nostro per Loop e quindi di implementazione della nostra funzione di intervallo.
Quindi il primo è il nostro ciclo for.
Quindi dirò speciale per loop.
Sotto il cofano, tutto ciò che fa è ricevere iterabile, e poi diremo Iterator.
Sta per essere uguale a un iterabile ora per noi avere un iterabile, abbiamo quella che chiamiamo una funzione ED.
Che accetta l'iterabile che abbiamo appena passato.
Ora, questa funzione interna ci consentirà di utilizzare la funzione successiva su questo iterabile, quindi resta con me.
Sto per dire mentre è vero.
Voglio.
Provare.
E in questo tri blocco dirà Iterator.
E possiamo eseguire, diciamo, una sorta di operazione qui se vogliamo, o possiamo semplicemente chiamare l'iteratore successivo.
Sai, stampiamo qualcosa qui solo così vediamo qual è l'iteratore.
E infine, voglio che ci fermiamo quando abbiamo l'eccezione di arresto dell'iterazione.
Ricordi quello che abbiamo visto dove non ci sono più elementi nell'iterabile?
E qui possiamo semplicemente rompere.
E assicurati che.
Ho il Colin impostato correttamente, quindi ora se faccio special per Loop e gli do un elenco di uno, due, tre e faccio clic
su Esegui.
Controlla.
Eseguo il ciclo attraverso alcuni oggetti iterabili usando next.
E vedi che questo oggetto esiste nello stesso spazio di memoria, anche se lo percorriamo costantemente
attraverso uno, due, tre.
Quindi questo è il modo in cui i cicli for funzionano sotto il cofano quando facciamo per, diciamo, ngom e poi gli diamo
una lista.
Passerà attraverso tutto, lo trasformerà in un ammirevole e continuerà a funzionare e continuerà a chiamare il prossimo
iteratore su di esso ancora e ancora e ancora fino a quando non finiremo la fine della linea e
poi usciremo dal ciclo.
E come controlliamo i valori effettivi dell'iteratore?
Bene, ricorda, la prossima funzione produrrà qualunque cosa sia la prossima voce.
Quindi se stampo qui.
E clicco su Esegui.
Ne prendo uno, due, tre.
Quindi posso fare solo due volte se volessi fare clic su Esegui.
Ed ecco qua, sono speciali per Loop, ho appena moltiplicato la nostra lista per due.
Questo è tutto, è tutto per i loop, funziona davvero, ma per quanto riguarda gli intervalli?
Possiamo creare la nostra funzione di gamma?
Possiamo assolutamente, e questo è divertente.
Creiamo una classe e questa classe, perché alla fine della giornata, creeremo solo un
oggetto.
Questo ha azioni che possiamo fare, quindi dirò la mia generazione per il mio generatore, e questo imiterà ciò che fa la nostra
gamma.
Quindi avrò una classe e questa classe avrà una funzione INET, avrà un sé, un primo e un ultimo.
Quindi è così che possiamo dire che un intervallo inizia con questo e finisce con questo.
E qui, faremo prima il tipico autodidatta.
Uguale al primo.
E poi l'ultimo autodidatta è uguale all'ultimo, e sto usando una classe qui perché, ricorda, stiamo
solo creando il nostro tipo di dati, la nostra gamma speciale in Python.
Ora abbiamo il nostro semplice generatore e idealmente vogliamo essere in grado di dire che Jen è uguale a e istanziare
il mio Jen per avere, diciamo, da zero a 100, proprio come faremmo con un intervallo.
E idealmente possiamo dire per AI e Jen.
E stampa.
Io perché, voglio dire, è così che possiamo usare i range, giusto?
Quindi come posso farlo funzionare?
Bene, possiamo usare i nostri metodi Dundar, quindi ricorda come abbiamo avuto l'it'a.
Per ottenere un iteratore e utilizzarlo in seguito?
Bene, abbiamo un Dundar definito che è itour e It'a ci permette di creare.
Un airball, quindi nel nostro caso, dirò self, e qui mi limiterò a restituire la classe effettiva in questo modo.
E infine, vogliamo essere in grado di eseguire la funzione successiva sul nostro Djenne perché abbiamo visto fino a che punto il lavoro di
Loop, dobbiamo essere in grado di utilizzare it'a e poi il prossimo Onda.
Quindi, ancora una volta, possiamo usare un metodo Dundar, che viene chiamato convenientemente.
Prossimo.
E questo è integrato in Python, quindi se mi sento.
E tutto ciò che vogliamo fare qui è farle sapere come vogliamo che la prossima volta lavori, mentre io dirò se e abbiamo bisogno di una
sorta di stato o dati per tenere traccia di dove siamo.
Ricorda come funziona il generatore.
Ricorda dove sono.
Bene, possiamo creare un oggetto di classe HB, quindi posso dire che la corrente è uguale a zero.
Quindi questo è il punto in cui siamo attualmente sulla nostra iterazione e diciamo la mia corrente gen dot, purché sia
meno dell'autoultima, che sarà il centinaio qui se è il caso.
Bene, voglio un numero uguale alla mia corrente di punti di generazione, voglio aumentare la mia corrente di punti di generazione di uno perché vogliamo dire,
ehi, ci spostiamo alla posizione successiva e poi torniamo.
Il numero.
Perché è così che funziona il prossimo sotto il cofano, giusto, incrementiamo la nostra posizione attuale di
uno e stiamo semplicemente restituendo il numero, che va bene, nel nostro caso, sarà zero.
E vogliamo andare avanti, andare avanti, andare avanti.
Bene, fino a quando la corrente non sarà più grande dell'ultima, in tal caso, alzeremo semplicemente un'iterazione di
arresto perché non ci sono più cose su cui eseguire l'iterazione.
Vediamo se funziona.
Ho intenzione di eseguire questo.
E guarda un po', funziona tutto.
Sono stato in grado di scorrere il mio generatore e stampare I da zero fino a novantanove.
Ancora una volta, se torniamo al nostro esempio qui.
E so che all'inizio è un po' difficile da guardare.
Ma tutto quello che ho fatto è stato dire, voglio che una funzione IT abbia l'opzione di primo e ultimo.
E vorrò essere in grado di iterare attraverso questo oggetto che creerò, e voglio anche essere in
grado di usare il prossimo ciclo for, se ricordi dal nostro esempio precedente, ha bisogno.
Quindi dirò per l'elemento in Jen, basta scorrerlo, sono in grado di esaminarlo perché ora
è un iteratore e sono in grado di usare il valore successivo su di esso perché ci permetto di eseguire il ciclo e
aumentare costantemente di uno.
Fino a quando non continuiamo a tornare, i numeri, continuiamo a restituire il numero finché il mio genere attuale
non diventa cento e 100 non è inferiore a 100 cento, che è omonimo per ultimo.
Quindi solleverà un'iterazione di arresto.
Il ciclo for ci cattura automaticamente in modo che non si erode e smetta di eseguire il ciclo.
È così che funzionano le cose sotto il cofano con la gamma.
Ora, non c'è bisogno che tu lo sappia, non ti verrà chiesto ogni giorno di implementarlo, ma
volevo mostrarti che è così che funzionano le cose.
Penso che sia importante.