Python Lambdatoiminnot ESIMERKKEJÄ

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, että emme käytä hakasulkuja parametrien ympärillä kuten tavallisten funktioiden kanssa. Viimeinen osa (lauseke) on mikä tahansa kelvollinen python-lauseke, joka toimii funktiolle antamillasi parametreilla.

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

Tässä on tuotos:

3

Koodin 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

Se oli perusesimerkki lambdan perusteiden ja syntaksin ymmärtämiseksi. Yritetään nyt tulostaa lambda ja katsoa tulos. Avaa uudelleen 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äällä tapahtuu? Katsotaanpa koodia ymmärtääksesi paremmin.

Koodin selitys

1. Tässä määrittelemme a jono jonka välität parametrina lambdalle.
2. Ilmoitamme lambdan, joka kutsuu print-lauseen ja tulostaa tuloksen.

Mutta miksi ohjelma ei tulosta lähettämäämme merkkijonoa? Tämä johtuu siitä, että lambda itse palauttaa funktioobjektin. Tässä esimerkissä lambda ei ole nimeltään tulostustoiminnolla, mutta yksinkertaisesti palaavat funktioobjekti ja muistipaikka, johon se on tallennettu. Se tulostetaan konsolissa.

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äet tällaisen tulosteen.

lähtö:

some kind of a useless lambda

Nyt lambdaa kutsutaan ja ohittamamme merkkijono tulostetaan konsoliin. Mutta mikä on tuo outo syntaksi, ja miksi lambda-määritelmä on katettu suluissa? Ymmärretään se nyt.

Koodin selitys

1. Tässä on sama merkkijono, jonka määritimme edellisessä esimerkissä.
2. Tässä osassa määrittelemme lambdan ja kutsumme sitä välittömästi välittämällä merkkijonon argumenttina. Tätä kutsutaan IIFE:ksi, ja opit siitä lisää tämän opetusohjelman tulevissa osissa.

Esimerkki 4

Katsotaanpa viimeistä esimerkkiä ymmärtääksemme, kuinka lambdat ja tavalliset funktiot suoritetaan. Joten, avaa omasi 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 paina F5 käynnistääksesi ohjelman. Jos et tehnyt virheitä, tulosteen pitäisi olla jotain tällaista.

lähtö:

printer 1 REGULAR CALL

printer 2 REGULAR CALL

printer 1 LAMBDA CALL

printer 2 LAMBDA CALL

Koodin 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 välitetyn parametrin ja palauttaa sen.
3. tulostin_kaksi on samanlainen kuin tulostin_one, mutta ilman return-lausetta.
4. Tässä osassa kutsumme guru-funktiota ja annamme parametreiksi tulostinfunktiot ja merkkijonon.
5. Tämä on syntaksi, jolla saavutetaan neljäs vaihe (eli guru-funktion kutsuminen), mutta käytetään lambdaa.

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-funktio on kutsuttavissa heti, kun se on määritelty. Ymmärretään tämä esimerkin avulla; sytytä omasi 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ääritettyyn rajoitteeseen. Se vaatii 2 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 tulos:

[10, 8, 7, 5, 11]

Koodin 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()

karttatoimintoa käytetään tietyn toiminnon soveltamiseen jokaiseen sekvenssin elementtiin. Kuten filter(), se vaatii myös 2 parametria:

1. Funktio, joka määrittää elementeille suoritettavan op:n
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]

[KR1]

Koodin selitys:

1. Tässä määritämme listan, jota kutsutaan sekvensseiksi ja joka sisältää joitain numeroita.
2. Ilmoitamme muuttujan nimeltä filtered_result, joka tallentaa yhdistetyt arvot
3. Lambda-funktio, joka suoritetaan jokaisessa luettelon elementissä ja palauttaa kyseisen luvun neliön.
4. Tulosta karttatoiminnon 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

Koodin selitys:

1. Tuo redusointi functools-moduulista
2. Tässä määritämme listan, jota kutsutaan sekvensseiksi ja joka sisältää joitain numeroita.
3. Ilmoitamme muuttujan nimeltä tuote, joka tallentaa vähennetyn arvon
4. Lambda-funktio, joka suoritetaan jokaisessa luettelon elementissä. Se palauttaa kyseisen luvun tulon edellisen tuloksen mukaisesti.
5. Tulosta vähennystoiminnon 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ä idea käyttää lambdaa ja milloin niitä kannattaa välttää. Tässä osiossa opit joitakin suunnitteluperiaatteita, joita python-kehittäjät käyttävät lambda-kirjoituksissa.

