Python Lambda funktsioonid NÄIDETEGA

Milles on lambda funktsioon Python?

A Lambda funktsioon sees Python programmeerimine on anonüümne funktsioon või funktsioon, millel pole nime. See on väike ja piiratud funktsioon, millel pole rohkem kui üks rida. Nagu tavafunktsioonil, võib ka Lambda-funktsioonil olla ühe avaldisega mitu argumenti.

In Python, kasutatakse anonüümsete funktsioonide koostamiseks lambda-avaldisi (või lambda-vorme). Selleks kasutate lambda märksõna (nagu te kasutate def normaalsete funktsioonide määratlemiseks). Iga anonüümne funktsioon, mille määrate Python sisaldab 3 olulist osa:

• Lambda märksõna.
• Parameetrid (või seotud muutujad) ja
• Funktsiooni keha.

Lambda-funktsioonil võib olla suvaline arv parameetreid, kuid funktsiooni keha võib sisaldada ainult üks väljendus. Veelgi enam, lambda on kirjutatud ühele koodireale ja seda saab ka kohe välja kutsuda. Seda kõike näete eelseisvates näidetes.

Süntaks ja näited

Lambda-funktsiooni kirjutamise formaalne süntaks on järgmine:

lambda p1, p2: expression

Siin on p1 ja p2 parameetrid, mis edastatakse lambda funktsioonile. Saate lisada nii palju või vähe parameetreid, kui vaja.

Siiski pane tähele, et me ei kasuta parameetrite ümber nurksulge nagu tavaliste funktsioonide puhul. Viimane osa (avaldis) on mis tahes kehtiv Python avaldis, mis opereerib funktsioonile antud parameetritega.

Näiteks 1

Nüüd, kui teate lambdade kohta, proovime seda näitega. Niisiis, avage oma IDLE ja sisestage järgmine tekst:

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

Code Selgitus

Siin määratleme muutuja, mis säilitab lambda-funktsiooni tagastatud tulemuse.

1. Lambda märksõna, mida kasutatakse anonüümse funktsiooni määratlemiseks.

2. x ja y on parameetrid, mille edastame lambda-funktsioonile.

3. See on funktsiooni põhiosa, mis lisab kaks edastatud parameetrit. Pange tähele, et see on üks väljend. Lambda-funktsiooni kehasse ei saa kirjutada mitut väidet.

4. Kutsume funktsiooni ja trükime tagastatud väärtuse.

Näiteks 2

See oli lihtne näide lambda põhitõdede ja süntaksi mõistmiseks. Proovime nüüd lambda välja printida ja tulemust vaadata. Avage uuesti oma IDLE ja sisestage järgmine tekst:

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

Nüüd salvestage fail ja vajutage programmi käivitamiseks klahvi F5. See on väljund, mida peaksite saama.

Väljund:

<function <lambda> at 0x00000185C3BF81E0>

Mis siin toimub? Vaatame koodi, et paremini aru saada.

Code Selgitus:

1. Siin defineerime a nöör mille annate parameetrina lambdale edasi.

2. Deklareerime lambda funktsiooni, mis kutsub välja print-lause ja prindib tulemuse.

Aga miks programm ei prindi edastatud stringi? See on sellepärast, et lambda ise tagastab funktsiooniobjekti. Selles näites lambdat ei kuvata. kutsutud printimisfunktsiooni abil, aga see on lihtsalt tagasi funktsiooniobjekt ja mälu asukoht, kuhu see salvestatakse. See prinditakse konsoolile.

Näiteks 3

Kui aga kirjutate sellise programmi:

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

Ja käivitage see F5-ga, näete sellist väljundit.

Väljund:

some kind of a useless lambda

Nüüd kutsutakse välja lambda ja konsool prindib edastatud stringi. Aga mis see imelik süntaks on ja miks on lambda definitsioon sulgudes? Saame sellest nüüd aru.

Code Selgitus:

1. Siin on sama string, mille me eelmises näites defineerisime.

2. Selles osas defineerime lambda ja kutsume selle kohe välja, edastades stringi argumendina. Seda nimetatakse IIFE-ks ja selle kohta saate lisateavet selle õpetuse järgmistes osades.

Näiteks 4

Vaatame viimast näidet, et mõista, kuidas lambda- ja regulaarfunktsioone täidetakse. Seega avage oma IDLE ja uude faili tippige järgmine tekst:

#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'))

