Python-lambda’s: een beginnersgids

Lambda’s in Python zijn krachtige, beknopte tools om snel kleine, anonieme functies te maken. Ze zijn perfect om kortdurende taken te vereenvoudigen, code te stroomlijnen met higher-order-functies zoals map, filter of sorted, en om rommel te verminderen bij het definiëren van tijdelijke of eenmalige logica. Ze bieden ook een elegante oplossing om de leesbaarheid van code in eenvoudige scenario’s te verbeteren. In dit artikel bekijken we wat lambda’s zijn, hun kenmerken en hoe je ze effectief inzet.

In deze gids geven we een compleet overzicht van lambda-functies in Python, inclusief hun werking, syntaxis en hoe ze zich verhouden tot standaardfuncties, met eenvoudige voorbeelden om kernconcepten te illustreren. We verkennen veelvoorkomende use-cases, zoals het gebruik van lambda’s binnen functionele programmeerparadigma’s en hun efficiëntie ten opzichte van standaardfuncties. Praktische voorbeelden en best practices helpen je om lambda’s effectief op te nemen in je Python-programmeerwerk.

Wat is een lambda-functie in Python?

Lambda-functies verschillen op een paar belangrijke punten van standaard Python-functies. Het zijn anonieme expressies, wat betekent dat ze geen naam hebben tenzij je ze expliciet aan een variabele toewijst. Ze zijn ook beknopter en in één regel gedefinieerd zonder een return-statement. Dat maakt ze ideaal voor eenvoudige, eenmalige bewerkingen en voor gebruik als inline argument in higher-order-functies zoals map, filter en sorted.

Hier is een voorbeeld van een lambda-functie die twee getallen optelt:

fn = lambda x, y: x + y
print(fn)

# <function <lambda> at 0xe508b8>

Hoe lambda-functies werken

Hoe werkt deze lambda-functie? Om dat te begrijpen, vergelijken we haar met een standaard Python-functie.

# Example: add two numbers using standard Python function
def add_numbers(x, y):
    return x + y

Deze standaardfunctie is eenvoudig. Het sleutelwoord def definieert de functie, die twee argumenten x en y aanneemt. Ze berekent de som van x en y en geeft het resultaat terug.

Laten we nu zien hoe onze lambda-functie dezelfde taak uitvoert.

# Example: add two numbers using a lambda function
fn = lambda x, y: x + y
print(fn)

# <function <lambda> at 0xbfb968>

Het sleutelwoord lambda geeft aan dat we een lambda-functie definiëren, waardoor het sleutelwoord def overbodig is. Na lambda volgen de invoerargumenten x en y. Na de dubbele punt specificeer je de expressie waarvan het resultaat wordt geretourneerd, x + y.

Lambda-functies schrijven in Python: voorbeelden

Om de concepten die we tot nu toe hebben besproken in de vingers te krijgen, bekijken we een paar voorbeelden van hoe lambda’s in Python werken. 

Stapsgewijze gids voor het schrijven van lambda’s

Lambda’s zijn ideaal om korte, eenvoudige functies te maken zonder extra complexiteit. 

Stel dat je wilt controleren of een gegeven niet-nul geheel getal even is. Je zou een standaard Python-functie kunnen schrijven, maar dezelfde functionaliteit past in een compacte one-liner lambda die je aan een variabele toewijst: is_even = lambda x: x % 2 == 0. 

Hier neemt de lambda aan de rechterkant van de toewijzing een input x en retourneert True als x even is (dus als de rest bij deling door 2 gelijk is aan 0). 

Deze lambda wordt vervolgens toegewezen aan de variabele is_even, zodat je haar kunt aanroepen als een gewone functie. Bijvoorbeeld, is_even(5) (geeft False) en is_even(678432) (geeft True).

Lambda’s zijn ook handig voor het definiëren van eenvoudige formules. Om bijvoorbeeld Celsius naar Fahrenheit te converteren, kun je een lambda gebruiken: c_to_f = lambda c: (c * 9/5) + 32. Je roept de functie daarna aan zoals elke andere functie: c_to_f(0).

