Python Lambda toimib NÄIDETEGA

Lang L: none (table-of-contents):

Anonim

Mis on Pythonis Lambda funktsioon?

Lambda Funktsioon Python programmeerimine on anonüümne funktsioon või funktsioon, millel ei ole nime. See on väike ja piiratud funktsioon, millel on mitte rohkem kui üks rida. Nii nagu tavalisel funktsioonil, võib ka Lambda funktsioonil olla ühe avaldisega mitu argumenti.

Pythonis kasutatakse anonüümsete funktsioonide koostamiseks lambda väljendeid (või lambda vorme). Selleks, siis kasutage lambda märksõna (nagu sa kasutad def määratleda normaalseid funktsioone). Igal Pythonis määratletud anonüümsel funktsioonil on 3 olulist osa:

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

Funktsioonil lambda võib olla mis tahes arv parameetreid, kuid funktsiooni keha võib sisaldada ainult ühte avaldist. Veelgi enam, lambda on kirjutatud ühte koodirida ja seda saab ka kohe käivitada. Seda kõike näete tulevastes näidetes toimimas.

Selles Lambda Pythonis õpetuses saate teada:

  • Süntaks ja näited
  • Lambda kasutamine Pythoni sisseehitatud seadmetega
  • lambdad filtris ()
  • lambdas kaardil ()
  • lambdas redutseerimisel ()
  • Miks (ja miks mitte) kasutada lambda funktsioone?
  • Lambdas vs tavalised funktsioonid

Süntaks ja näited

Ametlik süntaks lambda funktsiooni kirjutamiseks 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.

Pange tähele, et me ei kasuta parameetrite ümber sulgusid nagu tavaliste funktsioonide korral. Viimane osa (avaldis) on mis tahes kehtiv pythoni avaldis, mis töötab funktsioonile antud parameetritega.

Näide 1

Nüüd, kui olete lambdadest teadlik, proovime seda ühe näitega. Niisiis, avage oma IDLE ja tippige järgmine:

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

Siin on väljund:

3

Koodi selgitus

Siin määratleme muutuja, mis hoiab lambda funktsiooni tagastatud tulemust.

1. Anonüümse funktsiooni määratlemiseks kasutatav märksõna lambda.

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

3. See on funktsiooni keha, mis liidab 2 meie poolt läbitud parameetrit. Pange tähele, et see on üks väljend. Lambda funktsiooni kehasse ei saa kirjutada mitu lauset.

4. Kutsume funktsiooni ja printime tagastatud väärtuse.

Näide 2

See oli peamine näide lambda põhialuste ja süntaksite mõistmiseks. Proovime nüüd lambda välja printida ja tulemust näha. Jällegi avage oma IDLE ja tippige järgmine:

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

Nüüd salvestage fail ja vajutage programmi käivitamiseks F5. Selle väljundi peaksite saama.

Väljund:

 at 0x00000185C3BF81E0>

Mis siin toimub? Edasiseks mõistmiseks vaatame koodi.

Koodi selgitus

  1. Siin määratleme stringi, mille edastate lambda parameetrina.
  2. Kuulutame välja lambda, mis kutsub väljatrüki ja prindib tulemuse.

Kuid miks programm ei trüki meie edastatud stringi? Seda seetõttu, et lambda tagastab ise funktsiooniobjekti. Sel näiteks lambda ei oleks kutsutud poolt print funktsiooni vaid lihtsalt naasevad funktsiooni objekti ja mälu asukohta, kus see on salvestatud. See trükitakse konsoolis.

Näide 3

Kuid kui kirjutate sellise programmi:

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

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

Väljund:

some kind of a useless lambda

Nüüd helistatakse lambdale ja meie läbitav string trükitakse konsooli. Kuid mis on see imelik süntaks ja miks on lambda määratlus sulgudes? Saame sellest nüüd aru.

Koodi selgitus

  1. Siin on sama string, mille määratlesime eelmises näites.
  2. Selles osas määratleme lambda ja nimetame seda kohe, edastades stringi argumendina. Seda nimetatakse IIFE-ks ja selle kohta saate lisateavet selle õpetuse järgmistest osadest.

Näide 4

Vaatame viimast näidet, et mõista, kuidas lambdasid ja regulaarseid funktsioone täidetakse. Niisiis, avage oma IDLE ja tippige uude faili järgmine:

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

Nüüd salvestage fail ja vajutage programmi käivitamiseks F5. Kui te ei teinud ühtegi viga, peaks väljund olema umbes selline.

Väljund:

printer 1 REGULAR CALL

printer 2 REGULAR CALL

printer 1 LAMBDA KÕNE

printer 2 LAMBDA KÕNE