Nüüd salvesta fail ja vajuta programmi käivitamiseks F5. Kui sa vigu ei teinud, peaks väljund olema umbes selline.

Väljund:

printer 1 REGULAR CALL

printer 2 REGULAR CALL

printer 1 LAMBDA CALL

printer 2 LAMBDA CALL

Code Selgitus:

1. Funktsioon nimega guru, mis võtab esimese parameetrina teise funktsiooni ja kõik sellele järgnevad argumendid.

2. printer_one on lihtne funktsioon, mis prindib talle edastatud parameetri ja tagastab selle.

3. printer_two on sarnane printer_one'iga, aga ilma tagastuslauseta.

4. Selles osas kutsume välja guru funktsiooni ja edastame parameetritena printeri funktsioonid ja stringi.

5. See on süntaks neljanda sammu (st guru funktsiooni kutsumise) saavutamiseks, aga lambda-operaatorit kasutades.

Järgmises jaotises saate teada, kuidas lambda-funktsioone kasutada kaart (), vähenda ()ja filter() in Python.

Lambdade kasutamine koos Python sisseehitatud

Lambda funktsioonid pakuvad elegantset ja võimsat viisi toimingute tegemiseks, kasutades sisseehitatud meetodeid Python. See on võimalik, kuna lambdasid saab kohe kutsuda ja nendele funktsioonidele argumendina edasi anda.

IIFE sisse Python Lambda

IIFE tähistab kutsus kohe välja funktsiooni täitmise. See tähendab, et lambda funktsiooni saab kutsuda kohe, kui see on defineeritud. Vaatame seda näite abil; käivita oma IDLE ja sisestage järgmine tekst:

 (lambda x: x + x)(2)

Siin on väljundi ja koodi selgitus:

See lambdade viivitamatu käivitamise võimalus võimaldab teil neid kasutada sellistes funktsioonides nagu map() ja reduktor(). See on kasulik, kuna te ei pruugi soovida neid funktsioone enam kasutada.

lambdad filtris ()

Filtrifunktsiooni kasutatakse teatud elementide valimiseks elementide jadast. Jada võib olla mis tahes iteraator, näiteks loendid, komplektid, korteežid jne.

Valitavad elemendid põhinevad mingil eelnevalt määratletud piirangul. See võtab kaks parameetrit:

• Funktsioon, mis määrab filtreerimispiirangu
• Jada (mis tahes iteraator, näiteks loendid, kordused jne)

Näiteks

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

Siin on väljund:

[10, 8, 7, 5, 11]

Code Selgitus:

1. Esimeses lauses määratleme loendi, mida nimetatakse jadadeks ja mis sisaldab mõningaid numbreid.

2. Siin deklareerime muutuja nimega filtered_result, mis salvestab funktsiooni filter() poolt tagastatud filtreeritud väärtused.

3. Lambda-funktsioon, mis töötab loendi igal elemendil ja tagastab tõene, kui see on suurem kui 4.

4. Printige filtrifunktsiooni tagastatud tulemus.

lambdad kaardil()

Funktsiooni map kasutatakse kindla operatsiooni rakendamiseks igale järjestuse elemendile. Nagu filter(), võtab see samuti kaks parameetrit:

1. Funktsioon, mis määratleb elementidega tehtava toimingu
2. Üks või mitu järjestust

Näiteks siin on programm, mis prindib antud loendis arvude ruudud:

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

Väljund:

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

Code Selgitus:

1. Siin defineerime loendi, mida nimetatakse järjestusteks ja mis sisaldab mõningaid numbreid.

2. Deklareerime muutuja nimega filtered_result, mis salvestab kaardistatud väärtused.

3. Lambda-funktsioon, mis töötab loendi iga elemendi peal ja tagastab selle arvu ruudu.

4. Väljasta map-funktsiooni tagastatud tulemus.

lambdad reduktsioonis ()

Vähendamisfunktsiooni, nagu map(), kasutatakse toimingu rakendamiseks jada igale elemendile. Oma töö poolest erineb see aga kaardist. Need on sammud, millele järgneb väljundi arvutamiseks funktsioon vähendamise ().

Step 1) Tehke määratletud toiming jada kahe esimese elemendiga.

Step 2) Salvesta see tulemus.

Step 3) Tehke toiming salvestatud tulemuse ja jada järgmise elemendiga.

Step 4) Korrake, kuni enam elemente pole järele jäänud.