Veelvoorkomende use-cases voor lambda’s

Lambda’s worden vaak gebruikt in functioneel programmeren, vooral met functies als map() en filter(), die andere functies als argument nemen om elementen in een collectie te verwerken. Laten we bekijken hoe je een lambda gebruikt met filter(). Hier is een codefragment:

# Use filter with lambda function
numbers = [1, 2, 3, 4, 5, 6, 7, 8]
evens = filter(lambda x: x % 2 == 0, numbers)
print(list(evens))  # print the list of the filter object to see the result

# [2, 4, 6, 8]

In deze code beginnen we met het definiëren van een reeks numbers. Vervolgens maken we een lambda om te controleren of een getal even is. De functie filter past deze lambda toe op de set numbers. Daarna printen we de lijst met even getallen die door filter is gevonden.

Op dezelfde manier kunnen we map gebruiken om een lambda toe te passen op een collectie elementen. In het onderstaande voorbeeld berekenen we de lengtes van strings in een lijst door de functie len() op elk element te mappen.

# Use map with lambda function
fruits = ['apple', 'banana', 'cherry']
lengths = list(map(lambda x: len(x), fruits))
print(lengths)

# [5, 6, 6]

Lambda’s worden ook gebruikt met de functie sorted(), die de elementen van een collectie sorteert en een nieuwe collectie teruggeeft. In het volgende voorbeeld (zonder lambda) gebruiken we sorted() om een lijst met getallen te sorteren.

numbers = [1, 10, -1, 3, -10, 5]
sorted_stuff = sorted(numbers)
print(sorted_stuff)

# [-10, -1, 1, 3, 5, 10]

Stel dat we de lijst met getallen op absolute waarde willen sorteren. Hoe doen we dat? De functie sorted() heeft een argument key waarmee we de sorteervolgorde kunnen aanpassen door een lambda te geven.

# Sort according to absolute value
sorted_numbers_absolute = sorted(numbers, key=lambda x: abs(x))
print(sorted_numbers_absolute)

# [1, -1, 3, 5, 10, -10]

Een andere use-case voor sort() met een lambda is het sorteren van een lijst met tuples op basis van een specifiek element, bijvoorbeeld het tweede.

# Sort a list of tuples by the second element
data = [(1, 3), (2, 1), (4, 2)]
sorted_data = sorted(data, key=lambda x: x[1])
print(sorted_data)

# [(2, 1), (4, 2), (1, 3)]

In dit codefragment definiëren we data als een lijst met tuples. Daarna gebruiken we sorted() met de parameter key, waarbij een lambda het tweede element van elke tuple extraheert om op te sorteren.

Zijn lambda-functies sneller in Python?

In Python zijn lambda’s niet per se sneller dan standaardfuncties, omdat beide naar vergelijkbare bytecode worden gecompileerd. Ze kunnen echter de overhead iets verminderen in gevallen waarin een volledige functiedefinitie onnodige boilerplate zou toevoegen.

Hier zijn een paar testcases waarin lambda’s worden vergeleken met standaardfuncties. De code is uitgevoerd op mijn laptop, een MacBook Pro met een Apple M1 Pro-chip, 16 GB geheugen, met macOS Sequoia 15.2.

Lambda’s kun je inline gebruiken als anonieme functies wanneer je ze direct doorgeeft aan higher-order-functies zoals map(), filter() of sorted(). Zo voorkom je dat je een aparte benoemde functie moet definiëren en refereren, wat zowel boilerplate als opzoekoverhead vermindert.

import time

numbers = list(range(1, 1000000))

# Standard function
def double_standard(x):
    return x * 2

start = time.time()
map(double_standard, numbers)
print(time.time() - start)

# Lambda function
double_lambda = map(lambda x: x * 2, numbers)

start = time.time()
list(map(lambda x: x * 2, numbers))
print(time.time() - start)

# 3.504753112792969e-05
# 2.384185791015625e-05