Koodi selgitus

  1. Funktsioon nimega guru, mis võtab esimese funktsioonina teise funktsiooni ja kõik muud 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, kuid ilma tagastamislauseta.
  4. Selles osas kutsume parameetriteks funktsiooni guru ning edastame printeri funktsioonid ja stringi.
  5. See on süntaks neljanda sammu saavutamiseks (st guru funktsiooni kutsumine), kuid lambdade abil.

Järgmises jaotises saate teada, kuidas kasutada Pythonis lambda funktsioone kaardiga (), vähendamiseks () ja filtreerimiseks () .

Lambda kasutamine Pythoni sisseehitatud seadmetega

Lambda funktsioonid pakuvad elegantset ja võimsat viisi toimingute tegemiseks Pythonis sisseehitatud meetodite abil. See on võimalik, kuna lambdadele saab viivitamatult tugineda ja need argumentidena neile funktsioonidele edastada.

IIFE Python Lambdas

IIFE tähistab kohe käivitatud funktsiooni täitmist. See tähendab, et lambda-funktsioon saab helistada kohe, kui see on määratletud. Mõistame seda näite abil; käivitage oma IDLE ja tippige järgmine:

 (lambda x: x + x)(2)

Siin on väljund ja koodi selgitus:

See lambdade võime kohe käivitada võimaldab teil neid kasutada funktsioonides nagu kaart () ja vähendamine (). See on kasulik, kuna te ei pruugi neid funktsioone enam kasutada.

lambdad filtris ()

Filtrifunktsiooni kasutatakse elementide järjestusest mõne konkreetse elemendi valimiseks. Järjestus võib olla mis tahes iteraator, näiteks loendid, komplektid, koondised jne.

Valitavad elemendid põhinevad mõnel eelnevalt määratletud piirangul. Selleks on vaja kahte parameetrit:

  • Funktsioon, mis määratleb filtreerimise piirangu
  • Järjestus (mis tahes iteraator, näiteks loendid, koondised 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]

Koodi 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 () tagastatud filtreeritud väärtused.

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

4. Printige filtrifunktsiooni abil tagastatud tulemus.

lambdas kaardil ()

kaardifunktsiooni kasutatakse konkreetse toimingu rakendamiseks järjestuse igale elemendile. Nagu filter (), võtab see ka 2 parameetrit:

  1. Funktsioon, mis määratleb op elementidele esitamise
  2. Üks või mitu järjestust

Näiteks siin on programm, mis prindib antud loendi numbriruudud:

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, 121, 0, 1]

[KR1]

Koodi selgitus:

  1. Siin määratleme loendi, mida nimetatakse jadadeks ja mis sisaldab mõningaid numbreid.
  2. Kuulutame muutuja nimega filtered_result, mis salvestab kaardistatud väärtused
  3. Funktsioon lambda, mis töötab loendi igal elemendil ja tagastab selle arvu ruudu.
  4. Printige kaardi funktsiooni tagastatud tulemus.

lambdas redutseerimisel ()

Redutseerimisfunktsiooni, nagu kaarti (), kasutatakse toimingu rakendamiseks järjestuse igale elemendile. Kuid see erineb kaardilt oma töö poolest. Need on sammud, millele järgneb funktsioon output () väljundi arvutamiseks:

1. samm. Tehke määratletud toiming järjestuse kahe esimese elemendiga.

2. samm. Salvestage see tulemus

3. samm. Tehke toiming salvestatud tulemuse ja järjestuse järgmise elemendiga.

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

See võtab ka kaks parameetrit:

  1. Funktsioon, mis määratleb teostatava toimingu
  2. Järjestus (mis tahes iteraator, näiteks loendid, koondised jne)

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

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

Siin on väljund:

120

Koodi selgitus:

  1. Impordi vähendamine functoolsi moodulist
  2. Siin määratleme loendi, mida nimetatakse jadadeks ja mis sisaldab mõningaid numbreid.
  3. Deklareerime muutuja nimega toode, mis salvestab vähendatud väärtuse
  4. Lambda funktsioon, mis töötab loendi igal elemendil. See tagastab selle arvu korrutise vastavalt eelmisele tulemusele.
  5. Printige redutseerimisfunktsiooniga tagastatud tulemus.

Miks (ja miks mitte) kasutada lambda funktsioone?

Nagu näete järgmises jaotises, tõlgendatakse lambdasid tõlgendi tasandil samamoodi nagu tavalisi funktsioone. Mõnes mõttes võiks öelda, et lambdas pakub kompaktset süntaksit funktsioonide kirjutamiseks, mis tagastavad ühe avaldise.

Siiski peaksite teadma, millal on hea kasutada lambdasid ja millal neid vältida. Selles osas saate teada mõningatest Pythoni arendajate kasutatavatest disainiprintsiipidest lambdade kirjutamisel.

