Python Lambdatoiminnot ESIMERKKEJÄ

Mitä lambda-toiminto sisältää Python?

A Lambda-toiminto sisään Python ohjelmointi on anonyymi funktio tai funktio, jolla ei ole nimeä. Se on pieni ja rajoitettu toiminto, jossa on enintään yksi rivi. Aivan kuten normaalilla funktiolla, Lambda-funktiolla voi olla useita argumentteja yhdellä lausekkeella.

In Python, lambda-lausekkeita (tai lambda-muotoja) käytetään anonyymien funktioiden rakentamiseen. Käytä tätä varten lambda avainsana (kuten käytät def normaalien toimintojen määrittelemiseksi). Jokainen määrittämäsi anonyymi funktio Python siinä on 3 olennaista osaa:

• Lambda-avainsana.
• Parametrit (tai sidotut muuttujat) ja
• Toimintorunko.

Lambda-funktiolla voi olla mikä tahansa määrä parametreja, mutta funktion runko voi sisältää vain yksi ilmaisu. Lisäksi lambda kirjoitetaan yhdelle koodiriville, ja se voidaan myös kutsua välittömästi. Näet kaiken tämän toiminnassa tulevissa esimerkeissä.

Syntaksi ja esimerkit

Muodollinen syntaksi lambda-funktion kirjoittamiseen on seuraava:

lambda p1, p2: expression

Tässä p1 ja p2 ovat parametreja, jotka välitetään lambda-funktiolle. Voit lisätä niin monta tai vähän parametreja kuin tarvitset.

Huomaa kuitenkin, ettemme käytä hakasulkeita parametrien ympärillä kuten tavallisten funktioiden kanssa. Viimeinen osa (lauseke) on mikä tahansa kelvollinen Python lauseke, joka toimii funktiolle antamiesi parametrien perusteella.

Esimerkki 1

Nyt kun tiedät lambdasta, kokeillaan sitä esimerkin avulla. Joten, avaa omasi IDLE ja kirjoita seuraava:

adder = lambda x, y: x + y
print (adder (1, 2))

Code Selitys

Tässä määritetään muuttuja, joka säilyttää lambda-funktion palauttaman tuloksen.

1. Lambda-avainsana, jota käytetään määrittelemään anonyymi toiminto.

2. x ja y ovat parametrit, jotka välitämme lambda-funktiolle.

3. Tämä on funktion runko, joka lisää 2 hyväksymäämme parametria. Huomaa, että se on yksittäinen ilmaus. Et voi kirjoittaa useita lauseita lambda-funktion runkoon.

4. Kutsumme funktiota ja tulostamme palautetun arvon.

Esimerkki 2

Tuo oli perusesimerkki lambdan perusteiden ja syntaksin ymmärtämiseksi. Yritetään nyt tulostaa lambda ja katsoa tulos. Avaa jälleen IDLE ja kirjoita seuraava:

#What a lambda returns
string='some kind of a useless lambda'
print(lambda string : print(string))

Tallenna nyt tiedosto ja paina F5 käynnistääksesi ohjelman. Tämä on tulos, jonka sinun pitäisi saada.

lähtö:

<function <lambda> at 0x00000185C3BF81E0>

Mitä tässä tapahtuu? Katsotaanpa koodia ymmärtääksemme paremmin.

Code Selitys:

1. Tässä määrittelemme a:n jono jonka annat parametrina lambdalle.

2. Esittelemme lambdan, joka kutsuu tulostuslausetta ja tulostaa tuloksen.

Mutta miksi ohjelma ei tulosta välittämäämme merkkijonoa? Tämä johtuu siitä, että lambda itse palauttaa funktio-objektin. Tässä esimerkissä lambdaa ei tulosteta nimeltään tulostusfunktiolla, mutta se on yksinkertaisesti palaavat funktio-objekti ja muistipaikka, johon se on tallennettu. Tämä tulostuu konsoliin.

Esimerkki 3