Lambda’s zijn ideaal voor eenmalig of tijdelijk gebruik, omdat ze de noodzaak voor een formeel def-blok wegnemen en zo tijd en ruimte besparen. In het volgende codeblok vergelijken we de performance van een standaardfunctie met die van een lambda. We sorteren een dictionary met een miljoen elementen, waarbij de keys willekeurige tweeletterige codes zijn en de waarden willekeurige gehele getallen.

import random
import string

# Generate a dictionary with elements of the form 'XX': number.
NUMBER_ITEMS = 1000000
items = {
    ''.join(random.choices(string.ascii_uppercase, k=2)): random.randint(1, 100)
    for _ in range(NUMBER_ITEMS)
}

# Standard function (extra definition step)
def sort_standard(item):
    return item[1]

print('Standard')
start = time.time()
sorted_items_standard = sorted(items, key=sort_standard)
print(time.time() - start)
print(sorted_items_standard[:5])
print()

# Lambda function
print('Lambda')
start = time.time()
sorted_items_lambda = sorted(items, key=lambda x: x[1])
print(time.time() - start)
print(sorted_items_lambda[:5])
print()

# Standard
# 0.00011610984802246094
# ['OA', 'VA', 'XA', 'IA', 'BA']
# Lambda
# 0.00011014938354492188
# ['OA', 'VA', 'XA', 'IA', 'BA']

Python-lambda’s: voorbeelden en oefening

Laten we nog wat meer praktische voorbeelden doornemen om te laten zien hoe lambda’s in Python werken. 

Praktische voorbeelden

Lambda’s worden vaak gebruikt met ingebouwde Python-methoden. Laten we bijvoorbeeld reduce() gebruiken om een door de gebruiker gedefinieerde binaire functie cumulatief toe te passen op de items van een sequentie.

# Example: Use lambda function with built-in Python method reduce.
from functools import reduce

numbers = [5, -6, 2, 7]
total = reduce(lambda x, y: x + y, numbers)
print(f'The sum of the numbers is {total}.')

# The sum of the numbers is 8.

Net als filter() of map() hierboven past reduce() een functie toe, hier gegeven door een lambda, op een verzameling elementen.

Laten we nu een andere ingebouwde Python-functie bekijken, zip(). De functie zip koppelt overeenkomstige elementen uit meerdere lijsten aan elkaar tot tuples. Zo is het resultaat van zip(['a', 'b', 'c'], [1, 2, 3]) [('a', 1), ('b', 2), ('c', 3)].

# Example: Use lambda function with built-in Python method zip.
list1 = [1, 2, 3]
list2 = [4, 5, 6]

# Using zip and a lambda function to multiply corresponding elements
result = list(map(lambda x: x[0] * x[1], zip(list1, list2)))

print(f'The result of multiplying corresponding elements is {result}.')

# The result of multiplying corresponding elements is [4, 10, 18].

Deze code berekent het product van overeenkomstige elementen uit twee lijsten, list1 en list2. Hij gebruikt zip() om elementen te koppelen tot tuples, past vervolgens met map() een lambda toe om de gekoppelde elementen te vermenigvuldigen en zet het resultaat ten slotte om naar een lijst.

Praktijkvoorbeeld: datatransformatie

Stel, je runt een fruitkraam en wilt het totale verkoopbedrag per fruitsoort berekenen.

Eerst maken we wat verkooprecords aan. Daarna gebruiken we map() met een lambda om total_sales te berekenen door de prijs en hoeveelheid voor elk item in de dictionary sales_data te vermenigvuldigen. De syntaxis **record pakt de oorspronkelijke dictionary uit, zodat al zijn keys en waarden behouden blijven in de nieuwe dictionary. Tot slot printen we elk record van de getransformeerde data.

# Sample data: list of dictionaries representing sales records
sales_data = [
	{'fruit': 'peaches', 'price': 1.41, 'quantity': 3},
	{'fruit': 'pears', 'price': 1.21, 'quantity': 2},
	{'fruit': 'mangoes', 'price': 0.56, 'quantity': 3},
]

# Using a lambda function to calculate total sales for each record
transformed_data = list(
	map(
		lambda entry: {**entry, 'total_sales': round(entry['price'] * entry['quantity'], 2)},
		sales_data
	)
)

