Functies, closures en lambda
Definieer herbruikbare hulpfuncties, gebruik standaardargumenten en pas lambda-expressies toe bij sorteringen en functionele patronen in interviewopgaven.
Functies, closures en lambda is een gratis DSA Interview Prep-les op CoddyKit. Dit is les 4 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject DSA Interview Prep. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus DSA Interview Prep bevat in totaal 4 lessen.
Functies definiëren in Python
Functies zijn eersteklaswaarden in Python: je kunt ze doorgeven, teruggeven en opslaan. Goed benoemde hulpfuncties maken code voor sollicitatieopgaven leesbaar. Behandel randgevallen eerst.
def is_palindrome(s: str) -> bool:
'''Return True if s reads the same forwards and backwards.'''
s = s.lower()
return s == s[::-1]
print(is_palindrome('Racecar')) # True
print(is_palindrome('hello')) # False
# Functions as values
checks = [is_palindrome]
print(checks[0]('level')) # TrueStandaard- en sleutelwoordargumenten
Standaardwaarden zorgen ervoor dat aanroepers argumenten kunnen overslaan. Gebruik echter nooit een veranderlijke standaardwaarde zoals een lijst: alle aanroepers delen die. De oplossing is standaard None gebruiken en de lijst binnen de functie maken. Bekijk de code.
# WRONG: shared mutable default
def bad_append(val, lst=[]):
lst.append(val)
return lst
print(bad_append(1)) # [1]
print(bad_append(2)) # [1, 2] surprise!
# CORRECT: use None sentinel
def good_append(val, lst=None):
if lst is None:
lst = []
lst.append(val)
return lst
print(good_append(1)) # [1]
print(good_append(2)) # [2]*args en **kwargs
*args verzamelt extra positionele argumenten in een tuple; **kwargs verzamelt extra sleutelwoordargumenten in een dict. De * pakt bij het aanroepen van een functie ook een reeks uit.
def total(*args):
return sum(args)
print(total(1, 2, 3)) # 6
print(total(1, 2, 3, 4)) # 10
# Unpack a list as positional args
point = [3, 7]
print(max(*point)) # 7
# **kwargs
def greet(**kwargs):
name = kwargs.get('name', 'World')
return f'Hello, {name}!'
print(greet(name='Alice')) # Hello, Alice!Lambda-expressies
Een lambda is een kleine functie van één regel: lambda params: expression. Ideaal als snelle key in sorted of max. Voor iets groters leest een benoemde def duidelijker.
# Lambda as sort key
pairs = [(1, 3), (2, 1), (3, 2)]
sorted_by_second = sorted(pairs, key=lambda p: p[1])
print(sorted_by_second) # [(2,1),(3,2),(1,3)]
# Lambda with map
double = list(map(lambda n: n * 2, [1, 2, 3]))
print(double) # [2, 4, 6]
# Named function is clearer for complex logic
def sort_key(p):
return (p[1], -p[0]) # secondary sort
print(sorted(pairs, key=sort_key))Geneste functies en closures
Een closure is een functie die variabelen uit de omliggende functie onthoudt. Definieer een hulpfunctie binnen een andere functie en die kan de variabelen daarbuiten gebruiken, handig voor DFS.
def make_counter(start=0):
count = [start] # list to allow mutation
def increment():
count[0] += 1
return count[0]
return increment
counter = make_counter()
print(counter()) # 1
print(counter()) # 2
# Alternative: nonlocal keyword
def make_counter2():
count = 0
def increment():
nonlocal count
count += 1
return count
return incrementClosures in recursieve DFS
Een veelgebruikt patroon: definieer een dfs-hulpfunctie binnen de hoofdfunctie en laat die resultaten verzamelen in een variabele daarbuiten. De interne functie is een closure over dat bereik.
def max_depth(root):
'''Closure pattern for tree DFS.'''
max_d = [0] # mutable container for closure
def dfs(node, depth):
if node is None:
return
max_d[0] = max(max_d[0], depth)
dfs(node.left, depth + 1)
dfs(node.right, depth + 1)
dfs(root, 1)
return max_d[0]
# This pattern avoids a class or global state.functools.lru_cache voor memoisatie
lru_cache (of @cache in 3.9 en hoger) onthoudt de resultaten van een functie op basis van haar argumenten en verandert naïeve Fibonacci van O(2^n) in O(n). Argumenten moeten hashbaar zijn, dus gebruik tuples.
from functools import lru_cache
@lru_cache(maxsize=None)
def fib(n):
if n <= 1:
return n
return fib(n - 1) + fib(n - 2)
print(fib(40)) # 102334155 fast!
print(fib.cache_info()) # hits, misses, sizeFuncties van hogere orde
Een functie van hogere orde neemt een functie als argument of geeft er een terug. sorted, map en filter vallen daar allemaal onder. Met je eigen functies kun je terugkerende patronen abstraheren. De code toont compositie.
def apply_twice(f, x):
return f(f(x))
print(apply_twice(lambda n: n * 2, 3)) # 12 (3*2*2)
# Composing transformations
def compose(f, g):
return lambda x: f(g(x))
double = lambda n: n * 2
add_one = lambda n: n + 1
double_then_add = compose(add_one, double)
print(double_then_add(5)) # 11 ((5*2)+1)Recursie met hulpfuncties
Veel oplossingen combineren een buitenste functie die de voorbereiding en randgevallen afhandelt met een interne helper die de recursie uitvoert. Zo krijg je een nette openbare API en afgezonderde logica. Bekijk de code.
def flatten(nested):
'''Flatten an arbitrarily nested list.'''
result = []
def _flatten(lst):
for item in lst:
if isinstance(item, list):
_flatten(item)
else:
result.append(item)
_flatten(nested)
return result
print(flatten([1, [2, [3, 4], 5], 6]))
# [1, 2, 3, 4, 5, 6]Partiële functies met functools.partial
functools.partial vult enkele argumenten vooraf in en geeft een nieuw aanroepbaar object terug. Handig wanneer een API een functie zonder argumenten verwacht, maar je één vaste parameter wilt instellen.
from functools import partial
def power(base, exp):
return base ** exp
square = partial(power, exp=2)
cube = partial(power, exp=3)
print(square(5)) # 25
print(cube(3)) # 27
print(list(map(square, [1, 2, 3, 4]))) # [1, 4, 9, 16]Lambda voor aangepaste vergelijkingsfuncties
Python 3 liet vergelijkingsfuncties met twee argumenten vallen, maar cmp_to_key brengt ze terug voor lastige ordeningen, zoals getallen zo rangschikken dat hun aaneenschakeling het grootst is. Bekijk de code.
from functools import cmp_to_key
def largest_number(nums):
def compare(a, b):
if a + b > b + a: return -1
if a + b < b + a: return 1
return 0
strs = list(map(str, nums))
strs.sort(key=cmp_to_key(compare))
result = ''.join(strs)
return '0' if result[0] == '0' else result
print(largest_number([3, 30, 34, 5, 9])) # '9534330'Korte controle
Korte controle: laat zien wat je hebt geleerd over functies, closures en lambda's. Adem even rustig in en ga ervoor. 🚀
Samenvatting van de les
Samenvatting: gebruik nooit veranderlijke standaardwaarden (gebruik None), met closures kunnen interne hulpfuncties voor DFS variabelen daarbuiten bereiken en functies uit functools, zoals lru_cache, maken snelle oplossingen mogelijk.
Leer Python met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 30
- Lessen
- 120
Veelgestelde vragen
Is de les “Functies, closures en lambda” gratis?
Ja — de volledige tekst van “Functies, closures en lambda” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus DSA Interview Prep wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus DSA Interview Prep bevat in totaal 4 lessen.
Wat leer ik in “Functies, closures en lambda”?
Definieer herbruikbare hulpfuncties, gebruik standaardargumenten en pas lambda-expressies toe bij sorteringen en functionele patronen in interviewopgaven. Je oefent met DSA Interview Prep door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met DSA Interview Prep te beginnen?
Ervaring vooraf is niet nodig. DSA Interview Prep op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 4 van 4.
Hoe lang duurt de les “Functies, closures en lambda”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over DSA Interview Prep?
Ja. Elke les over DSA Interview Prep bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Lijsten, tuples en slicing
- Dictionaries en sets in Python
- Comprehensions en ingebouwde functies
- Functies, closures en lambda