Sie müssen Produkte nach Preis sortieren. Das Schreiben einer separaten benannten Funktion, nur um „den Preis verwenden“ zu sagen, fühlt sich wie eine Menge Zeremonie an. Python-Lambda-Funktionen ermöglichen es Ihnen, dieses kleine Stück Logik inline zu definieren, genau dort, wo Sie es verwenden.

Lambdas sind praktisch, können aber auch leicht überbeansprucht werden. Dieser Leitfaden zeigt, wo sie wirklich helfen und wo sie die Lesbarkeit des Codes erschweren. Wir haben jedes Beispiel auf Python 3.13 ausgeführt und die angezeigte Ausgabe stammt von diesem Lauf.

Was ist ein Lambda?

Ein Lambda ist eine Funktion ohne Namen, geschrieben mit dem Schlüsselwort lambda:

lambda arguments: expression

Es akzeptiert eine beliebige Anzahl von Argumenten und gibt automatisch den Wert eines einzelnen Ausdrucks zurück. Es gibt kein Schlüsselwort return und keinen Anweisungskörper.

square = lambda x: x * x
print(square(4))                     # 16

print((lambda a, b=10: a + b)(5))    # 15

Die zweite Zeile definiert ein Lambda mit einem Standardargument und ruft es sofort auf. Sie würden dies selten in echtem Code schreiben, aber es zeigt, dass ein Lambda ein gewöhnliches Funktionsobjekt ist.

Lambda vs. Def

Diese beiden erzeugen Funktionen, die sich gleich verhalten:

square = lambda x: x * x

def square_def(x):
    return x * x

print(square(4), square_def(4))                 # 16 16
print(square.__name__, square_def.__name__)     # <lambda> square_def

Schauen Sie sich die Namen an. Jedes Lambda heißt einfach <lambda>, daher können Fehlermeldungen und Protokolle Ihnen nicht sagen, welches fehlgeschlagen ist. Dies ist der Hauptgrund dafür, dass Styleguides wie PEP 8 eine def empfehlen, wenn Sie einer Funktion einen Namen geben möchten.

Sortieren mit Schlüssel: die beste Verwendung

Funktionen wie sorted, min und max akzeptieren eine key-Funktion, die entscheidet, was verglichen werden soll. Hier glänzen Lambdas:

products = [("pen", 10), ("bag", 900), ("book", 250)]

sorted(products, key=lambda p: p[1])
# [('pen', 10), ('book', 250), ('bag', 900)]

max(products, key=lambda p: p[1])
# ('bag', 900)

Um nach mehreren Dingen zu sortieren, geben Sie ein Tupel zurück. Hier werden die Personen nach Alter sortiert, zuerst nach den Ältesten und dann nach Namen:

people = [{"name": "Asha", "age": 31}, {"name": "Ben", "age": 25},
          {"name": "Dev", "age": 31}]

[p["name"] for p in sorted(people, key=lambda p: (-p["age"], p["name"]))]
# ['Asha', 'Dev', 'Ben']

Das Minuszeichen kehrt die Reihenfolge nur für die Nummer um. Manchmal braucht man überhaupt kein Lambda, weil eine vorhandene Funktion den Job bereits erledigt. Vergleichen Sie die Standardsortierung mit einer Sortierung ohne Berücksichtigung der Groß- und Kleinschreibung:

names = ["Asha", "ben", "Chitra", "dev"]

sorted(names)                  # ['Asha', 'Chitra', 'ben', 'dev']
sorted(names, key=str.lower)   # ['Asha', 'ben', 'Chitra', 'dev']

Standardmäßig stehen alle großgeschriebenen Wörter an erster Stelle. Das Übergeben von str.lower behebt das Problem ohne Lambda. Das Modul operator bietet ähnliche Helfer, etwa itemgetter(1) für lambda p: p[1].

Karte und Filter

map wendet eine Funktion auf jedes Element an und filter behält die Elemente bei, für die es „true“ zurückgibt. Beide arbeiten mit Lambdas, vergleichen sie jedoch jeweils mit einem Listenverständnis:

nums = [1, 2, 3, 4, 5, 6]

list(map(lambda n: n * 10, nums))      # [10, 20, 30, 40, 50, 60]
[n * 10 for n in nums]                 # [10, 20, 30, 40, 50, 60]

list(filter(lambda n: n % 2 == 0, nums))   # [2, 4, 6]
[n for n in nums if n % 2 == 0]            # [2, 4, 6]

Die Ergebnisse sind identisch und die meisten Python-Entwickler finden die Erläuterungen einfacher zu lesen. Beachten Sie auch, dass map und filter verzögerte Iteratoren zurückgeben, sodass Sie list() benötigen, um die Werte zu sehen. Unser Leitfaden zum Python-Listenverständnis behandelt diesen Stil ausführlich. map lässt sich immer noch gut mit einer vorhandenen benannten Funktion lesen, wie in map(str.strip, lines).