Jos kuitenkin kirjoitat seuraavanlaisen ohjelman:

#What a lambda returns #2
x="some kind of a useless lambda"
(lambda x : print(x))(x)

Ja suorita se painamalla F5-näppäintä, niin näet tällaisen tulosteen.

lähtö:

some kind of a useless lambda

Nyt lambdaa kutsutaan, ja välittämämme merkkijono tulostuu konsoliin. Mutta mikä tuo outo syntaksi on, ja miksi lambdan määritelmä on hakasulkeissa? Ymmärretäänpä se nyt.

Code Selitys:

1. Tässä on sama merkkijono, jonka määrittelimme edellisessä esimerkissä.

2. Tässä osiossa määrittelemme lambdan ja kutsumme sitä välittömästi antamalla merkkijonon argumenttina. Tätä kutsutaan IIFE:ksi, ja opit siitä lisää tämän tutoriaalin seuraavissa osioissa.

Esimerkki 4

Katsotaanpa viimeistä esimerkkiä ymmärtääksemme, miten lambda-funktiot ja säännölliset funktiot suoritetaan. Avaa siis oma tiedostosi. IDLE ja kirjoita uuteen tiedostoon seuraava:

#A REGULAR FUNCTION
def guru( funct, *args ):
funct( *args )
def printer_one( arg ):
return print (arg)
def printer_two( arg ):
print(arg)
#CALL A REGULAR FUNCTION 
guru( printer_one, 'printer 1 REGULAR CALL' )
guru( printer_two, 'printer 2 REGULAR CALL \n' )
#CALL A REGULAR FUNCTION THRU A LAMBDA
guru(lambda: printer_one('printer 1 LAMBDA CALL'))
guru(lambda: printer_two('printer 2 LAMBDA CALL'))

Tallenna nyt tiedosto ja suorita ohjelma painamalla F5-näppäintä. Jos et tehnyt virheitä, tulosteen pitäisi näyttää suunnilleen tältä.

lähtö:

printer 1 REGULAR CALL

printer 2 REGULAR CALL

printer 1 LAMBDA CALL

printer 2 LAMBDA CALL

Code Selitys:

1. Funktio nimeltä guru, joka ottaa toisen funktion ensimmäiseksi parametriksi ja kaikki muut sitä seuraavat argumentit.

2. printer_one on yksinkertainen funktio, joka tulostaa sille annetun parametrin ja palauttaa sen.

3. printer_two on samanlainen kuin printer_one, mutta ilman return-lausetta.

4. Tässä osiossa kutsumme guru-funktiota ja välitämme sille parametreina tulostinfunktiot ja merkkijonon.

5. Tämä on syntaksi neljännen vaiheen (eli guru-funktion kutsumisen) saavuttamiseksi, mutta käyttäen lambda-lausekkeita.

Seuraavassa osiossa opit käyttämään lambda-toimintoja kartta(), vähentää()ja suodattaa() in Python.

Lambdaa käyttämällä Python Takkasydämet

Lambdatoiminnot tarjoavat tyylikkään ja tehokkaan tavan suorittaa toimintoja sisäänrakennetuilla menetelmillä Python. Se on mahdollista, koska lambdat voidaan kutsua välittömästi ja välittää argumenttina näille funktioille.

IIFE sisään Python Lambda

IIFE tarkoittaa välittömästi käynnistänyt toiminnon suorittamisen. Se tarkoittaa, että lambda-funktiota voidaan kutsua heti, kun se on määritelty. Ymmärretään tämä esimerkin avulla; käynnistä oma IDLE ja kirjoita seuraava:

 (lambda x: x + x)(2)

Tässä on tulos ja koodin selitys:

Tämä lambda-toimintojen kyky kutsua välittömästi käyttöön mahdollistaa niiden käytön funktioissa, kuten map() ja reduction(). Se on hyödyllinen, koska et ehkä halua käyttää näitä toimintoja uudelleen.

lambdat suodattimessa()

