Python Lambda-functies met VOORBEELDEN

In Pythonworden lambda-expressies (of lambda-vormen) gebruikt om anonieme functies te construeren. Hiervoor maak je gebruik van de lambda trefwoord (net zoals u gebruikt def om normale functies te definiëren). Elke anonieme functie die u definieert Python zal uit 3 essentiële onderdelen bestaan:

• Het lambda-trefwoord.
• De parameters (of gebonden variabelen), en
• Het functielichaam.

Een lambda-functie kan een willekeurig aantal parameters hebben, maar de hoofdtekst van de functie kan alleen maar bevatten een uitdrukking. Bovendien wordt een lambda in één regel code geschreven en kan deze ook direct worden aangeroepen. U zult dit allemaal in actie zien in de komende voorbeelden.

Syntaxis en voorbeelden

De formele syntaxis voor het schrijven van een lambdafunctie is zoals hieronder weergegeven:

lambda p1, p2: expression

Hier zijn p1 en p2 de parameters die worden doorgegeven aan de lambdafunctie. U kunt zoveel of weinig parameters toevoegen als u nodig heeft.

Let er echter op dat we geen haakjes gebruiken rond de parameters zoals we dat doen bij reguliere functies. Het laatste deel (expressie) is een geldige python-expressie die werkt op de parameters die u aan de functie verstrekt.

Voorbeeld 1

Nu je weet wat lambda's zijn, laten we het proberen met een voorbeeld. Open dus uw IDLE en typ het volgende in:

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

Dit is de uitvoer:

3

Code Uitleg

Hier definiëren we een variabele die het resultaat bevat dat wordt geretourneerd door de lambda-functie.

1. Het lambda-trefwoord dat wordt gebruikt om een ​​anonieme functie te definiëren.

2. x en y zijn de parameters die we doorgeven aan de lambda-functie.

3. Dit is de hoofdtekst van de functie, die de twee parameters toevoegt die we hebben doorgegeven. Merk op dat het een enkele uitdrukking is. U kunt niet meerdere instructies in de hoofdtekst van een lambda-functie schrijven.

4. We roepen de functie aan en drukken de geretourneerde waarde af.

Voorbeeld 2

Dat was een eenvoudig voorbeeld om de grondbeginselen en syntaxis van lambda te begrijpen. Laten we nu proberen een lambda af te drukken en het resultaat te bekijken. Nogmaals, open uw IDLE en typ het volgende in:

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

Sla nu uw bestand op en druk op F5 om het programma uit te voeren. Dit is de uitvoer die u zou moeten krijgen.

Output:

<function <lambda> at 0x00000185C3BF81E0>

Wat gebeurt er hier? Laten we naar de code kijken om het verder te begrijpen.

Code Uitleg

1. Hier definiëren we a snaar die u als parameter aan de lambda doorgeeft.
2. We declareren een lambda die een printinstructie aanroept en het resultaat afdrukt.

Maar waarom drukt het programma de string die we doorgeven niet af? Dit komt omdat de lambda zelf een functieobject retourneert. In dit voorbeeld is de lambda niet aanwezig genaamd door de printfunctie, maar eenvoudig terugkerende het functieobject en de geheugenlocatie waar het is opgeslagen. Dat is wat er op de console wordt afgedrukt.

Voorbeeld 3

Als u echter een programma als dit schrijft:

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

En voer het uit door op F5 te drukken, je zult een uitvoer als deze zien.

Output:

some kind of a useless lambda

Nu wordt de lambda aangeroepen en de string die we doorgeven wordt op de console afgedrukt. Maar wat is die vreemde syntaxis en waarom staat de lambda-definitie tussen haakjes? Laten we dat nu eens begrijpen.

Code Uitleg

1. Hier is dezelfde string die we in het vorige voorbeeld hebben gedefinieerd.
2. In dit deel definiëren we een lambda en roepen deze onmiddellijk aan door de string als argument door te geven. Dit wordt een IIFE genoemd, en u zult er meer over leren in de komende secties van deze zelfstudie.

Voorbeeld 4

Laten we een laatste voorbeeld bekijken om te begrijpen hoe lambda's en reguliere functies worden uitgevoerd. Open dus uw IDLE en typ in een nieuw bestand het volgende:

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

Sla nu het bestand op en druk op F5 om het programma uit te voeren. Als u geen fouten heeft gemaakt, zou de uitvoer er ongeveer zo uit moeten zien.

Output:

printer 1 REGULAR CALL

printer 2 REGULAR CALL

printer 1 LAMBDA CALL

printer 2 LAMBDA CALL

Code Uitleg

1. Een functie met de naam guru die een andere functie als eerste parameter neemt en eventuele andere argumenten die daarop volgen.
2. printer_one is een eenvoudige functie die de doorgegeven parameter afdrukt en retourneert.
3. printer_two is vergelijkbaar met printer_one, maar zonder de return-instructie.
4. In dit deel roepen we de goeroefunctie aan en geven we de printerfuncties en een string door als parameters.
5. Dit is de syntaxis om de vierde stap te bereiken (dwz de goeroefunctie aan te roepen), maar met behulp van lambdas.