# Print the transformed data
for record in transformed_data:
	print(record)

# {'fruit': 'peaches', 'price': 1.41, 'quantity': 3, 'total_sales': 4.23}
# {'fruit': 'pears', 'price': 1.21, 'quantity': 2, 'total_sales': 2.42}
# {'fruit': 'mangoes', 'price': 0.56, 'quantity': 3, 'total_sales': 1.68}

Eenvoudige oefenopgaven met lambda’s

Wil je oefenen met lambda’s? Probeer dan deze opgaven.

• Gegeven een getal: bepaal het kwadraat.
• Gegeven twee getallen: bepaal het grootste.
• Gegeven een getal: controleer of het oneven is.
• Gegeven een lijst met positieve integers: filter alle oneven getallen eruit.
• Sorteer een lijst met 3-element-tuples op basis van hun derde element.
• Haal het domein uit een e-mailadres. Bijvoorbeeld: gegeven [email protected], haal example.com eruit.

Veelgemaakte fouten met lambda’s

Laten we enkele veelgemaakte fouten met lambda’s bekijken en hoe je ze oplost.

1. De eerste fout is een lambda gebruiken waar dat niet passend is. Onthoud dat lambda’s bedoeld zijn voor korte, eenvoudige taken, niet voor complexe logica. Het volgende codefragment is bijvoorbeeld geen ideale use-case voor een lambda.

# Complex logic in a lambda
result = lambda x: (x ** 2 + x - 1) / (x + 1 if x != -1 else 1)
print(result(5))  # Hard to understand

# 4.833333333333333

In dit geval kun je beter gewoon een standaard Python-functie gebruiken.

def complex_logic(x):
    if x == -1:
        return x ** 2 + x - 1
    return (x ** 2 + x - 1) / (x + 1)
print(complex_logic(5))

# 4.833333333333333

2. Een andere veelvoorkomende fout is de syntaxis verwarren. Als je bijvoorbeeld het sleutelwoord lambda vergeet, krijg je een fout. Een andere syntaxisfout is het weglaten van de invoerargument(en):

# Forgetting the required arguments
numbers = [1, 2, 3, 4]
squared = map(lambda: x ** 2, numbers)  # <-- Where is the input argument? Error: lambda missing argument

De oplossing is om het invoerargument op te nemen:

squared = map(lambda x: x ** 2, numbers)

Een goede manier om dit soort fouten te vangen, is tijdens het ontwikkelen informele, eenvoudige testcases op te nemen.

print(list(squared))

3. Nog een valkuil is geen logica opnemen voor randgevallen. In deze code gaat het bijvoorbeeld mis als y gelijk is aan 0. De oplossing is een eenvoudige if-verklaring om het probleemgeval af te vangen of de code in een exceptieblok te wikkelen.

# Dividing without handling zero
divide = lambda x, y: x / y

safe_divide = lambda x, y: x / y if y != 0 else "undefined"
print(safe_divide(5, 0))

# undefined

4. Een subtieler probleem is vergeten de iterator naar een lijst te converteren bij het tonen van de resultaten. De functie map() retourneert bijvoorbeeld een map-object, geen lijst. Zet het map-object om naar een list om de resultaten te zien.

# Forgetting to convert to a list
numbers = [1, 2, 3]
squared = map(lambda x: x ** 2, numbers)
print(squared)  # <-- squared is the map, not the result

# <map object at 0x106d2b0>

print(list(squared))  # list(squared) gives the result

# [1, 4, 9]

Python-lambda’s debuggen: strategieën

Hoe debuggen we lambda’s? Hier zijn enkele mogelijkheden.

• Breek de lambda op. Zet haar tijdelijk om naar een benoemde functie voor debugdoeleinden.
• Gebruik print-statements om tussenresultaten te tonen in higher-order-functies zoals map() of filter().
• Test randgevallen. Test met extreme, ongeldige of grenswaarden om mogelijke fouten te vinden.