Suodatintoimintoa käytetään tiettyjen elementtien valitsemiseen elementtisarjasta. Sekvenssi voi olla mikä tahansa iteraattori, kuten luettelot, joukot, monikot jne.

Valittavat elementit perustuvat johonkin ennalta määriteltyyn rajoitteeseen. Se vaatii kaksi parametria:

• Funktio, joka määrittää suodatusrajoituksen
• Sarja (mikä tahansa iteraattori, kuten luettelot, monikot jne.)

Esimerkiksi

sequences = [10,2,8,7,5,4,3,11,0, 1]
filtered_result = filter (lambda x: x > 4, sequences) 
print(list(filtered_result))

Tässä on tuotos:

[10, 8, 7, 5, 11]

Code Selitys:

1. Ensimmäisessä lauseessa määritämme listan, jota kutsutaan sekvensseiksi ja joka sisältää joitain numeroita.

2. Tässä määritetään muuttuja nimeltä filtered_result, joka tallentaa filter()-funktion palauttamat suodatetut arvot.

3. Lambda-funktio, joka suoritetaan jokaisessa luettelon elementissä ja palauttaa tosi, jos se on suurempi kuin 4.

4. Tulosta suodatustoiminnon palauttama tulos.

lambdat kartalla()

map-funktiota käytetään tietyn operaation soveltamiseen jokaiseen sekvenssin elementtiin. Kuten filter(), sekin ottaa kaksi parametria:

1. Funktio, joka määrittää elementeille suoritettavan operaation
2. Yksi tai useampi jakso

Esimerkiksi tässä on ohjelma, joka tulostaa numeroiden neliöt tietyssä luettelossa:

sequences = [10,2,8,7,5,4,3,11,0, 1]
filtered_result = map (lambda x: x*x, sequences) 
print(list(filtered_result))

lähtö:

 [100, 4, 64, 49, 25, 16, 9, 121, 0, 1]

Code Selitys:

1. Tässä määrittelemme lukujonoiksi kutsutun listan, joka sisältää joitakin lukuja.

2. Määrittelemme muuttujan nimeltä filtered_result, joka tallentaa kartoitetut arvot.

3. Lambda-funktio, joka suoritetaan listan jokaiselle alkiolle ja palauttaa kyseisen luvun neliön.

4. Tulosta map-funktion palauttama tulos.

lambdat reduktorissa()

Vähennysfunktiota, kuten map(), käytetään toiminnon soveltamiseen jokaiseen sekvenssin elementtiin. Se eroaa kuitenkin toiminnaltaan kartasta. Nämä ovat vaiheet, joita seuraa vähentää()-funktio tulosteen laskemiseksi:

Vaihe 1) Suorita määritetty toimenpide sekvenssin kahdelle ensimmäiselle elementille.

Vaihe 2) Tallenna tämä tulos.

Vaihe 3) Suorita toimenpide tallennetulla tuloksella ja sekvenssin seuraavalla elementillä.

Vaihe 4) Toista, kunnes elementtejä ei ole enää jäljellä.

Se vaatii myös kaksi parametria:

1. Toiminto, joka määrittää suoritettavan toiminnon
2. Sarja (mikä tahansa iteraattori, kuten luettelot, monikot jne.)

Esimerkiksi tässä on ohjelma, joka palauttaa listan kaikkien elementtien tulon:

from functools import reduce
sequences = [1,2,3,4,5]
product = reduce (lambda x, y: x*y, sequences)
print(product)

Tässä on tuotos:

120

Code Selitys:

1. Tuo reduce-funktio functools-moduulista.

2. Tässä määrittelemme lukujonoiksi kutsutun listan, joka sisältää joitakin lukuja.

3. Esittelemme muuttujan nimeltä product, joka tallentaa pienennetyn arvon.

4. Lambda-funktio, joka suoritetaan listan jokaiselle alkiolle. Se palauttaa kyseisen luvun tulon edellisen tuloksen mukaisesti.

