Wat is Lambda-functie in Python?
Een Lambda-functie in Python- programmering 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-formulieren) gebruikt om anonieme functies te construeren. Om dit te doen, gebruikt u het lambda- trefwoord (net zoals u def gebruikt om normale functies te definiëren). Elke anonieme functie die u in Python definieert, heeft 3 essentiële onderdelen:
- 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 slechts één uitdrukking bevatten . Bovendien wordt een lambda geschreven in een enkele regel code en kan deze ook onmiddellijk worden aangeroepen. U 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 ()
- lambdas in kaart ()
- lambda's in verminderen ()
- Waarom (en waarom niet) lambda-functies gebruiken?
- Lambdas vs. 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 zo weinig parameters toevoegen als u nodig heeft.
Merk echter op dat we geen haakjes rond de parameters gebruiken zoals bij reguliere functies. Het laatste deel (expressie) is een geldige python-expressie die werkt op de parameters die u aan de functie opgeeft.
voorbeeld 1
Nu je weet wat lambda's zijn, laten we het eens proberen met een voorbeeld. Dus open je IDLE en typ het volgende in:
adder = lambda x, y: x + yprint (adder (1, 2))
Hier is de output:
3
Code Verklaring
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 body van de functie, die de 2 parameters toevoegt die we hebben doorgegeven. Merk op dat het een enkele uitdrukking is. U kunt niet meerdere instructies 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 af te drukken en het resultaat te zien. Open opnieuw uw IDLE en typ het volgende in:
#What a lambda returnsstring='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 output die u zou moeten krijgen.
Uitgang:
at 0x00000185C3BF81E0>
Wat gebeurt er hier? Laten we de code bekijken om verder te begrijpen.
Code Verklaring
- Hier definiëren we een string die u als parameter doorgeeft aan de lambda.
- We declareren een lambda die een printverklaring oproept en het resultaat afdrukt.
Maar waarom drukt het programma de string die we passeren niet af? Dit komt doordat de lambda zelf een functieobject retourneert. In dit voorbeeld wordt de lambda niet aangeroepen door de printfunctie maar retourneert eenvoudig het functieobject en de geheugenlocatie waar het is opgeslagen. Dat is wat er op de console wordt afgedrukt.
Voorbeeld 3
Als je echter een programma als dit schrijft:
#What a lambda returns #2x="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.
Uitgang:
some kind of a useless lambda
Nu wordt de lambda geroepen en de snaar die we passeren wordt op de console afgedrukt. Maar wat is die rare syntaxis en waarom staat de lambda-definitie tussen haakjes? Laten we dat nu begrijpen.
Code Verklaring
- Hier is dezelfde string die we in het vorige voorbeeld hebben gedefinieerd.
- In dit deel definiëren we een lambda en noemen deze onmiddellijk 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 naar een laatste voorbeeld kijken om te begrijpen hoe lambda's en reguliere functies worden uitgevoerd. Dus open je IDLE en typ in een nieuw bestand het volgende:
#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'))
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.
Uitgang:
printer 1 REGELMATIG OPROEP
printer 2 REGELMATIG OPROEP
printer 1 LAMBDA-OPROEP
printer 2 LAMBDA-OPROEP
Code Verklaring
- Een functie genaamd goeroe die een andere functie als eerste parameter krijgt en alle andere argumenten die erop volgen.
- printer_one is een eenvoudige functie die de parameter die eraan is doorgegeven, afdrukt en retourneert.
- printer_two is vergelijkbaar met printer_one maar zonder de return-instructie.
- In dit deel noemen we de goeroe-functie en geven we de printerfuncties en een string door als parameters.
- Dit is de syntaxis om de vierde stap te bereiken (dwz de goeroe-functie aanroepen) maar met behulp van lambda's.
In de volgende sectie leert u hoe u lambda-functies kunt gebruiken met map (), reduce () 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 begrijpen met een voorbeeld; start uw IDLE en typ het volgende in:
(lambda x: x + x)(2)
Hier is de uitvoer en code-uitleg:
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 u 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, 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 verklaring definiëren we een lijst met de naam reeksen die enkele getallen bevat.
2. Hier declareren we een variabele met de naam gefilterd_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 true retourneert als deze groter is dan 4.
4. Druk het resultaat af dat door de filterfunctie wordt geretourneerd.
lambdas in kaart ()
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:
- Een functie die de op definieert die op de elementen moet worden uitgevoerd
- Een of meer reeksen
Hier is bijvoorbeeld een programma dat de vierkanten 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))
Uitgang:
[100, 4, 64, 49, 25, 16, 121, 0, 1]
[KR1]
Code Verklaring:
- Hier definiëren we een lijst met de naam reeksen die enkele getallen bevat.
- We declareren een variabele genaamd gefilterd_result die de toegewezen waarden zal opslaan
- Een lambda-functie die op elk element van de lijst wordt uitgevoerd en het kwadraat van dat getal retourneert.
- Druk het resultaat af dat door de kaartfunctie is geretourneerd.
lambda's in verminderen ()
De reduceerfunctie, 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 die worden 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 totdat er geen elementen meer over zijn.
Er zijn ook twee parameters nodig:
- Een functie die de uit te voeren bewerking definieert
- 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 reducesequences = [1,2,3,4,5]product = reduce (lambda x, y: x*y, sequences)print(product)
Hier is de output:
120
Code Verklaring:
- Importeer verkleinen vanuit de functools-module
- Hier definiëren we een lijst met de naam reeksen die enkele getallen bevat.
- We declareren een variabele met de naam product waarin de verminderde waarde wordt opgeslagen
- Een lambda-functie die op elk element van de lijst wordt uitgevoerd. Het retourneert het product van dat nummer volgens het vorige resultaat.
- Druk het resultaat af dat wordt geretourneerd door de verkleiningsfunctie.
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 compacte syntaxis bieden voor het schrijven van functies die een enkele uitdrukking retourneren.
U moet echter weten wanneer het een goed idee is om lambda's te gebruiken en wanneer u ze moet vermijden. In deze sectie leer je enkele van de ontwerpprincipes die door python-ontwikkelaars worden gebruikt bij het schrijven van lambda's.
Een van de meest voorkomende use-cases voor lambda's is in 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 map, 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?
U mag nooit gecompliceerde lambda-functies schrijven in een productieomgeving. Het zal erg moeilijk zijn voor codeerders die uw code onderhouden om deze te ontsleutelen. Als je merkt dat je complexe oneliner-uitdrukkingen maakt, zou het een veel betere gewoonte zijn om een juiste functie te definiëren. Als best practice moet u onthouden dat eenvoudige code altijd beter is dan complexe code.
Lambdas vs. reguliere functies
Zoals eerder vermeld, zijn lambda's [vV4] [J5] alleen functies waaraan geen identificator is gebonden. In eenvoudigere woorden, het zijn functies zonder namen (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 uitspraken in hun hoofdtekst hebben.
Lambda's hebben geen naam die eraan is gekoppeld. Daarom worden ze ook wel anonieme functies genoemd.
Reguliere functies moeten een naam en handtekening hebben.
Lambdas bevat geen return-instructie omdat de body automatisch wordt geretourneerd.
Functies die waarde moeten retourneren, moeten een retourinstructie bevatten.
Verklaring van de verschillen?
Het belangrijkste verschil tussen een lambda en een reguliere functie is dat de lambda-functie slechts één uitdrukking evalueert en een functieobject oplevert. Daarom kunnen we het resultaat van de lambda-functie een naam geven en het in ons programma gebruiken zoals we in het vorige voorbeeld hebben gedaan.
Een normale functie voor het bovenstaande voorbeeld zou er als volgt uitzien:
def adder (x, y):return x + yprint (adder (1, 2))
Hier moeten we een naam definiëren voor de functie die het resultaat retourneert wanneer we deze aanroepen . Een lambda-functie bevat geen return-instructie omdat deze slechts één enkele uitdrukking 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.
U kunt zich echter nog steeds afvragen 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 je in het diagram kunt zien, worden de twee definities op dezelfde manier afgehandeld door de python-interpreter wanneer ze worden geconverteerd naar bytecode. Nu kun je een functie lambda geen naam geven omdat deze is gereserveerd door Python, maar elke andere functienaam levert dezelfde bytecode [KR6] op.
Overzicht
- Lambdas, ook bekend als anonieme functies, zijn kleine, beperkte functies die geen naam (dwz een identificatie) nodig hebben.
- Elke lambda-functie in Python heeft 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 ze staan niet tussen accolades
- Een lambda kan slechts 1 uitdrukking in zijn functielichaam hebben, die standaard wordt geretourneerd.
- Op bytecode-niveau is er niet veel verschil tussen hoe lambda's en reguliere functies door de tolk worden afgehandeld.
- Lambdas ondersteunt IIFE via deze syntaxis: (lambda parameter: expression) (argument)
- Lambda's worden vaak gebruikt met de volgende ingebouwde python-ins:
- Filter: filter (lambda-parameter: uitdrukking, itereerbare reeks)
- Map: map (lambda-parameter: uitdrukking, itereerbare-reeksen)
- Reduce: reduce (lambda parameter1, parameter2: expression, iterable-sequence)
- Schrijf geen gecompliceerde 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.