reduzieren

functools.reduce kombiniert Elemente zu einem einzigen Wert und liefert ein laufendes Ergebnis:

from functools import reduce

reduce(lambda acc, n: acc + n, nums, 0)   # 21
sum(nums)                                 # 21

Verwenden Sie für allgemeine Aufgaben wie Summen eine integrierte Funktion wie sum, max oder any. Behalten Sie reduce für seltenere Fälle bei und ziehen Sie eine einfache Schleife in Betracht, wenn das Lambda kompliziert aussieht.

Bedingungen in einem Lambda

Sie können in einem Lambda keine if-Anweisung verwenden, aber Sie können einen bedingten Ausdruck verwenden:

label = lambda total: "large" if total >= 1000 else "small"

label(1200), label(300)
# ('large', 'small')

Eine Bedingung ist in Ordnung. Sobald Sie mit der Verschachtelung beginnen, müssen die Leser hart arbeiten, was ein klares Zeichen dafür ist, zu einer def-Anweisung mit gewöhnlichen if-Anweisungen zu wechseln.

Lambdas, die Funktionen zurückgeben

Eine Funktion kann ein Lambda erstellen und zurückgeben, das sich einen Wert aus seiner Umgebung merkt:

def multiplier(n):
    return lambda x: x * n

double = multiplier(2)
double(7)   # 14

Dies funktioniert aufgrund von Abschlüssen, die unser Artikel über JavaScript-Abschlüsse in einer anderen Sprache erklärt. Pythons functools.partial bietet eine weitere Möglichkeit, Argumente vorab auszufüllen.

Die Late-Binding-Falle

Das erwischt irgendwann fast jeden. Wir haben drei Lambdas in einer Schleife erstellt und erwartet, dass jedes seine eigene Zahl zurückgibt:

funcs = [lambda: i for i in range(3)]
[f() for f in funcs]

# [2, 2, 2]

Alle drei geben 2 zurück. Ein Lambda erfasst nicht den Wert von i, wenn es erstellt wird. Es sucht nach der Variablen, wenn sie aufgerufen wird, und bis dahin ist die Schleife beendet, so dass i bei 2 bleibt. Die übliche Lösung besteht darin, den Wert als Standardargument zu erfassen, da Standardwerte zum Zeitpunkt der Definition ausgewertet werden:

funcs = [lambda i=i: i for i in range(3)]
[f() for f in funcs]

# [0, 1, 2]

Dies gilt nicht nur für Lambdas, da sich eine def innerhalb einer Schleife genauso verhält. Bei Lambdas tritt es einfach häufiger auf, weil sie so häufig in Schleifen erstellt werden, beispielsweise beim Anhängen von Schaltflächenrückrufen.

Nachschlagetabellen für kleine Funktionen

Lambdas passen perfekt in ein Wörterbuch, das Namen kleinen Operationen zuordnet:

ops = {
    "add": lambda a, b: a + b,
    "sub": lambda a, b: a - b,
}

ops["sub"](10, 3)   # 7

Dies kann eine lange Kette von if und elif ersetzen. Das Python-Wörterbuch-Handbuch deckt weitere Wörterbuchmuster ab, und das Modul operator bietet bereits operator.add und operator.sub.

Grenzen von Lambdas

• Nur ein Ausdruck. Keine Zuweisungen mit =, keine Schleifen und keine try Blöcke.
• Keine Aussagen. Das Schreiben von lambda x: return x schlägt mit einer SyntaxError fehl, wie unser Test bestätigte.
• Keine Dokumentzeichenfolge oder Typhinweise. Tools und Reader erhalten weniger Hilfe.
• Schwierigeres Debuggen. Fehler deuten auf <lambda> statt auf einen hilfreichen Namen.

Lambdas können natürlich immer noch Ausnahmen auslösen. Die Handhabung dieser funktioniert genauso wie bei jeder anderen Funktion, wie unter Python-Ausnahmebehandlung beschrieben.

Wann man kein Lambda verwenden sollte

Der letzte Punkt ist wichtig. Es lohnt sich, eine wiederzuverwendende Logik zu testen, und eine benannte Funktion ist weitaus einfacher zu testen, wie unser Pytest-Tutorial zeigt.

Fazit

Ein gutes Lambda ist kurz genug, um auf einen Blick gelesen zu werden, und wird einmal verwendet, normalerweise als Argument. Sortierschlüssel sind das klassische Beispiel. Um Ihren eigenen Code zu überprüfen, suchen Sie nach = lambda und wandeln Sie diese in benannte Funktionen um. Schauen Sie sich dann map oder filter mit einem Lambda an und prüfen Sie, ob sich ein Verständnis besser liest.

Häufige Fragen

Lerne weiter