Een handige truc om tussenstappen te printen is een print-statement in een tuple op te nemen naast het resultaat. De gewenste output kan dan aan de higher-order-functie worden doorgegeven door de tuple op index 1 te nemen. 

Hier is een voorbeeld:

numbers = [1, 2, 3, 4, 5]

# Lambda function with print to debug intermediate values
filtered_numbers = filter(lambda x: (print(f'Checking: {x} -> {x >= 3}'), x >= 3)[1], numbers)

# Converting filter object to list to force evaluation
print(list(filtered_numbers))

# Checking: 1 -> False
# Checking: 2 -> False
# Checking: 3 -> True
# Checking: 4 -> True
# Checking: 5 -> True
# [3, 4, 5]

In deze code wordt een truc gebruikt om tussenstappen te printen tijdens het filteren van een lijst met getallen. De lambda in filter bevat een tuple: het eerste element is een print-statement dat het huidige getal logt en of het aan de voorwaarde voldoet (x >= 3), en het tweede element is de voorwaarde zelf. 

De [1] aan het einde van de lambda zorgt ervoor dat de voorwaarde (x >= 3) wordt geretourneerd aan de functie filter, terwijl het print-statement kan worden uitgevoerd voor debuggen. 

Door het filter-object naar een lijst te converteren, worden alle elementen geëvalueerd en worden de print-statements voor elk getal geactiveerd. Deze aanpak helpt om de logica te debuggen terwijl de filterbewerking intact blijft.

Best practices voor het gebruik van lambda’s

Best practices voor lambda’s draaien om begrijpen wanneer ze passend zijn en wanneer je ze beter kunt vermijden.

Wanneer lambda’s gebruiken

• Korte, eenvoudige logica. Ideaal voor beknopte operaties die geen volledige functiedefinitie vereisen.
• Higher-order-functies. Werken effectief als argument voor higher-order-functies zoals map(), filter() of sorted().
• Tijdelijke (wegwerp)functies. Handig wanneer een functie maar één keer nodig is en definiëren met def de code onnodig zou vervuilen.
• Betere leesbaarheid. Geschikt voor eenvoudige taken waarbij een lambda de code compact en goed te volgen houdt.

Wanneer lambda’s vermijden

• Complexe of meerregelige logica. Lambda’s zijn beperkt tot één expressie en worden snel onleesbaar bij ingewikkelder operaties.
• Herbruikbare of benoemde functies. Als de functie hergebruikt moet worden of baat heeft bij een beschrijvende naam, is een standaardfunctie met def geschikter.
• Debugging of documentatie. Lambda’s kunnen geen docstrings bevatten en zijn lastiger te debuggen dan benoemde functies.

Volg deze best practices om leesbaarheid en onderhoudbaarheid te vergroten wanneer je lambda’s gebruikt:

• Gebruik beschrijvende namen voor duidelijkheid.
• Houd het simpel: lambda’s horen idealiter op één regel te passen en rechttoe-rechtaan logica te bevatten.
• Beperk nesting: vermijd lambda’s binnen andere lambda’s of complexe datastructuren, tenzij noodzakelijk.
• Kies leesbaarheid boven beknoptheid: als een lambda de leesbaarheid schaadt, definieer dan liever een benoemde functie.

Conclusie

Python-lambda’s zijn een krachtig hulpmiddel om beknopte, anonieme functies te schrijven. Ze blinken uit in scenario’s die korte, tijdelijke of inline bewerkingen vereisen, vooral in combinatie met higher-order-functies zoals map, filter of sorted. 

Gebruik ze wel met beleid, want complexere logica is beter geschikt voor standaardfuncties gedefinieerd met def. Door hun sterke punten, beperkingen en best practices te begrijpen, kun je lambda’s effectief inzetten om schone, efficiënte en onderhoudbare Python-code te schrijven.

Wil je meer leren over Python-functies? Bekijk de bronnen van DataCamp.

• Python-functies: functies aanroepen & schrijven
• Cursus Writing Functions in Python
• Python Data Fundamentals
• Python Programming Fundamentals
• Cursus Intermediate Python for Developers