Samuti on vaja kahte parameetrit:

1. Funktsioon, mis määrab sooritatava toimingu
2. Jada (mis tahes iteraator, näiteks loendid, kordused jne)

Näiteks siin on programm, mis tagastab loendi kõigi elementide korrutise:

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

Siin on väljund:

120

Code Selgitus:

1. Impordi `reduce` `functools` moodulist.

2. Siin defineerime loendi, mida nimetatakse järjestusteks ja mis sisaldab mõningaid numbreid.

3. Deklareerime muutuja nimega korrutis, mis salvestab vähendatud väärtuse.

4. Lambda-funktsioon, mis töötab loendi iga elemendi peal. See tagastab selle arvu korrutise vastavalt eelmisele tulemusele.

5. Väljasta funktsiooni reduce tagastatud tulemus.

Miks (ja miks mitte) kasutada lambda funktsioone?

Nagu näete järgmisest jaotisest, käsitletakse lambdasid tõlgendaja tasemel samamoodi kui tavalisi funktsioone. Mõnes mõttes võib öelda, et lambdad pakuvad kompaktset süntaksit funktsioonide kirjutamiseks, mis tagastavad ühe avaldise.

Siiski peaksite teadma, millal on hea mõte kasutada lambda-operaatoreid ja millal neid vältida. Selles osas saate teada mõningaid disainipõhimõtteid, mida kasutavad Python arendajad lambdade kirjutamisel.

Üks levinumaid lambda-avaldiste kasutusjuhtumeid on funktsionaalprogrammeerimine, kuna Python toetab programmeerimise paradigmat (või stiili), mida nimetatakse funktsionaalseks programmeerimiseks.

See võimaldab teil anda funktsiooni parameetrina teisele funktsioonile (näiteks funktsioonides map, filter jne). Sellistel juhtudel pakub lambda kasutamine elegantset viisi ühekordse funktsiooni loomiseks ja selle parameetrina edastamiseks.

Millal ei tohiks Lambdat kasutada?

Tootmiskeskkonnas ei tohiks kunagi kirjutada keerulisi lambda funktsioone. Teie koodi hooldavatel kodeerijatel on seda väga raske dekrüpteerida. Kui leiate end koostamas keerulisi ühejoonelisi väljendeid, oleks õige funktsiooni määratlemine palju parem tava. Parima tavana peate meeles pidama, et lihtne kood on alati parem kui keeruline kood.

Lambdad vs tavafunktsioonid

Nagu varem mainitud, on lambda-funktsioonid lihtsalt funktsioonid, millel pole identifikaatorit. Lihtsamalt öeldes on need nimetud funktsioonid (seega anonüümsed). Siin on tabel, mis illustreerib lambda-funktsioonide ja tavaliste funktsioonide erinevust. Python.

lambda x : x + x

def (x) :
return x + x 

Erinevuste selgitus

Peamine erinevus lambda- ja tavafunktsiooni vahel on see, et lambda-funktsioon hindab ainult ühte avaldist ja annab funktsiooniobjekti. Sellest tulenevalt saame lambda-funktsiooni tulemusele nime anda ja seda oma programmis kasutada nagu eelmises näites.

Ülaltoodud näite tavafunktsioon näeb välja selline:

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

Siin peame defineerima a nimi funktsiooni jaoks, mis Tulu tulemus, kui me helistama seda. Lambda funktsioon ei sisalda tagastuslauset, kuna sellel on ainult üks avaldis, mis vaikimisi alati tagastatakse. Te ei pea isegi lambdat määrama, kuna seda saab kohe välja kutsuda (vt eelmist jaotist). Nagu näete, muutuvad lambdad eriti võimsaks, kui me neid koos kasutame Pythonsisseehitatud funktsioonid.

Siiski võite siiski mõelda, kuidas lambdad erinevad funktsioonist, mis tagastab ühe avaldise (nagu ülaltoodud). Tõlgi tasandil pole suurt vahet. See võib kõlada üllatavalt, kuid mis tahes lambda-funktsioon, milles te määratlete Python tõlk käsitleb seda tavalise funktsioonina.

Baitkoodi tasandil käsitleb kood kahte definitsiooni ühtemoodi. Python interpreter. Nüüd ei saa funktsioonile nime anda lambda sest see on reserveeritud Python, aga iga teine ​​funktsiooninimi annab sama baitkoodi.

KKK