Python Lambda-functies met VOORBEELDEN

Waar zit de Lambda-functie in? Python?

A 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 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.

Merk echter op dat we geen haakjes rond de parameters gebruiken zoals bij gewone functies. Het laatste deel (de expressie) is een willekeurige geldige waarde. Python Een expressie die werkt met de parameters die je aan de functie doorgeeft.

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

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 basisprincipes en de syntaxis van lambda te begrijpen. Laten we nu proberen een lambda af te drukken en het resultaat te bekijken. Open opnieuw 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 hier? Laten we de code bekijken om dit beter te begrijpen.

Code Uitleg:

1. Hier definiëren we een snaar die je als parameter aan de lambda doorgeeft.

2. We declareren een lambda-uitdrukking die een printopdracht aanroept en het resultaat afdrukt.

Maar waarom print het programma de string die we doorgeven niet? Dat komt omdat de lambda zelf een functieobject retourneert. In dit voorbeeld wordt de lambda niet genaamd door de printfunctie, maar is simpelweg terugkerende Het functieobject en de geheugenlocatie waar het is opgeslagen. Dat is wat er in 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 als je het programma start door op F5 te drukken, krijg je een uitvoer zoals deze te zien.

Output:

some kind of a useless lambda

Nu wordt de lambda-functie aangeroepen en de string die we doorgeven, wordt in de console afgedrukt. Maar wat is die vreemde syntax, en waarom staat de definitie van de lambda-functie tussen haakjes? Laten we dat nu eens bekijken.

Code Uitleg:

1. Hier is dezelfde tekenreeks die we in het vorige voorbeeld hebben gedefinieerd.

2. In dit deel definiëren we een lambda-uitdrukking en roepen we deze direct aan door de tekenreeks als argument door te geven. Dit noemen we een IIFE (Immediately Invoked Function Expression), en hierover leer je meer in de volgende delen van deze handleiding.

Voorbeeld 4

Laten we tot slot nog een voorbeeld bekijken om te begrijpen hoe lambda-uitdrukkingen en gewone 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 het bestand nu 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.

Output:

printer 1 REGULAR CALL

printer 2 REGULAR CALL

printer 1 LAMBDA CALL

printer 2 LAMBDA CALL

Code Uitleg:

1. Een functie genaamd guru die een andere functie als eerste parameter en alle andere argumenten die daarop volgen, accepteert.

2. printer_one is een eenvoudige functie die de eraan doorgegeven parameter afdrukt en retourneert.

3. printer_two is vergelijkbaar met printer_one, maar dan zonder de return-instructie.

4. In dit deel roepen we de guru-functie aan en geven we de printerfuncties en een tekenreeks als parameters door.

5. Dit is de syntaxis om de vierde stap (het aanroepen van de guru-functie) te bereiken, maar dan met behulp van lambda-uitdrukkingen.

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. Dit betekent dat een lambdafunctie aanroepbaar is zodra deze is gedefinieerd. Laten we dit met een voorbeeld verduidelijken; start uw 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 aantal vooraf gedefinieerde beperkingen. Het vereist 2 parameters:

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

Dit is de uitvoer:

[10, 8, 7, 5, 11]

Code Uitleg:

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 reeks. Net als `filter()` heeft deze functie twee parameters:

1. Een functie die de bewerking definieert die 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]

Code Uitleg:

1. Hier definiëren we een lijst genaamd 'sequenties' die een aantal getallen bevat.

2. We declareren een variabele genaamd filtered_result die de toegewezen waarden zal opslaan.

3. Een lambdafunctie die op elk element van de lijst wordt uitgevoerd en het kwadraat van dat getal retourneert.

4. Print het resultaat dat de map-functie retourneert.

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) Sla dit resultaat op.

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 Uitleg:

1. Importeer reduce uit de functools-module.

2. Hier definiëren we een lijst genaamd 'sequenties' die een aantal getallen bevat.

3. We declareren een variabele genaamd product die de gereduceerde waarde zal opslaan.

4. Een lambdafunctie die op elk element van de lijst wordt uitgevoerd. Deze retourneert het product van dat getal, zoals in het vorige resultaat.

5. Print het resultaat dat de reduce-functie retourneert.

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.

Je moet echter wel weten wanneer het een goed idee is om lambda-functies te gebruiken en wanneer je ze beter kunt vermijden. In dit gedeelte leer je enkele ontwerpprincipes die worden gebruikt door Python ontwikkelaars bij het schrijven van lambda-functies.

Een van de meest voorkomende toepassingen van lambda-uitdrukkingen is in functioneel programmeren, omdat Python ondersteunt een paradigma (of stijl) van programmeren dat bekend staat als functioneel programmeren.

Het stelt je in staat om een ​​functie als parameter aan een andere functie door te geven (bijvoorbeeld in `map`, `filter`, enz.). In dergelijke gevallen biedt het gebruik van lambda-uitdrukkingen een elegante manier om een ​​eenmalige functie te creëren 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-uitdrukkingen functies zonder een bijbehorende identificatiecode. Simpeler gezegd: het zijn functies zonder naam (vandaar de naam 'anoniem'). Hieronder staat een tabel die het verschil tussen lambda-uitdrukkingen en gewone functies illustreert. Python.

lambda x : x + x

def (x) :
return x + x 

Uitleg 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 Een lambdafunctie bevat geen return-statement, omdat deze slechts één expressie bevat die standaard altijd wordt geretourneerd. Je hoeft een lambdafunctie zelfs niet toe te wijzen, omdat deze direct kan worden aangeroepen (zie de vorige sectie). Zoals je zult zien, worden lambdafuncties 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.

Op bytecode-niveau worden de twee definities op dezelfde manier verwerkt door de Python interpreter. Nu kun je geen functie meer benoemen. lambda omdat het gereserveerd is door PythonMaar elke andere functienaam levert dezelfde bytecode op.

Veelgestelde vragen