Yksi yleisimmistä lambda-käyttötapauksista on toiminnallinen ohjelmointi as Python tukee ohjelmoinnin paradigmaa (tai tyyliä), joka tunnetaan nimellä toiminnallinen ohjelmointi.

Sen avulla voit antaa funktion parametrina toiselle funktiolle (esimerkiksi kartassa, suodattimessa jne.). Tällaisissa tapauksissa lambdat tarjoavat tyylikkään tavan luoda kertaluonteinen funktio ja välittää se parametriksi.

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, lambdat ovat [vV4][J5] vain toimintoja, joihin ei ole sidottu tunnistetta. Yksinkertaisemmin sanottuna ne ovat toimintoja, joilla ei ole nimiä (siis anonyymejä). Tässä on taulukko havainnollistamaan eroa lambda-funktioiden ja pythonin tavallisten funktioiden välillä.

Lambdat

Säännölliset toiminnot

Syntaksi:

lambda x : x + x

Syntaksi:

def (x) :
return x + x 

Lambdatoiminnoilla voi olla vain yksi ilmaisu kehossaan.

Säännöllisten funktioiden rungossa voi olla useita lausekkeita ja lausekkeita.

Lambdaan ei ole liitetty nimeä. Siksi ne tunnetaan myös anonyymeinä funktioina.

Tavallisilla funktioilla on oltava nimi ja allekirjoitus.

Lambdat eivät sisällä return-lausetta, koska runko palautetaan automaattisesti.

Funktioiden, joiden on palautettava arvo, tulee sisältää return-lause.

Selitys eroista?

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 se. Lambda-funktio ei sisällä return-lausetta, koska sillä on vain yksi lauseke, joka palautetaan aina oletuksena. Sinun ei myöskään tarvitse määrittää lambdaa, koska se voidaan kutsua välittömästi (katso seuraava osa). Kuten seuraavassa esimerkissä näet, lambdasta tulee erityisen voimakas, 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.

Kuten kaaviosta näkyy, python-tulkki käsittelee näitä kahta määritelmää samalla tavalla, kun ne muunnetaan tavukoodiksi. Nyt et voi nimetä funktiota lambda koska se on varattu Python, mutta mikä tahansa muu funktion nimi tuottaa saman tavukoodin[KR6].

Yhteenveto

• Lambdat, jotka tunnetaan myös anonyymeinä funktioina, ovat pieniä, rajoitettuja toimintoja, jotka eivät tarvitse nimeä (eli tunnistetta).
• Jokainen lambda-toiminto mukana Python siinä on 3 olennaista osaa:
• Lambda-avainsana.
• Parametrit (tai sidotut muuttujat) ja
• Toimintorunko.
• Lambdan kirjoittamisen syntaksi on: lambda-parametri: lauseke
• Lambdalla voi olla mikä tahansa määrä parametreja, mutta niitä ei ole suljettu aaltosulkeisiin
• Lambda-funktion rungossa voi olla vain yksi lauseke, joka palautetaan oletuksena.
• Tavukooditasolla ei ole paljon eroa siinä, miten tulkki käsittelee lambda- ja tavallisia toimintoja.
• Lambdat tukevat IIFE:tä tällä syntaksilla: (lambda-parametri: lauseke)(argumentti)
• Lambdaa käytetään yleisesti seuraavien sisäänrakennettujen python-laitteiden kanssa:
• Suodatin: suodatin (lambda-parametri: lauseke, iteroitava sekvenssi)
• Kartta: kartta (lambda-parametri: lauseke, iteroitavissa olevat sekvenssit)
• Pienennä: vähennä (lambda-parametri1, parametri2: lauseke, iteroitava sekvenssi)
• Älä kirjoita monimutkaisia ​​lambda-funktioita tuotantoympäristöön, koska se on vaikeaa koodin ylläpitäjille.

[J5]Olen lisännyt taulukon, mutta selitys on tarpeen erojen ymmärtämiseksi.

Tämä koodi on muokattavissa. Napsauta Suorita suorittaaksesi