DSA Interview Prep · Lektion

Funktionen, Closures und Lambda

Definieren Sie wiederverwendbare Hilfsfunktionen, verwenden Sie Standardargumente und wenden Sie Lambda-Ausdrücke auf Sortierungen und funktionale Muster in Interviewaufgaben an.

Lektion 4 von 413 Schritte

Funktionen, Closures und Lambda ist eine kostenlose DSA Interview Prep-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des DSA Interview Prep-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der DSA Interview Prep-Kurs umfasst insgesamt 4 Lektionen.

Funktionen in Python definieren

Funktionen sind in Python first-class: Sie können sie weitergeben, zurückgeben und speichern. Aussagekräftig benannte Hilfsfunktionen machen Interview-Code lesbar. Behandeln Sie zuerst die Randfälle.

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- und Schlüsselwortargumente

Standardwerte ermöglichen es Aufrufern, Argumente wegzulassen. Verwenden Sie jedoch niemals einen veränderbaren Standardwert wie eine Liste – alle Aufrufer teilen sich diesen Wert. Die Lösung: Verwenden Sie None als Standardwert und erstellen Sie die Liste innerhalb der Funktion. Sehen Sie sich den Code an.

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

*args sammelt zusätzliche Positionsargumente in einem Tupel; **kwargs sammelt zusätzliche Schlüsselwortargumente in einem dict. Das * entpackt außerdem eine Sequenz, wenn Sie eine Funktion aufrufen.

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-Ausdrücke

Ein lambda ist eine kleine, einzeilige Funktion: lambda params: expression. Ideal als schnelles key-Argument für sorted oder max. Für alles Umfangreichere ist ein benanntes def übersichtlicher.

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

Verschachtelte Funktionen und Closures

Eine closure ist eine Funktion, die sich Variablen aus der sie umgebenden Funktion merkt. Definieren Sie eine Hilfsfunktion innerhalb einer anderen Funktion, kann sie die äußeren Variablen verwenden – praktisch 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 bei rekursivem DFS

Ein häufig verwendetes Muster: Definieren Sie eine dfs-Hilfsfunktion innerhalb der Hauptfunktion und lassen Sie sie Ergebnisse in einer äußeren Variable sammeln. Die innere Funktion bildet eine Closure über diesen Gültigkeitsbereich.

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 Memoisation

lru_cache (oder @cache ab 3.9) merkt sich die Ergebnisse einer Funktion anhand ihrer Argumente und macht aus dem naiven Fibonacci-Algorithmus mit O(2^n) einen mit O(n). Die Argumente müssen hashbar sein, verwenden Sie daher Tupel.

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

Funktionen höherer Ordnung

Eine Funktion höherer Ordnung nimmt eine Funktion entgegen oder gibt eine Funktion zurück. sorted, map und filter gehören alle dazu. Wenn Sie eigene solche Funktionen schreiben, können Sie wiederkehrende Muster abstrahieren. Der Code zeigt die 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 mit Hilfsfunktionen

Viele Lösungen kombinieren eine äußere Funktion, die Einrichtung und Randfälle behandelt, mit einer inneren helper-Funktion, die die Rekursion ausführt. Eine saubere öffentliche API und isolierte Logik. Sehen Sie sich den Code an.

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 Funktionen mit functools.partial

functools.partial füllt einige Argumente vorab aus und gibt ein neues aufrufbares Objekt zurück. Nützlich, wenn eine API eine Funktion ohne Argumente erwartet, Sie aber einen festen Parameter vorgeben müssen.

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 benutzerdefinierte Vergleiche

Python 3 hat Vergleiche mit zwei Argumenten entfernt, aber cmp_to_key stellt sie für anspruchsvolle Sortierreihenfolgen wieder bereit – etwa um Zahlen so anzuordnen, dass ihre Verkettung möglichst groß ist. Sehen Sie sich den Code an.

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'

Kurzer Test

Kurzer Test – zeigen Sie, was Sie über Funktionen, Closures und Lambdas gelernt haben. Atmen Sie kurz durch und legen Sie los. 🚀

Beantworte es in der interaktiven Lektion

Zusammenfassung der Lektion

Zusammenfassung: Verwenden Sie niemals veränderbare Standardwerte (verwenden Sie None), mit Closures können innere Hilfsfunktionen für DFS auf äußere Variablen zugreifen, und functools-Werkzeuge wie lru_cache ermöglichen schnelle Lösungen.

Kostenlos starten

Lerne Python mit einem KI-Tutor — kostenlos

Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.

Kurse: 30
Lektionen: 120

Kostenlos lernen Den vollständigen Kurs ansehen

Häufig gestellte Fragen

Ist die Lektion „Funktionen, Closures und Lambda“ kostenlos?

Ja — der vollständige Text von „Funktionen, Closures und Lambda“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des DSA Interview Prep-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der DSA Interview Prep-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Funktionen, Closures und Lambda“?

Definieren Sie wiederverwendbare Hilfsfunktionen, verwenden Sie Standardargumente und wenden Sie Lambda-Ausdrücke auf Sortierungen und funktionale Muster in Interviewaufgaben an. Du übst DSA Interview Prep mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um DSA Interview Prep zu starten?

Keine Vorkenntnisse erforderlich. DSA Interview Prep auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Funktionen, Closures und Lambda“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser DSA Interview Prep-Lektion Code schreiben und ausführen?

Ja. Jede DSA Interview Prep-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu DSA Interview Prep