Üks lambdade kõige levinumaid juhtumeid on funktsionaalne programmeerimine, kuna Python toetab funktsionaalse programmeerimisena tuntud programmeerimise paradigmat (või stiili).

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

Millal ei tohiks te Lambdat kasutada?

Ärge kunagi kirjutage keerukaid lambda-funktsioone tootmiskeskkonnas. Teie koodi hooldavatel kodeerijatel on selle dekrüpteerimine väga keeruline. Kui leiate, et teete keerukaid ühe liiniga väljendeid, oleks õige funktsiooni määratlemine palju parem praktika. Parima tavana peate meeles pidama, et lihtne kood on alati parem kui keeruline kood.

Lambdas vs tavalised funktsioonid

Nagu varem öeldud, on lambdad [vV4] [J5] lihtsalt funktsioonid, millel pole identifikaatorit. Lihtsamalt öeldes on need funktsioonid, millel pole nimesid (seega anonüümsed). Siin on tabel, mis illustreerib lambdade ja Pythoni tavaliste funktsioonide erinevust.

Lambdas

Regulaarsed funktsioonid

Süntaks:

lambda x : x + x

Süntaks:

def (x) :return x + x

Lambda funktsioonidel võib nende kehas olla ainult üks väljend.

Regulaarsete funktsioonide kehas võib olla mitu väljendit ja lauset.

Lambdadel pole nendega seotud nime. Seetõttu tuntakse neid ka anonüümsete funktsioonidena.

Tavalistel funktsioonidel peab olema nimi ja allkiri.

Lambdas ei sisalda tagastamislauset, kuna keha tagastatakse automaatselt.

Funktsioonid, mis peavad tagastama väärtuse, peaksid sisaldama tagastamislauset.

Erinevuste seletus?

Peamine erinevus lambda ja regulaarfunktsiooni vahel on see, et lambda funktsioon hindab ainult ühte avaldist ja annab funktsiooni objekti. Järelikult võime lambda funktsiooni tulemuse nimetada ja kasutada oma programmis nagu eelmises näites.

Eespool toodud näite regulaarne funktsioon näeks välja selline:

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

Siin peame määrama funktsiooni nime , mis tagastab tulemuse, kui seda kutsume . Funktsioon lambda ei sisalda return-lauset, kuna sellel on ainult üks avaldis, mis vaikimisi alati tagastatakse. Samuti ei pea te isegi lambdat määrama, kuna seda saab kohe kasutada (vt järgmist jaotist). Nagu näete järgmises näites, muutuvad lambdad eriti võimsaks, kui kasutame neid koos Pythoni sisseehitatud funktsioonidega.

Kuid võite ikkagi mõelda, kuidas lambdasid erinevad funktsioonist, mis tagastab ühe avaldise (nagu ülaltoodud). Tõlgi tasandil pole erilist vahet. See võib tunduda üllatav, kuid tõlgendaja käsitleb kõiki Pythonis määratletud lambda funktsioone tavalise funktsioonina.

Nagu diagrammil näete, käsitseb pythoni interpretaator neid mõisteid baidekoodiks teisendades samal viisil. Nüüd ei saa te nimetada funktsiooni lambda, kuna selle reserveerib Python, kuid mis tahes muu funktsiooni nimi annab sama baidikoodi [KR6].

Kokkuvõte

  • Lambdas, tuntud ka kui anonüümsed funktsioonid, on väikesed, piiratud funktsioonid, mis ei vaja nime (st identifikaatorit).
  • Igal Pythoni lambda funktsioonil on 3 olulist osa:
  • Lambda märksõna.
  • Parameetrid (või seotud muutujad) ja
  • Funktsioon keha.
  • Lambda kirjutamise süntaks on: lambda parameeter: avaldis
  • Lambdadel võib olla mis tahes arv parameetreid, kuid need pole sulgudes
  • Lambda funktsiooni kehas võib olla ainult 1 avaldis, mis tagastatakse vaikimisi.
  • Baidikoodi tasemel pole suurt vahet, kuidas interpreet lambdade ja tavafunktsioonidega hakkama saab.
  • Lambdas toetab IIFE-d selle süntaksi kaudu: (lambda parameeter: avaldis) (argument)
  • Lambdasid kasutatakse tavaliselt järgmiste Pythoni sisseehitatud seadmetega:
  • Filter: filter (lambda parameeter: avaldis, iterable-järjestus)
  • Kaart: kaart (lambda parameeter: avaldis, iterable-järjestused)
  • Reduce: reduc (lambda parameeter1, parameeter2: avaldis, korduv järjestus)
  • Ärge kirjutage keerukaid lambda-funktsioone tootmiskeskkonnas, kuna see on koodi hooldajatel keeruline.

[J5] Olen lisanud tabeli, kuid selgitus on vajalik erinevuste mõistmiseks.