Python Lambda

Was ist eine Lambda-Funktion?

Eine Lambda-Funktion ist eine kleine, anonyme Funktion, die mit dem Schlüsselwort lambda statt mit def definiert wird. Anonym bedeutet, dass sie keinen Namen trägt — obwohl man ihr eine Variable zuweisen kann, wenn man sie wiederverwenden möchte. Lambda-Funktionen sind eine kompakte Möglichkeit, einfache Einzeilfunktionen inline zu schreiben, ohne den Aufwand einer vollständigen Funktionsdefinition.

Lambda-Funktionen sind besonders nützlich als kurzlebige Callbacks, die an Higher-Order-Funktionen wie map(), filter() und sorted() übergeben werden.

Syntax

lambda arguments: expression

• arguments — null oder mehr kommagetrennte Parameter (wie die Parameterliste einer def-Funktion, einschließlich Standardwerte).
• expression — ein einzelner Ausdruck, dessen Wert automatisch zurückgegeben wird. Anweisungen (wie if/else-Blöcke, for-Schleifen oder return) sind im Lambda-Körper nicht erlaubt.

Ein direkter Vergleich nebeneinander:

def square(x):
    return x ** 2

square_lambda = lambda x: x ** 2

print(square(5))        # Output: 25
print(square_lambda(5)) # Output: 25

Grundlegende Beispiele

# No arguments
greet = lambda: "Hello, World!"
print(greet())  # Output: Hello, World!

# One argument
square = lambda x: x ** 2
print(square(5))  # Output: 25

# Two arguments
add = lambda x, y: x + y
print(add(10, 20))  # Output: 30

# Default argument value
greet_name = lambda name="World": "Hello, " + name + "!"
print(greet_name())          # Output: Hello, World!
print(greet_name("Alice"))   # Output: Hello, Alice!

Bedingte Logik in einem Lambda

Da Lambdas ein einziger Ausdruck sein müssen, können Sie keine if/else-Anweisung verwenden. Sie können jedoch einen ternären (bedingten) Ausdruck nutzen:

classify = lambda n: "positive" if n > 0 else ("zero" if n == 0 else "negative")

print(classify(5))   # Output: positive
print(classify(0))   # Output: zero
print(classify(-3))  # Output: negative

Tief verschachtelte ternäre Ausdrücke beeinträchtigen die Lesbarkeit schnell — wechseln Sie zu einer regulären def-Funktion, sobald die Logik komplexer wird.

Lambda mit map() verwenden

map(function, iterable) wendet eine Funktion auf jedes Element eines Iterables an und gibt ein map-Objekt zurück. Lambda eignet sich hervorragend als Funktionsargument.

nums = [1, 2, 3, 4, 5]
doubled = list(map(lambda x: x * 2, nums))
print(doubled)  # Output: [2, 4, 6, 8, 10]

Die entsprechende List Comprehension wird aus Gründen der Lesbarkeit oft bevorzugt:

doubled = [x * 2 for x in nums]  # same result

Mehr dazu unter List Comprehension.

Lambda mit filter() verwenden

filter(function, iterable) behält nur die Elemente, für die die Funktion True zurückgibt.

nums = [1, 2, 3, 4, 5]
evens = list(filter(lambda x: x % 2 == 0, nums))
print(evens)  # Output: [2, 4]

Lambda mit sorted() verwenden

Der Parameter key von sorted() (und list.sort()) akzeptiert einen Callable, der für jedes Element den Vergleichswert zurückgibt. Lambda ermöglicht kompakte, einmalige Sortierschlüssel.

# Sort strings by length
words = ["banana", "apple", "cherry", "date"]
by_length = sorted(words, key=lambda s: len(s))
print(by_length)  # Output: ['date', 'apple', 'banana', 'cherry']

# Sort a list of tuples by the second element
pairs = [(1, "b"), (2, "a"), (3, "c")]
by_second = sorted(pairs, key=lambda p: p[1])
print(by_second)  # Output: [(2, 'a'), (1, 'b'), (3, 'c')]

Mehr zum Sortieren von Listen finden Sie unter Sort Lists.

Sofort aufgerufenes Lambda

Ein Lambda kann direkt nach seiner Definition aufgerufen werden, indem es in Klammern gesetzt und die Argumente angehängt werden:

result = (lambda x, y: x + y)(3, 7)
print(result)  # Output: 10

Dieses Muster ist in Produktionscode unüblich, kann aber in einmaligen Skripten oder schnellen Tests nützlich sein.

Lambda in einer Datenstruktur gespeichert

Da ein Lambda in Python ein Objekt erster Klasse ist, können Sie Lambdas in Listen oder Dictionaries speichern, um einfache Dispatch-Tabellen zu erstellen:

ops = {
    "add": lambda x, y: x + y,
    "sub": lambda x, y: x - y,
    "mul": lambda x, y: x * y,
}

print(ops["add"](3, 4))   # Output: 7
print(ops["sub"](10, 3))  # Output: 7
print(ops["mul"](2, 6))   # Output: 12

Lambda vs. def — Wann welches verwenden?

Der PEP 8 Style Guide empfiehlt, ein Lambda nicht einer Variablen zuzuweisen, wenn ein def klarer wäre. Bevorzugen Sie zum Beispiel def add(x, y): return x + y gegenüber add = lambda x, y: x + y, wenn die Funktion auf Modulebene liegt.

Wichtige Einschränkungen

• Nur ein einzelner Ausdruck. Keine Zuweisungen, Schleifen oder mehrzeilige Logik.
• Keine Anweisungen. print() ist ein Funktionsaufruf (gültig), aber assert, raise oder return sind Anweisungen und dürfen nicht im Lambda-Körper erscheinen.
• Keine Annotationen. Typhinweise (x: int) sind in Lambda-Parameterlisten nicht erlaubt.
• Schwieriger zu debuggen. Stack-Traces zeigen <lambda> statt eines aussagekräftigen Funktionsnamens.
• Kann nicht gepickelt werden. Standard-pickle kann Lambda-Objekte nicht serialisieren — relevant beim Einsatz von Multiprocessing.

Beziehung zu Closures und Dekoratoren

Wie eine reguläre Funktion, die mit def definiert wurde, schließt ein Lambda Variablen aus seinem umgebenden Gültigkeitsbereich ein:

def make_multiplier(n):
    return lambda x: x * n   # 'n' is captured from the enclosing scope

double = make_multiplier(2)
triple = make_multiplier(3)

print(double(5))  # Output: 10
print(triple(5))  # Output: 15

Einen tieferen Einblick in die Funktionsweise von Closures in Python finden Sie unter Python Closures. Lambda-Funktionen erscheinen auch häufig innerhalb von Python Decorators als leichtgewichtige Wrapper. Für einen vollständigen Überblick über Funktionsdefinitionen siehe Python Functions.

Übungen