Python Lambda-functies met VOORBEELDEN

Wat is de Lambda-functie in Python?

Een Lambda-functie in Python programmeren is een anonieme functie of een functie zonder naam. Het is een kleine en beperkte functie met niet meer dan één regel. Net als een normale functie kan een Lambda-functie meerdere argumenten hebben met één uitdrukking.

In Python worden lambda-expressies (of lambda-vormen) gebruikt om anonieme functies te construeren. Om dit te doen, gebruikt u de lambda zoekwoord (net zoals u def gebruikt om normale functies te definiëren). Elke anonieme functie die u definieert in Python heeft 3 essentiële onderdelen:

• Het lambda-sleutelwoord.
• De parameters (of gebonden variabelen), en
• De hoofdtekst van de functie.

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

In deze Lambda in Python-tutorial leer je:

• Syntaxis en voorbeelden
• Lambda's gebruiken met ingebouwde Python
• lambda's in filter()
• lambda's in map()
• lambda's in reduce()
• Waarom (en waarom niet) lambda-functies gebruiken?
• Lambda's versus reguliere functies

Syntaxis en voorbeelden

De formele syntaxis om een ​​lambda-functie te schrijven is als volgt:

lambda p1, p2: expression

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

Merk echter op dat we geen haakjes rond de parameters gebruiken 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 meer weet over lambda's, laten we het eens met een voorbeeld proberen. Open dus uw IDLE en typ het volgende in:

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

Hier 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-sleutelwoord 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 2 parameters toevoegt die we hebben doorgegeven. Merk op dat het een enkele uitdrukking is. Je kunt niet meerdere statements in de body 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 uit te printen en het resultaat te zien. Open nogmaals 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 je bestand op en druk op F5 om het programma uit te voeren. Dit is de output die je zou moeten krijgen.

Uitvoer:

<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 een string die je als parameter doorgeeft aan de lambda.
2. We declareren een lambda die een printstatement 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 wordt de lambda niet aangeroepen door de afdrukfunctie maar gewoon terugkerend het functieobject en de geheugenlocatie waar het is opgeslagen. Dat wordt afgedrukt op de console.

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 ziet een uitvoer als deze.

Uitvoer:

some kind of a useless lambda

Nu wordt de lambda aangeroepen en de string die we doorgeven wordt afgedrukt op de console. Maar wat is die rare syntaxis en waarom staat de lambda-definitie tussen haakjes? Laten we dat nu 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 je zult er meer over leren in de komende secties van deze tutorial.

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 je geen fouten hebt gemaakt, zou de uitvoer er ongeveer zo uit moeten zien.

Uitvoer:

printer 1 REGELMATIG OPROEP

printer 2 REGELMATIG BELLEN

printer 1 LAMBDA OPROEP

printer 2 LAMBDA OPROEP

Code Uitleg

1. Een functie genaamd guru die een andere functie als eerste parameter neemt en alle andere argumenten die erop volgen.
2. printer_one is een eenvoudige functie die de parameter die eraan is doorgegeven, afdrukt en teruggeeft.
3. printer_two is vergelijkbaar met printer_one maar zonder de return-instructie.
4. In dit deel noemen we de guru-functie en geven we de printerfuncties en een string door als parameters.
5. Dit is de syntaxis om de vierde stap te bereiken (d.w.z. het aanroepen van de guru-functie) maar met behulp van lambda's.

In het volgende gedeelte leert u hoe u lambda-functies gebruikt met map(), reduceer(), en filter() in Python.

Lambda's gebruiken met ingebouwde Python

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

IIFE in Python Lambda

IIFE staat voor onmiddellijk aangeroepen functie-uitvoering. Het betekent dat een lambda-functie kan worden opgeroepen zodra deze is gedefinieerd. Laten we dit met een voorbeeld begrijpen; start uw IDLE en typ het volgende:

 (lambda x: x + x)(2)

Hier is de uitleg van de uitvoer en code:

Dit vermogen van lambda's om onmiddellijk te worden aangeroepen, stelt je in staat om ze te gebruiken in functies zoals map() en reduce(). Het is handig omdat je deze functies misschien 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, tuples, 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, tuples, 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))

Dit is de uitvoer:

[10, 8, 7, 5, 11]

Code uitleg:

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

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

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

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

lambda's in map()

de kaartfunctie wordt gebruikt om een ​​bepaalde bewerking toe te passen op elk element in een reeks. Net als filter(), zijn er ook 2 parameters nodig:

1. Een functie die de op te voeren op de elementen definieert
2. Een of meer reeksen

