DSA Interview Prep · Lektion

Funktioner, closures och lambda

Definiera återanvändbara hjälpfunktioner, använd standardargument och tillämpa lambda-uttryck på sortering och funktionella mönster i intervjuproblem.

Lektion 4 av 413 steg

Funktioner, closures och lambda är en gratis lektion i DSA Interview Prep på CoddyKit. Detta är lektion 4 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för DSA Interview Prep, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i DSA Interview Prep innehåller totalt 4 lektioner.

Definiera funktioner i Python

Funktioner är förstaklassobjekt i Python: ni kan skicka runt dem, returnera dem och lagra dem. Hjälpfunktioner med bra namn gör intervjukod lättläst. Hantera specialfall först.

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'))  # True

Standardargument och nyckelordsargument

Standardvärden gör att anropare kan utelämna argument. Men använd aldrig ett muterbart standardvärde som en lista – alla anropare delar på det. Lösningen är att använda None som standard och skapa listan inuti funktionen. Se koden.

# 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 och **kwargs

*args samlar extra positionsargument i en tupel, medan **kwargs samlar extra nyckelordsargument i en dict. * packar också upp en sekvens när ni anropar en funktion.

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

En lambda är en liten funktion på en enda rad: lambda params: expression. Perfekt som en snabb key i sorted eller max. För allt större blir en namngiven def tydligare.

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

Kapslade funktioner och closures

En closure är en funktion som kommer ihåg variabler från funktionen runt omkring. Definiera en hjälpfunktion inuti en annan funktion, så kan den använda de yttre variablerna – praktiskt för 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 increment

Closures i rekursiv DFS

Ett vanligt mönster är att definiera en dfs-hjälpfunktion inuti huvudfunktionen och låta den samla resultat i en yttre variabel. Den inre funktionen är en closure över det yttre scopet.

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 för memoisering

lru_cache (eller @cache i 3.9+) kommer ihåg en funktions resultat utifrån dess argument och omvandlar naiv Fibonacci från O(2^n) till O(n). Argumenten måste vara hashbara, så använd tupler.

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, size

Funktioner av högre ordning

En funktion av högre ordning tar emot eller returnerar en funktion. sorted, map och filter räknas alla hit. Genom att skriva egna kan ni abstrahera återkommande mönster. Koden visar komposition.

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)

Rekursion med hjälpfunktioner

Många lösningar kombinerar en yttre funktion som hanterar initiering och specialfall med en inre helper som utför rekursionen. Ett rent publikt API och isolerad logik. Se koden.

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]

Partiella funktioner med functools.partial

functools.partial fyller i vissa argument på förhand och lämnar tillbaka ett nytt anropsbart objekt. Det är användbart när ett API vill ha en funktion utan argument, men ni behöver ange ett fast parametervärde.

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 för anpassade jämförelsefunktioner

Python 3 tog bort jämförelsefunktioner med två argument, men cmp_to_key tar tillbaka dem för komplicerade ordningar – till exempel när tal ska ordnas så att deras sammanfogning blir störst. Se koden.

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'

Snabbtest

Snabbtest – dags att visa vad ni har lärt er om funktioner, closures och lambdas. Ta ett andetag och kör. 🚀

Besvara frågan i den interaktiva lektionen

Sammanfattning av lektionen

Sammanfattning: använd aldrig muterbara standardvärden (använd None), closures låter inre hjälpfunktioner nå yttre variabler vid DFS och verktyg i functools, som lru_cache, möjliggör snabba lösningar.

Gratis att börja

Lär dig Python med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 30
Lektioner: 120

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Funktioner, closures och lambda” gratis?

Ja – hela texten till ”Funktioner, closures och lambda” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i DSA Interview Prep, kan Ni uppgradera till CoddyKit PRO. Kursen i DSA Interview Prep innehåller totalt 4 lektioner.

Vad lär jag mig i ”Funktioner, closures och lambda”?

Definiera återanvändbara hjälpfunktioner, använd standardargument och tillämpa lambda-uttryck på sortering och funktionella mönster i intervjuproblem. Ni övar på DSA Interview Prep med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig DSA Interview Prep?

Du behöver inga förkunskaper. Utbildningen i DSA Interview Prep på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 4 av 4.

Hur lång tid tar lektionen ”Funktioner, closures och lambda”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här DSA Interview Prep-lektionen?

Ja. Varje DSA Interview Prep-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till DSA Interview Prep