In het volgende gedeelte leert u hoe u lambda-functies gebruikt kaart(), verminderen(), en filter() in Python.

Lambda's gebruiken bij Python ingebouwde ins

Lambda-functies bieden een elegante en krachtige manier om bewerkingen uit te voeren met behulp van ingebouwde methoden in Python. Dit is mogelijk omdat lambdas onmiddellijk kunnen worden aangeroepen en als argument aan deze functies kunnen worden doorgegeven.

IIFE in Python Lambda

IIFE staat voor onmiddellijk een beroep gedaan op de uitvoering van de functie. Het betekent dat een lambda-functie kan worden aangeroepen zodra deze is gedefinieerd. Laten we dit begrijpen met een voorbeeld; vuur je aan IDLE en typ het volgende in:

 (lambda x: x + x)(2)

Hier is de uitvoer en code-uitleg:

Dankzij de mogelijkheid om lambda's onmiddellijk aan te roepen, kunt u ze gebruiken in functies zoals map() en reduce(). Het is handig omdat u deze functies mogelijk niet meer wilt gebruiken.

lambda's in filter()

De filterfunctie wordt gebruikt om bepaalde elementen uit een reeks elementen te selecteren. De reeks kan elke iterator zijn, zoals lijsten, sets, tupels, enz.

De elementen die worden geselecteerd, zijn gebaseerd op een vooraf gedefinieerde beperking. Er zijn 2 parameters nodig:

• Een functie die de filterbeperking definieert
• Een reeks (elke iterator zoals lijsten, tupels, enz.)

Bijvoorbeeld

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

Hier is de output:

[10, 8, 7, 5, 11]

Code Verklaring:

1. In de eerste zin definiëren we een lijst met de naam reeksen die een aantal getallen bevat.

2. Hier declareren we een variabele genaamd filtered_result, die de gefilterde waarden opslaat die worden geretourneerd door de functie filter().

3. Een lambda-functie die op elk element van de lijst wordt uitgevoerd en waar retourneert als deze groter is dan 4.

4. Druk het resultaat af dat door de filterfunctie wordt geretourneerd.

lambda's in kaart()

de map-functie wordt gebruikt om een ​​bepaalde bewerking toe te passen op elk element in een sequentie. Net als filter() heeft het ook 2 parameters:

1. Een functie die definieert welke bewerking op de elementen moet worden uitgevoerd
2. Eén of meer reeksen

Hier is bijvoorbeeld een programma dat de kwadraten van getallen in een gegeven lijst afdrukt:

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

Output:

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

[KR1]

Code Verklaring:

1. Hier definiëren we een lijst met de naam reeksen die een aantal getallen bevat.
2. We declareren een variabele met de naam filtered_result, waarin de toegewezen waarden worden opgeslagen
3. Een lambdafunctie die op elk element van de lijst wordt uitgevoerd en het kwadraat van dat getal retourneert.
4. Druk het resultaat af dat door de kaartfunctie wordt geretourneerd.

lambda's in reduce()

De reduce-functie, zoals map(), wordt gebruikt om een ​​bewerking toe te passen op elk element in een sequentie. Het verschilt echter van de map in zijn werking. Dit zijn de stappen die de reduce()-functie volgt om een ​​uitvoer te berekenen:

Stap 1) Voer de gedefinieerde bewerking uit op de eerste 2 elementen van de reeks.

Stap 2) Bewaar dit resultaat

Stap 3) Voer de bewerking uit met het opgeslagen resultaat en het volgende element in de reeks.

Stap 4) Herhaal dit totdat er geen elementen meer over zijn.

Er zijn ook twee parameters nodig:

1. Een functie die de uit te voeren bewerking definieert
2. Een reeks (elke iterator zoals lijsten, tupels, enz.)

Hier is bijvoorbeeld een programma dat het product van alle elementen in een lijst retourneert:

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

Dit is de uitvoer:

120

Code Verklaring:

1. Importeer reductie uit de functools-module
2. Hier definiëren we een lijst met de naam reeksen die een aantal getallen bevat.
3. We declareren een variabele met de naam product, waarin de verminderde waarde wordt opgeslagen
4. Een lambda-functie die op elk element van de lijst wordt uitgevoerd. Het retourneert het product van dat getal volgens het vorige resultaat.
5. Druk het resultaat af dat door de reduceerfunctie wordt geretourneerd.

Waarom (en waarom niet) lambda-functies gebruiken?

Zoals u in de volgende sectie zult zien, worden lambda's op dezelfde manier behandeld als reguliere functies op tolkniveau. In zekere zin zou je kunnen zeggen dat lambda's een compacte syntaxis bieden voor het schrijven van functies die één enkele expressie retourneren.

U moet echter weten wanneer het een goed idee is om lambdas te gebruiken en wanneer u deze moet vermijden. In dit gedeelte leer je enkele ontwerpprincipes die door Python-ontwikkelaars worden gebruikt bij het schrijven van lambda's.