Hier is bijvoorbeeld een programma dat de kwadraten van getallen in een bepaalde 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))

Uitvoer:

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

[KR1]

Code Uitleg:

1. Hier definiëren we een lijst met de naam reeksen die enkele getallen bevat.
2. We declareren een variabele genaamd filtered_result die de toegewezen waarden zal opslaan
3. Een lambda-functie die op elk element van de lijst draait en het kwadraat van dat getal retourneert.
4. Druk het resultaat af dat wordt geretourneerd door de kaartfunctie.

lambda's in reduce()

De reduce-functie, zoals map(), wordt gebruikt om een ​​bewerking toe te passen op elk element in een reeks. Het verschilt echter van de kaart in zijn werking. Dit zijn de stappen gevolgd door de functie reduce() 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, tuples, 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)

Hier is de uitvoer:

120

Code Uitleg:

1. Verminder importeren uit de functools-module
2. Hier definiëren we een lijst met de naam reeksen die enkele getallen bevat.
3. We declareren een variabele met de naam product die de verlaagde waarde opslaat
4. Een lambda-functie die op elk element van de lijst draait. Het zal het product van dat getal retourneren volgens het vorige resultaat.
5. Druk het resultaat af dat wordt geretourneerd door de functie verkleinen.

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 een enkele uitdrukking teruggeven.

U moet echter weten wanneer het een goed idee is om lambda's te gebruiken en wanneer u ze 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, aangezien Python een paradigma (of stijl) van programmeren ondersteunt dat bekend staat als functioneel programmeren.

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

Wanneer mag je Lambda niet gebruiken?

Schrijf nooit ingewikkelde lambda-functies in een productieomgeving. Het zal erg moeilijk zijn voor codeurs die uw code onderhouden om deze te decoderen. Als je merkt dat je complexe one-liner-uitdrukkingen maakt, zou het een veel betere gewoonte zijn om een ​​goede functie te definiëren. Als best practice moet u onthouden dat eenvoudige code altijd beter is dan complexe code.

Lambda's versus reguliere functies

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

Lambda's

Regelmatige functies

Syntaxis:

lambda x : x + x

Syntaxis:

def (x) :
return x + x 

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

Reguliere functies kunnen meerdere uitdrukkingen en instructies in hun hoofdtekst hebben.

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

Reguliere functies moeten een naam en handtekening hebben.

Lambda's bevatten geen return-statement omdat de body automatisch wordt geretourneerd.

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

Uitleg van de verschillen?

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

Een normale functie voor het bovenstaande voorbeeld ziet er als volgt uit:

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

Hier moeten we een naam definiëren voor de functie die retourneert het resultaat wanneer we bellen het. Een lambda-functie bevat geen return-instructie omdat deze slechts één enkele expressie heeft die standaard altijd wordt geretourneerd. U hoeft zelfs geen lambda toe te wijzen, omdat deze onmiddellijk kan worden aangeroepen (zie de volgende sectie). Zoals je in het volgende voorbeeld zult zien, worden lambda's bijzonder krachtig wanneer we ze gebruiken met de ingebouwde functies van Python.

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

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

Samenvatting

• Lambda's, ook wel anonieme functies genoemd, zijn kleine, beperkte functies die geen naam nodig hebben (d.w.z. een identifier).
• Elke lambda-functie in Python heeft 3 essentiële onderdelen:
• Het lambda-sleutelwoord.
• De parameters (of gebonden variabelen), en
• De hoofdtekst van de functie.
• De syntaxis voor het schrijven van een lambda is:lambda parameter:expressie
• Lambda's kunnen een willekeurig aantal parameters hebben, maar ze staan ​​niet tussen accolades
• Een lambda kan maar 1 expressie hebben in de hoofdtekst van de functie, die standaard wordt geretourneerd.
• Op bytecode-niveau is er niet veel verschil tussen hoe lambda's en reguliere functies worden afgehandeld door de interpreter.
• Lambda's ondersteunen IIFE via deze syntaxis:(lambda-parameter:expressie)(argument)
• Lambda's worden vaak gebruikt met de volgende ingebouwde python:
• Filter:filter (lambda-parameter:uitdrukking, itereerbare reeks)
• Kaart:kaart (lambda-parameter:uitdrukking, itereerbare reeksen)
• Reduce:reduce (lambda parameter1, parameter2:expression, iterable-sequence)
• Schrijf geen ingewikkelde lambda-functies in een productieomgeving, omdat dit moeilijk zal zijn voor code-beheerders.

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