Forberedelse til kodeinterviews · Lektion

Funktioner, closures og lambda

Definer genanvendelige hjælpefunktioner, brug standardargumenter, og anvend lambda-udtryk til sortering og funktionelle mønstre i interviewopgaver.

Lektion 4 af 413 trin

Funktioner, closures og lambda er en gratis Forberedelse til kodeinterviews-lektion på CoddyKit. Dette er lektion 4 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Forberedelse til kodeinterviews, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Forberedelse til kodeinterviews-kurset indeholder 4 lektioner i alt.

Definition af funktioner i Python

Funktioner er førsteklasses i Python: Du kan sende dem rundt, returnere dem og gemme dem. Velnavngivne hjælpefunktioner gør interviewkode let at læse. Håndter kanttilfælde 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

Standard- og nøgleordsargumenter

Standardværdier gør, at kaldende kode kan udelade argumenter. Men brug aldrig en foranderlig standardværdi som en liste – alle kaldere deler den. Løsningen er at bruge None som standard og oprette listen indeni. 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 og **kwargs

*args samler ekstra positionsargumenter i en tuple, mens **kwargs samler ekstra nøgleordsargumenter i en dict. * pakker også en sekvens ud, når du kalder 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!

Lambdaudtryk

En lambda er en lille funktion på én linje: lambda params: expression. Den er perfekt som en hurtig key i sorted eller max. Til alt større er en navngivet def tydeligere.

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

Indlejrede funktioner og closures

En closure er en funktion, der husker variabler fra funktionen omkring sig. Definér en hjælpefunktion inde i en anden funktion, så kan den bruge de ydre variabler – praktisk til 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

Et almindeligt mønster er at definere en dfs-hjælpefunktion inde i hovedfunktionen og lade den samle resultater i en ydre variabel. Den indre funktion er en closure over det omgivende omfang.

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 til memoisering

lru_cache (eller @cache i 3.9+) husker en funktions resultater ud fra dens argumenter og forvandler naiv Fibonacci fra O(2^n) til O(n). Argumenterne skal være hashbare, så brug 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, size

Funktioner af højere orden

En funktion af højere orden tager en funktion som argument eller returnerer en funktion. sorted, map og filter hører alle til denne kategori. Når du skriver dine egne, kan du abstrahere gentagne mønstre. Koden viser 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ælpefunktioner

Mange løsninger kombinerer en ydre funktion, der håndterer opsætning og kanttilfælde, med en indre hjælpefunktion, der udfører rekursionen. Ren offentlig grænseflade, isoleret 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]

Partielle funktioner med functools.partial

functools.partial udfylder nogle argumenter på forhånd og returnerer en ny kaldbar funktion. Det er nyttigt, når en grænseflade forventer en funktion uden argumenter, men du har brug for ét fast parametersæt.

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 til tilpassede sammenligninger

Python 3 fjernede sammenligningsfunktioner med to argumenter, men cmp_to_key giver dig dem tilbage til vanskelige sorteringsordener – for eksempel at arrangere tal, så deres sammenkædning bliver 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'

Hurtig kontrol

Hurtig kontrol – vis, hvad du har lært om funktioner, closures og lambdaer. Træk vejret, og gå i gang. 🚀

Besvar den i den interaktive lektion

Opsummering af lektionen

Opsummering: brug aldrig foranderlige standardværdier (brug None), closures lader indre hjælpefunktioner få adgang til ydre variabler i DFS, og functools-værktøjer som lru_cache driver hurtige løsninger.

Gratis at komme i gang

Lær Forberedelse til kodeinterviews med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 90
Lektioner: 360

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Funktioner, closures og lambda” gratis?

Ja — hele teksten til “Funktioner, closures og lambda” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Forberedelse til kodeinterviews-kurset, skal du opgradere til CoddyKit PRO. Forberedelse til kodeinterviews-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Funktioner, closures og lambda”?

Definer genanvendelige hjælpefunktioner, brug standardargumenter, og anvend lambda-udtryk til sortering og funktionelle mønstre i interviewopgaver. Du øver dig i Forberedelse til kodeinterviews med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Forberedelse til kodeinterviews?

Der kræves ingen tidligere erfaring. Forberedelse til kodeinterviews på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 4 af 4.

Hvor lang tid tager lektionen “Funktioner, closures og lambda”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Forberedelse til kodeinterviews-lektion?

Ja. Alle Forberedelse til kodeinterviews-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

← Tilbage til Forberedelse til kodeinterviews