Lambda-functies in Python

Wat zijn Lambda-functies?

​
In Python zijn functies objecten: ze kunnen worden toegewezen aan variabelen, kunnen worden geretourneerd vanuit andere functies, worden opgeslagen in lijsten of dictaten en worden doorgegeven als parameters voor andere functies. Denk bijvoorbeeld aan de map() ingebouwde functie. De syntaxis is map(function, iterable) en het wordt gebruikt om handig toe te passen function aan elk element van iterable.

map() geeft eigenlijk een terug iterator voorwerp. In de praktijk casten we het resultaat als een list, tuple, set, dict, enz., wat het handigst is.
​
Stel dat u elke term van een lijst wilt kwadrateren met behulp van de map() functie. Om dat te doen, definiëren we a square() functie en gebruik het als parameter voor map():

my_list = [1,2,3,4,5]
def square(x):
    return x**2

my_modified_list = list(map(square, my_list))
print(my_modified_list)

[1, 4, 9, 16, 25]

​
Echter, als het enige gebruik van onze square() functie is om deze lijst te maken, het is schoner om een lambda functie:

my_list = [1,2,3,4,5]
my_modified_list = list(map(lambda x: x**2, my_list))
print(my_modified_list)

[1, 4, 9, 16, 25]

Python, lambda functies zijn anonieme functies die hun naam en syntaxis ontlenen aan die van Alonzo Church Lambda-calculus. Hun syntaxis is:

lambda x_1,..., x_n : expression(x_1, ..., x_n)

Dit creëert een anonieme functie die als invoer de variabelen ontvangt x_1, ..., x_n en retourneert de geëvalueerde expression(x_1, ..., x_n).
​
Het doel van lambda functies moet worden gebruikt als parameter voor functies die functies als parameter accepteren, zoals we deden met map() boven. Met Python kun je een lambda functie naar een variabele, maar de PEP 8-stijlgids raadt het af. Als u een eenvoudige functie aan een variabele wilt toekennen, kunt u dit beter doen als een eenregelige definitie. Dit zorgt ervoor dat het resulterende object de juiste naam krijgt, waardoor de leesbaarheid van de traceback wordt verbeterd:

anonymous_square = lambda x : x**2
​
def named_square(x): return x**2
​
print(anonymous_square.__name__)
print(named_square.__name__)


a = anonymous_square
b = named_square
print(a.__name__)
print(b.__name__)

Waarom Lambda-functies gebruiken?

Na de laatste alinea vraag je je misschien af ​​waarom je een lambda functie. Immers, alles wat kan worden gedaan met een lambda functie kan worden gedaan met een benoemde functie.
​
Het antwoord hierop is dat lambda functie doel is leven in grotere uitdrukkingen die een berekening vertegenwoordigen. Een manier om hierover na te denken is naar analogie met variabelen en waarden. Beschouw de volgende code:

x = 2

De variabele x is een tijdelijke aanduiding (of een naam) voor het gehele getal 2. Bellen bijvoorbeeld print(x) en print(2) geeft exact dezelfde output. In het geval van functies:

def square(x): return x**2

De functie square() is een tijdelijke aanduiding voor de berekening van het kwadrateren van een getal. Deze berekening kan naamloos worden geschreven als lambda x: x**2.
​
Laten we na deze filosofische uitweiding enkele voorbeelden bekijken van toepassingen voor lambda functies.
​

Lambda gebruiken met de functie Sorted().

De sorted() functie sorteert een iterable. Het accepteert een functie als zijn key argument, en het resultaat van de functie toegepast op elk element van de iterable wordt gebruikt om de elementen te ordenen.
​
Dit is perfect geschikt voor een lambda functie: door het instellen van de key parameter met a lambda functie kunnen we sorteren op elk type attribuut van de elementen. We kunnen bijvoorbeeld een lijst met namen sorteren op achternaam:

name_list = ['Grace Hopper', 'Ada Lovelace', 'Emmy Noether', 'Marie Curie']
​
sorted_by_surname = sorted(name_list, key = lambda x: x.split()[1])
​
print(sorted_by_surname)

['Marie Curie', 'Grace Hopper', 'Ada Lovelace', 'Emmy Noether']

Lambda gebruiken met de functie 'filter()'

De filter() functie heeft de volgende syntaxis: filter(function, iterable) en het voert de elementen van uit iterable die evalueren function(element) als waar (het is vergelijkbaar met een WHERE clausule in SQL). We kunnen gebruiken lambda functies als parameters voor filter() om elementen uit een iterable te selecteren.

Overweeg het volgende voorbeeld:

num_list = list(range(0,100))
​
multiples_of_15= filter(lambda x: (x % 3 == 0) and (x % 5 == 0), num_list)
​
print(list(multiples_of_15))

[0, 15, 30, 45, 60, 75, 90]

filter() past de lambda functie lambda x: (x % 3 == 0) and (x % 5 == 0) naar elk element van range(0,100), en retourneert een filter voorwerp. We krijgen toegang tot de elementen door het te casten als list.
​

Lambda gebruiken met de map()-functie

​
Ons laatste voorbeeld is iets dat we in de inleiding hebben gezien - de map() functie. De map() syntaxis van de functie is: map(function, iterable) en map() geldt function naar elk element van iterable, terug a map object dat toegankelijk is door te casten naar een list.

We hebben gezien hoe dit kan worden toegepast op lijsten, maar het kan ook worden toegepast op dictaten met behulp van de dict.items() methode:

my_data = {'Mary':1, 'Alice':2, 'Bob':0}
map_obj = map(lambda x: f'{x[0]} had {x[1]} little lamb', my_data.items())
print(', '.join((map_obj)))

Mary had 1 little lamb, Alice had 2 little lamb, Bob had 0 little lamb

of naar een string:

my_string = 'abcdefg'
''.join(map(lambda x: chr(ord(x)+2),my_string))

'cdefghi'

We kunnen gebruik maken map() op ingenieuze manieren functioneren – een voorbeeld is het toepassen van veel functies op dezelfde invoer.

Stel dat u een API maakt die een tekenreeks ontvangt en dat u er een lijst met functies op wilt toepassen.

Elke functie extraheert een kenmerk uit de tekst. De kenmerken die we willen extraheren zijn het aantal woorden, het tweede woord en de vierde letter van het vierde woord:

def number_of_words(text):
  return len(text.split())
​
def second_word(text):
  return text.split()[1]
​
def fourth_letter_of_fourth_word(text):
  return text.split()[3][3]
​
function_list = [number_of_words, second_word, fourth_letter_of_fourth_word]
​
my_text = 'Mary had a little lamb'
map_obj = map(lambda f: f(my_text), function_list)
​
feature_list = list(map_obj)
​
print(feature_list)

[5, 'had', 't']

​

Conclusie

​
In deze handleiding hebben we de functionaliteit van onderzocht lambda functies in Python. Dat hebben we gezien lambda functies zijn anonieme functies die kunnen worden gebruikt als een inline functieparameter voor andere functies. We hebben enkele use-cases gezien en ook wanneer ze niet moeten worden gebruikt.
​
Bij het programmeren is het belangrijk om het citaat van Donald Knuth in gedachten te houden: "Programma's zijn bedoeld om door mensen gelezen te worden en slechts incidenteel door computers om uitgevoerd te worden." Met dit in gedachten, lambda functies zijn een handig hulpmiddel om onze code te vereenvoudigen, maar moeten verstandig worden gebruikt.