Een van de meest voorkomende gebruiksscenario's voor lambda's is functioneel programmeren Python ondersteunt een paradigma (of stijl) van programmeren dat bekend staat als functioneel programmeren.

Hiermee kunt u een functie als parameter aan een andere functie opgeven (bijvoorbeeld in kaart, filter, enz.). In dergelijke gevallen biedt het gebruik van lambda's een elegante manier om een ​​eenmalige functie te maken en deze als parameter door te geven.

Wanneer mag u Lambda niet gebruiken?

Je moet nooit ingewikkelde lambdafuncties schrijven in een productieomgeving. Het zal erg moeilijk zijn voor programmeurs die je code onderhouden om deze te decoderen. Als je merkt dat je complexe one-liner expressies maakt, zou het een veel betere gewoonte zijn om een ​​goede functie te definiëren. Als best practice moet je onthouden dat simpele code altijd beter is dan complexe code.

Lambda's versus reguliere functies

Zoals eerder vermeld zijn lambda's[vV4][J5] slechts functies waaraan geen identificatie is gekoppeld. In eenvoudiger bewoordingen zijn het functies zonder naam (vandaar anoniem). Hier is een tabel om het verschil tussen lambdas en reguliere functies in Python te illustreren.

Lambda's

Reguliere functies

Syntax:

lambda x : x + x

Syntax:

def (x) :
return x + x 

Lambda-functies kunnen slechts één uitdrukking in hun lichaam hebben.

Reguliere functies kunnen meerdere expressies en instructies in hun lichaam hebben.

Aan Lambda's is geen naam verbonden. Daarom worden ze ook wel anonieme functies genoemd.

Reguliere functies moeten een naam en handtekening hebben.

Lambda's bevatten geen retourverklaring omdat de body automatisch wordt geretourneerd.

Functies die waarde moeten retourneren, moeten een return-instructie bevatten.

Verklaring van de verschillen?

Het belangrijkste verschil tussen een lambda- en een reguliere functie is dat de lambda-functie slechts één enkele expressie evalueert en een functieobject oplevert. Daarom kunnen we het resultaat van de lambda-functie een naam geven en in ons programma gebruiken, zoals we in het vorige voorbeeld deden.

Een reguliere functie voor het bovenstaande voorbeeld zou er als volgt uitzien:

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

Hier moeten we a definiëren naam voor de functie die Retourneren het resultaat toen wij Bellen it. Een lambda-functie bevat geen return-statement omdat deze slechts één expressie heeft die standaard altijd wordt geretourneerd. U hoeft ook geen lambda toe te wijzen, omdat deze direct kan worden aangeroepen (zie de volgende sectie). Zoals u in het volgende voorbeeld zult zien, worden lambda's bijzonder krachtig wanneer we ze gebruiken met Pythoningebouwde functies.

U vraagt ​​zich echter misschien nog steeds af hoe lambda's verschillen van een functie die een enkele expressie retourneert (zoals die hierboven). Op tolkniveau is er niet veel verschil. Het klinkt misschien verrassend, maar elke lambda-functie die je definieert Python wordt door de tolk als een normale functie behandeld.

Zoals u in het diagram kunt zien, worden de twee definities op dezelfde manier verwerkt door de Python-interpreter wanneer ze worden geconverteerd naar bytecode. Nu kunt u een functie geen naam geven lambda omdat het gereserveerd is door Python, maar elke andere functienaam levert dezelfde bytecode[KR6] op.

Samenvatting

• Lambda's, ook wel anonieme functies genoemd, zijn kleine, beperkte functies die geen naam (dwz een identificatie) nodig hebben.
• Elke lambdafunctie in Python bestaat uit 3 essentiële onderdelen:
• Het lambda-trefwoord.
• De parameters (of gebonden variabelen), en
• Het functielichaam.
• De syntaxis voor het schrijven van een lambda is: lambda parameter: expressie
• Lambda's kunnen een willekeurig aantal parameters hebben, maar deze staan ​​niet tussen accolades
• Een lambda kan slechts één expressie in de functietekst hebben, die standaard wordt geretourneerd.
• Op bytecodeniveau is er niet veel verschil tussen hoe lambda's en reguliere functies door de tolk worden afgehandeld.
• Lambdas ondersteunen IIFE via deze syntaxis: (lambda-parameter: expressie) (argument)
• Lambda's worden vaak gebruikt met de volgende Python-ingebouwde modules:
• Filter: filter (lambda-parameter: expressie, iterabele reeks)
• Kaart: kaart (lambda-parameter: expressie, iterabele reeksen)
• Reduce: reduceren (lambda-parameter1, parameter2: expressie, itereerbare reeks)
• Schrijf geen ingewikkelde lambda-functies in een productieomgeving, omdat dit moeilijk zal zijn voor code-onderhouders.

[J5]Ik heb een tabel toegevoegd, maar de uitleg is nodig om de verschillen te begrijpen.

Deze code kan worden bewerkt. Klik op Uitvoeren om uit te voeren