Jose: Ciao, bentornato.
In questa lezione parliamo di filtri.
Ora che abbiamo tolto di mezzo i
generatori, gli iteratori e gli iterabili, possiamo
iniziare con alcune divertenti funzioni integrate.
La funzione filtro è una funzione incorporata
in Python che può essere richiamata da qualsiasi file o programma,
questo è il significato di incorporazione,
e richiede due argomenti.
Il primo argomento della funzione
filtro è un'altra funzione
e anch'essa accetta un iterabile.
Quindi funziona così:
troviamo una lista
di amici come Rolf, Jose, Randy, Anna e Mary e so di averne
perso uno.
Ora utilizzeremo la
funzione di filtro per ottenere solo gli amici che
iniziano con la lettera R.
Quindi, iniziamo con R, che sarà
filtro, questa è la funzione, che prende
come primo argomento una
funzione, arg 1, che restituisce vero o falso.
Quindi il primo argomento di questa funzione di filtro
deve essere un'altra funzione che restituisce true o false
a seconda di ciò che vogliamo filtrare.
Quindi definisco una funzione qui sopra.
Inizia con R.
Restituzione del punto amico che inizia con R.
Il punto amico che inizia con la R sarà vero
se questo argomento inizia con la R, sarà falso
se non lo inizia.
Quindi, il primo parametro della funzione filtro
deve essere questa funzione
che inizia con R e il secondo parametro
deve essere un iterabile, sappiamo che cosa sono,
quindi friends è un iterabile perché possiamo
iterare su di esso, è una lista e questo
è tutto, questo è l'aspetto della funzione filtro e ciò
che fa è mantenere solo gli elementi per i quali questo
restituisce true.
Quindi, la prima volta che la funzione
filtro viene eseguita, ci darà Rolf, Rolf che va agli
amici, l'amico che inizia con R sarà
vero, quindi Rolf verrà mantenuto
dalla funzione filtro.
Poi si ripeterà, e questa volta con Jose, Jose
inizia con R è falso, quindi il filtro
lo rimuoverà e lo ignorerà e così
via per ogni amico qui.
La cosa interessante è che filter
restituisce effettivamente un
generatore, in modo da
essere un po' più efficiente,
invece di copiare la lista con i soli elementi
che si vogliono mantenere, bisogna chiamare l'elemento next, start with R, in
modo da ottenere il prossimo elemento disponibile, che in questo caso
sarà Rolf.
Se lo si fa ancora e ancora, si otterrà Randy e alla
fine si otterrà
l'eccezione di stop all'iterazione di cui abbiamo parlato
prima, che segnala
la fine di una sequenza o di un generatore
o di un iteratore quando
si raggiunge la fine, ok?
Quando si esegue un ciclo for,
ciò che il ciclo for fa in background
è chiamare next e non appena si raggiunge l'iterazione
di stop, il ciclo for si ferma e non
dà questo errore perché l'iterazione
di stop è stata progettata per significare questo e il ciclo for è un costrutto
che usa l'iterazione di stop per sapere quando
ha raggiunto la fine, ok?
Naturalmente, se si esegue l'elenco di inizio con R, si otterrà un elenco
di tutti gli elementi del generatore,
si passerà in rassegna
ogni elemento e lo si inserirà in un nuovo elenco.
Ora, se lo fate di nuovo, cosa
pensate che succederà?
Si otterrà una lista vuota, l'oggetto
lista qui non solleva un'iterazione di stop, ma vede che l'iterazione
di stop è stata sollevata e non dà nulla,
dà solo una lista vuota
ora, perché il generatore è già
stato usato e ricorda di aver raggiunto
la fine, quindi non può dare nient'altro.
Ecco perché spiego i generatori, gli iteratori
e gli iterabili prima di passare a questa funzione di filtro, ok?
Naturalmente, invece di definire una funzione che
prende un parametro
e restituisce se il parametro inizia
con R, potremmo usare una lamda.
Questa funzione lamda è esattamente
la stessa cosa: prende un parametro
e dopo i due punti definiamo ciò che restituisce
e ciò che restituisce è il punto x che inizia con R, quindi
è vero o falso a seconda che
x inizi o meno con R.
Se vi fa sentire meglio, potete chiamare
il parametro amico e in questo modo forse è un
po' più chiaro che questa
funzione opererà su questi amici
qui, quindi non avete più bisogno
di quella funzione lì.
Inoltre, non abbiamo più bisogno di questo
commento perché ora sappiamo cosa significa.
Questa funzione di filtro qui
è identica a questa
espressione del generatore, questa
comprensione del generatore
che dice: F per F in amici, se F inizia con R.
Quindi questi due sono identici, ok?
Qui abbiamo un'espressione generatore,
una comprensione generatore che inserisce
ogni amico in un nuovo generatore, ma solo se F inizia con R, quindi
questi due sono uguali, ok?
Quale dei due è più veloce?
Quale dei due ha prestazioni migliori?
In questo caso, almeno, la comprensione del
generatore funziona meglio.
Il motivo è che si deve
creare questa funzione lamda in questo filtro e non si
deve creare una funzione lamda
nell'espressione del generatore.
Se la funzione è già definita in
un altro punto del programma,
la funzione filtro può funzionare meglio
e in alcuni casi la funzione
filtro può essere più leggibile, anche se in molti altri
casi la comprensione
della lista è più leggibile.
Quindi dipende da voi quale
usare, io di solito scelgo le comprensioni, che
sono anche un po' più pitoniche.
A proposito, per completezza, in
modo che sia chiaro cosa sta succedendo, questi
due filtri e questa comprensione del generatore
sono identici a quest'altra funzione
che sto per definire.
È un'altra funzione
di filtro, molto
simile a questa, che accetta una
funzione e un iterabile e itera sull'iterabile,
controlla se la funzione restituisce
true o no e restituisce I alla fine
se la funzione è true.
Immaginiamo di chiamare qui il mio filtro personalizzato.
Lamda friend inizia con R è questa funzione,
l'iterabile è il nostro elenco di amici.
Eseguiamo un'iterazione sull'iterabile e otteniamo il primo elemento
che è Rolf.
Se la func I cioè l'amico inizia con R è
vera, e lo è, allora otterremo
I, cioè Rolf.
Quando chiamiamo next in questa funzione,
otterremo Rolf e ci fermeremo
subito dopo la riga nove.
Quando chiamiamo di
nuovo next, torniamo all'inizio,
cioè a I, controlliamo se la funzione
corrisponde a Jose,
la stringa Jose, quindi non restituiamo
nulla, non ci fermiamo, passiamo al prossimo
elemento del ciclo, controlliamo se Randy
inizia con R e lo fa, quindi restituiamo
Randy e ci fermiamo.
La prossima volta che chiamiamo next, andiamo
qui ed è Anna, è false, quindi non cediamo, continuiamo, I è Mary,
è false, quindi non cediamo, continuiamo, raggiungiamo
la fine, questa è un'iterazione di stop, quindi raggiungiamo
la fine dell'oggetto generatore e questa è un'altra
iterazione di stop che ci dice che abbiamo raggiunto
la fine.
Quindi, se tutto questo ha senso,
stiamo iniziando a entrare un po' di più in
quello che Python è, cioè la gestione dei dati e l'invio
dei dati da un posto all'altro e il rendimento è estremamente
potente perché permette
di fermarsi e generare i valori uno per uno senza
doverli memorizzare tutti allo stesso
tempo.
Comunque questo è tutto per
questo video, volevo solo mostrarvi questa funzione
di filtro e il suo utilizzo.
La funzione di filtro è presente anche
in molti altri linguaggi di programmazione,
quindi la vedrete ovunque man mano che svilupperete
le vostre capacità di programmazione e continuerete il vostro
percorso di programmazione.
Quindi, sì, è tutto e ci vediamo
nel prossimo video.