Va bene, questa enorme lista ha finalmente finito di essere inserita nella memoria.
Ma ricorda i nostri termini chiave, ricordi come ha detto che un elenco è un iterabile?
Cos'era un iterabile?
Bene, un iterabile è qualsiasi oggetto in Python, che siamo in grado di scorrere sotto il
cofano, ha il metodo Dundar ed.
Quindi, quando l'oggetto viene creato, questo itour ci consente di avere un oggetto iterabile che
può essere iterato per iterare qualcosa o l'iterazione è l'atto di prendere un elemento da un iterabile, fare qualcosa su di esso, quindi passare
a quello successivo.
Quando usiamo loop come i cicli for o while, chiamiamo quella iterazione.
È il processo stesso.
E generatori.
Sono in realtà iterabili, cioè tutto ciò che è un generatore è iterabile su cui puoi iterare, ma non tutto
ciò che è.
Iterable è un generatore, ad esempio un intervallo è un generatore.
Quindi sarà sempre iterabile.
Ma un elenco è un iterabile, ma non è un generatore.
Quindi un generatore è un sottoinsieme di un iterabile.
So che sono molte parole.
Spero che tu sia ancora con me.
La differenza tra un generatore e un iterabile regolare è il modo in cui li implementiamo.
Quindi lascia che ti mostri un modo generale per creare un generatore.
Chiariamo questo codice e definiamo il nostro generatore e i generatori di solito sono funzioni proprio come range è una funzione, i
generatori di solito sono creati in questo modo.
Quindi diciamo la funzione del generatore.
E questa funzione generatore avrà un ciclo for che eseguirà un ciclo su un intervallo proprio come
prima.
Ma la differenza qui, riportiamo effettivamente il codice che avevamo in precedenza.
Commenterà questo in modo che possiamo vederlo in termini di differenza.
La funzione generatore sta per.
Crea, diciamo, questi tanti oggetti.
Ma invece di restituire come faremmo in una funzione normale, useremo una parola chiave chiamata
rendimento.
E qui ci accingiamo a produrre l'io così l'oggetto.
Quindi nota la differenza qui.
Ora, se vogliamo come qui, possiamo passare un numero.
Così, ma invece di tornare.
E aggiungendo questo elenco e creando tutti questi dati, useremo ILD.
Ora, cosa rende yield, vedi yield mette in pausa la funzione e torna su di essa quando facciamo qualcosa, che viene
chiamato dopo, qualcosa che tratteremo tra poco?
Quindi Yield dice, ehi, metti in pausa la funzione, cedi e basta.
Io do io e quando mi dirai di andare avanti di nuovo, allora continuerò.
Quindi come possiamo farlo?
Bene, posso dire che per l'elemento nella funzione generatore sto andando.
Stampa l'articolo.
Ora, qui, quello che accadrà è che andremo in loop sulla funzione del generatore e lo daremo alla
funzione del generatore, diciamo mille per ora.
E stamperemo ogni elemento nella funzione generatore perché questo è un iterabile.
Verrà eseguito e andrà in loop e per ogni elemento in questo numero, quindi questa è la gamma che
produrremo perché?
Quindi continuerà a fare loop e loop.
E quando torniamo, quando torniamo indietro.
Eseguiremo questo e il rendimento.
Torna indietro e corre di nuovo.
Lascia che ti mostri cosa intendo commentare, commentare anche questo e fare clic su Ron qui.
Hai visto che quello che abbiamo appena fatto qui è simile a quello qui sotto, ma invece di dover creare quell'elenco in
memoria, ha continuato ad andare avanti uno per uno.
Abbiamo tenuto solo un elemento in memoria.
E l'abbiamo usato come volevamo, nel nostro caso, tutto ciò che abbiamo fatto è stato stampare l'oggetto.
Esploriamo un po' di più questa parola chiave di rendimento.
Cosa fa in realtà?
Diciamo che vogliamo moltiplicare questo per due, proprio come abbiamo fatto qui nel nostro esempio originale
con list, ma ora invece di eseguire il ciclo for, chiamiamo semplicemente la funzione.
E diciamo che G è uguale alla funzione del generatore e gli daremo 100.
Ora, se stampo G e faccio clic su Esegui.
Vedi che ottengo un oggetto generatore.
Ricordo che questo è solo il modo standard in Python in cui possiamo creare una funzione
generatore usando l'intervallo e la parola chiave yield, ma questa parola chiave yield ci dà un po' di potere perché se ritorno qui.
Non otterremo nulla di speciale, infatti, otterremo solo un valore utilizzando
la parola chiave yield.
Quello che siamo in grado di fare è trasformarlo in una funzione generatore che può fare bene, questo posso dire Next
G.
Ora, se stampo Next G qui e faccio clic su Esegui.
ottengo zero.
Ma ecco una parte interessante, se faccio NextG due volte e poi una volta qui e stampato.
ottengo per.
Perché?
Ricorda, la parola chiave eagle mette in pausa la funzione.
Quindi quello che è appena successo qui è che ho eseguito la funzione con cento.
Il primo elemento nell'intervallo 100 era zero.
Destra.
Ora, qui, prima ancora che fossi in grado di eseguire, si dice, ehi, questa è una funzione generatore, ma la prima volta
che la esegui.
Assegna zero volte all'output in modo che la prima volta che eseguiamo questa funzione e clicco su Esegui.
Mi assicurerò di cambiarlo in I.
Questo è solo quest'anno.
Se lo eseguo di nuovo in questo modo, ora abbiamo che voglio che tu lo ripeta e vai a uno.
Quindi uno per due, cos'è quello?
Cosa, una volta per farmi aggiustare la cosa in questo modo?
Assicurati che questo sia io, ci arrivo perché uno per due fa due, se lo eseguo di nuovo e faccio clic su Esegui.
ottengo per.
Vedi yield, come ho detto prima, mette in pausa la funzione e torna su di essa quando viene chiamato il prossimo.
Quindi, se ha una parola chiave yield, diventa un generatore.
Tiene traccia di questo stato, quello che chiamiamo valore, e conserva solo i dati più recenti in memoria,
ad esempio, perché lo ricorda perché sull'ultima riga 14, se stampo Next G.
Si ricorda che prima ero questo.
Bene, per ora, anche se questo pezzo di codice è già stato eseguito, se lo eseguo alla riga 14.
ne prendo sei.
Perché tre per due, beh, fa sei, ricorda, perché si moltiplica per due, quindi lascia che ti chieda questo.
Se diciamo che ne faccio solo un intervallo qui, e sai una cosa?
Rimuoviamo semplicemente moltiplicare per due.
Se lo faccio e corro ancora, allora bene, più di una volta, cosa accadrà se clicco su Esegui qui?
Ottengo un'iterazione di arresto, vedi che il prossimo può essere chiamato tutte le volte che vogliamo, tutte le volte
fino alla scadenza di questo intervallo e quando superiamo il numero di elementi nell'intervallo.
Bene, otteniamo un'iterazione di arresto, ehm.
Per farci sapere che, ehi, non puoi più chiamare il prossimo.
Abbiamo raggiunto la fine della linea e quando usiamo per i loop con intervalli, in realtà rileva questo sotto il cofano
per te.
Quindi siamo in grado di eseguire una funzione come questa in cui usiamo range, anche se range è un generatore, perché
il ciclo for dice automaticamente, ehi, smetterò di eseguire il ciclo non appena incontro questa iterazione di arresto, ma
è nascosto a noi come utenti.
Ora, questo concetto di generatori è piuttosto difficile da capire, soprattutto all'inizio.
Quindi potresti doverlo guardare un paio di volte.
Ma nei prossimi due video, voglio convincerti di quanto siano potenti.
Vedrò nel prossimo da.