5. Tulosta reduce-funktion palauttama tulos.

Miksi (ja miksi ei) käyttää lambda-funktioita?

Kuten seuraavassa osiossa huomaat, lambdat käsitellään samoin kuin tavallisia tulkkitason toimintoja. Voit tavallaan sanoa, että lambdat tarjoavat kompaktin syntaksin funktioille, jotka palauttavat yhden lausekkeen.

Sinun tulisi kuitenkin tietää, milloin on hyvä käyttää lambda-operaattoria ja milloin sitä kannattaa välttää. Tässä osiossa opit joitakin suunnitteluperiaatteita, joita käyttävät Python kehittäjille lambda-koodeja kirjoitettaessa.

Yksi yleisimmistä lambdan käyttötapauksista on funktionaalinen ohjelmointi, kuten Python tukee ohjelmoinnin paradigmaa (tai tyyliä), joka tunnetaan nimellä toiminnallinen ohjelmointi.

Sen avulla voit antaa funktion parametrina toiselle funktiolle (esimerkiksi map- tai filter-funktioissa). Tällaisissa tapauksissa lambda-lausekkeiden käyttö tarjoaa elegantin tavan luoda kertakäyttöinen funktio ja välittää se parametrina.

Milloin Lambdaa ei saa käyttää?

Älä koskaan kirjoita monimutkaisia ​​lambda-funktioita tuotantoympäristössä. Koodiasi ylläpitävien koodaajien on erittäin vaikea purkaa sen salaus. Jos huomaat tekeväsi monimutkaisia ​​yksilinjaisia ​​lausekkeita, olisi paljon parempi käytäntö määrittää oikea funktio. Paras käytäntö on muistaa, että yksinkertainen koodi on aina parempi kuin monimutkainen koodi.

Lambdat vs. tavalliset toiminnot

Kuten aiemmin todettiin, lambda-funktiot ovat vain funktioita, joihin ei ole sidottu tunnistetta. Yksinkertaisemmin sanottuna ne ovat funktioita, joilla ei ole nimeä (ja jotka ovat siten anonyymejä). Tässä on taulukko, joka havainnollistaa lambdan ja tavallisten funktioiden välistä eroa Python.

lambda x : x + x

def (x) :
return x + x 

Erojen selitys

Ensisijainen ero lambda-funktion ja säännöllisen funktion välillä on, että lambda-funktio arvioi vain yhden lausekkeen ja tuottaa funktioobjektin. Näin ollen voimme nimetä lambda-funktion tuloksen ja käyttää sitä ohjelmassamme kuten teimme edellisessä esimerkissä.

Yllä olevan esimerkin tavallinen funktio näyttäisi tältä:

def adder (x, y):
return x + y 
print (adder (1, 2))

Tässä meidän on määriteltävä a nimi funktiolle, joka Tuotto tulos kun me soittaa sitä. Lambda-funktio ei sisällä return-lausetta, koska sillä on vain yksi lauseke, joka palautetaan aina oletusarvoisesti. Sinun ei tarvitse edes määrittää lambdaa, koska sitä voidaan kutsua välittömästi (katso edellinen osio). Kuten näet, lambda-lausekkeista tulee erityisen tehokkaita, kun käytämme niitä Pythonsisäänrakennetut toiminnot.

Saatat kuitenkin edelleen ihmetellä, kuinka lambdat eroavat funktiosta, joka palauttaa yhden lausekkeen (kuten yllä). Tulkkitasolla ei ole paljon eroa. Se saattaa kuulostaa yllättävältä, mutta mikä tahansa määrittämäsi lambda-toiminto Python tulkki käsittelee sitä normaalina toimintona.

Tavukooditasolla näitä kahta määritelmää käsitellään samalla tavalla Python tulkki. Et voi enää nimetä funktiota lambda koska se on varattu Python, mutta mikä tahansa muu funktion nimi tuottaa saman tavukoodin.

UKK