Python Lambda-Funktionen: Ein klarer Leitfaden mit praktischen Beispielen

Name

Soren Atelier

Updated on 9.2.2026

Jedes Python-Projekt sammelt kleine Hilfsfunktionen an. Eine Funktion, die eine Zahl verdoppelt. Eine weitere, die Leerzeichen entfernt. Noch eine, die einen Nachnamen aus einem Dictionary extrahiert. Jede davon ist zwei oder drei Zeilen lang, wird genau einmal verwendet und überfüllt das Modul mit Namen, die Sie sich nie merken werden. Python Lambda-Funktionen lösen dieses Problem, indem Sie winzige Wegwerf-Funktionen genau dort definieren können, wo Sie sie brauchen -- kein def, kein Name, kein verschwendeter vertikaler Platz.

Dieser Leitfaden behandelt alles, was Sie über Python Lambda-Funktionen wissen müssen: die Syntax, die eingebauten Funktionen, mit denen sie zusammenarbeiten, praktische Muster für realen Code und die spezifischen Situationen, in denen Sie sie vermeiden sollten.

Was ist eine Lambda-Funktion?

Eine Lambda-Funktion ist eine anonyme Einzelausdruck-Funktion. "Anonym" bedeutet, dass sie keinen Namen hat. "Einzelausdruck" bedeutet, dass der Funktionskörper genau ein Ausdruck ist, dessen Ergebnis automatisch zurückgegeben wird. Python wertet diesen Ausdruck aus und gibt das Ergebnis zurück -- keine return-Anweisung erforderlich.

Der Begriff stammt aus dem Lambda-Kalkül, einem formalen System in der mathematischen Logik. Aber Sie müssen die Mathematik nicht verstehen. Im praktischen Python ist ein Lambda einfach eine kürzere Möglichkeit, eine kleine Funktion zu schreiben.

Hier ist eine reguläre Funktion und ihr Lambda-Äquivalent:

# Regular function
def double(x):
    return x * 2
 
print(double(5))
# 10
 
# Lambda equivalent
double_lambda = lambda x: x * 2
 
print(double_lambda(5))
# 10

Beide liefern das gleiche Ergebnis. Die Lambda-Version passt in eine Zeile und überspringt die Formalitäten von def und return.

Lambda-Syntax

Die Syntax für ein Python Lambda ist:

lambda arguments: expression

• lambda -- das Schlüsselwort, das eine anonyme Funktion signalisiert.
• arguments -- null oder mehr Parameter, durch Kommas getrennt. Keine Klammern erforderlich.
• expression -- ein einzelner Ausdruck, der ausgewertet und zurückgegeben wird. Keine Anweisungen (keine if-Blöcke, keine for-Schleifen, keine Zuweisungen mit =).

Ein paar schnelle Beispiele, um die Bandbreite zu zeigen:

# No arguments
greet = lambda: "Hello, world!"
print(greet())
# Hello, world!
 
# One argument
square = lambda x: x ** 2
print(square(9))
# 81
 
# Two arguments
add = lambda a, b: a + b
print(add(3, 7))
# 10
 
# Default argument
power = lambda base, exp=2: base ** exp
print(power(3))
# 9
print(power(3, 3))
# 27

Die wichtigste Einschränkung ist, dass der Körper ein einzelner Ausdruck sein muss. Sie können keine mehrzeilige Logik schreiben, keine if-Anweisungen verwenden (obwohl Sie bedingte Ausdrücke verwenden können) und keine Zuweisungen einschließen. Dies ist beabsichtigt -- Lambdas sind für einfache Operationen gedacht.

Lambda mit map() -- Listen transformieren

map() wendet eine Funktion auf jedes Element einer Iterable an und gibt einen Iterator zurück. Lambda-Funktionen sind der natürliche Begleiter für map(), da die Transformation oft einfach genug ist, um in einer Zeile ausgedrückt zu werden.

numbers = [1, 2, 3, 4, 5]
 
# Square each number
squared = list(map(lambda x: x ** 2, numbers))
print(squared)
# [1, 4, 9, 16, 25]
 
# Convert temperatures from Celsius to Fahrenheit
celsius = [0, 20, 37, 100]
fahrenheit = list(map(lambda c: round(c * 9/5 + 32, 1), celsius))
print(fahrenheit)
# [32.0, 68.0, 98.6, 212.0]
 
# Extract first names from full names
names = ["Ada Lovelace", "Grace Hopper", "Alan Turing"]
first_names = list(map(lambda name: name.split()[0], names))
print(first_names)
# ['Ada', 'Grace', 'Alan']

map() mit einem Lambda ist eine saubere Alternative zu einer List Comprehension, wenn die Mapping-Logik eine einfache einstufige Transformation ist. Für komplexere Transformationen sind List Comprehensions in der Regel besser lesbar.

Lambda mit filter() -- Elemente filtern

filter() nimmt eine Funktion und eine Iterable und gibt einen Iterator zurück, der nur die Elemente liefert, für die die Funktion True zurückgibt. Lambda-Funktionen machen es einfach, das Prädikat inline zu definieren.

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
 
# Keep only even numbers
evens = list(filter(lambda x: x % 2 == 0, numbers))
print(evens)
# [2, 4, 6, 8, 10]
 
# Keep strings longer than 4 characters
words = ["cat", "elephant", "dog", "butterfly", "ant"]
long_words = list(filter(lambda w: len(w) > 4, words))
print(long_words)
# ['elephant', 'butterfly']
 
# Filter out None values
data = [1, None, 3, None, 5, None, 7]
clean = list(filter(lambda x: x is not None, data))
print(clean)
# [1, 3, 5, 7]

Wie bei map() funktioniert die Kombination aus filter() und Lambda am besten für einfache Bedingungen. Wenn die Filterlogik mehrere Prüfungen umfasst, ist eine List Comprehension oder eine benannte Funktion normalerweise klarer.

Lambda mit sorted() und sort() -- Benutzerdefinierte Sortierschlüssel

Sortierung ist eine der häufigsten und praktischsten Verwendungen für Lambda-Funktionen. Die Funktion sorted() und die Methode .sort() akzeptieren beide einen key-Parameter -- eine Funktion, die einen Vergleichswert aus jedem Element extrahiert.

# Sort strings by length
fruits = ["banana", "kiwi", "strawberry", "fig", "apple"]
by_length = sorted(fruits, key=lambda s: len(s))
print(by_length)
# ['fig', 'kiwi', 'apple', 'banana', 'strawberry']
 
# Sort tuples by the second element
pairs = [(1, 'b'), (3, 'a'), (2, 'c')]
by_second = sorted(pairs, key=lambda pair: pair[1])
print(by_second)
# [(3, 'a'), (1, 'b'), (2, 'c')]
 
# Sort dictionaries by a specific key
students = [
    {"name": "Alice", "grade": 88},
    {"name": "Bob", "grade": 95},
    {"name": "Charlie", "grade": 72},
]
by_grade = sorted(students, key=lambda s: s["grade"], reverse=True)
for s in by_grade:
    print(f"{s['name']}: {s['grade']}")
# Bob: 95
# Alice: 88
# Charlie: 72

Sortierung mit Lambda ist so weit verbreitet, dass es zu einem idiomatischen Python-Muster geworden ist. Jedes Mal, wenn Sie komplexe Objekte nach einem bestimmten Attribut oder Feld sortieren müssen, ist eine Lambda-Schlüsselfunktion der Standardansatz.

Sortierung mit mehreren Kriterien

Sie können ein Tupel aus dem Lambda zurückgeben, um nach mehreren Feldern zu sortieren:

employees = [
    {"name": "Alice", "dept": "Engineering", "salary": 95000},
    {"name": "Bob", "dept": "Marketing", "salary": 72000},
    {"name": "Charlie", "dept": "Engineering", "salary": 88000},
    {"name": "Diana", "dept": "Marketing", "salary": 85000},
]
 
# Sort by department (ascending), then by salary (descending)
sorted_emp = sorted(employees, key=lambda e: (e["dept"], -e["salary"]))
for e in sorted_emp:
    print(f"{e['dept']:12s} {e['name']:8s} ${e['salary']:,}")
# Engineering  Alice    $95,000
# Engineering  Charlie  $88,000
# Marketing    Diana    $85,000
# Marketing    Bob      $72,000

Lambda mit reduce() aus functools

functools.reduce() wendet eine Funktion mit zwei Argumenten kumulativ auf die Elemente einer Iterable an und reduziert sie auf einen einzelnen Wert. Lambda-Funktionen passen natürlich zu reduce() für kompakte Aggregationen.

from functools import reduce
 
numbers = [1, 2, 3, 4, 5]
 
# Product of all numbers
product = reduce(lambda x, y: x * y, numbers)
print(product)
# 120
 
# Find the maximum value (for demonstration; use max() in practice)
largest = reduce(lambda a, b: a if a > b else b, numbers)
print(largest)
# 5
 
# Concatenate a list of strings
words = ["Python", " ", "lambda", " ", "functions"]
sentence = reduce(lambda a, b: a + b, words)
print(sentence)
# Python lambda functions
 
# Flatten a list of lists
nested = [[1, 2], [3, 4], [5, 6]]
flat = reduce(lambda acc, lst: acc + lst, nested)
print(flat)
# [1, 2, 3, 4, 5, 6]

Ein Wort der Vorsicht: reduce() kann die Absicht verschleiern. Für gängige Operationen wie Summierung verwenden Sie sum(). Zum Finden von Min/Max verwenden Sie min() und max(). Reservieren Sie reduce() mit Lambda für benutzerdefinierte Akkumulationen, für die kein eingebauter Befehl existiert.

Lambda vs def -- Wann welches verwenden

Dies ist die Frage, die in der Praxis am meisten zählt. Lambda und def erstellen beide Funktionsobjekte, aber sie dienen unterschiedlichen Zwecken.

Wann Lambda verwenden

• Sortierschlüssel: sorted(items, key=lambda x: x.name)
• Schnelle map/filter-Operationen: map(lambda x: x.strip(), lines)
• Callback-Argumente: Funktionen, die einen aufrufbaren Parameter akzeptieren
• Einfacher Dictionary- oder Tupel-Zugriff: key=lambda item: item[1]

Wann def verwenden

• Die Funktion hat mehr als einen Ausdruck
• Sie brauchen einen Docstring oder Type Hints
• Die Funktion wird von mehreren Stellen aufgerufen
• Die Logik erfordert Fehlerbehandlung oder Verzweigungen
• Sie brauchen einen aussagekräftigen Namen in Stack-Traces zum Debuggen

Faustregel: Wenn das Lambda nicht bequem in eine einzelne Zeile passt oder Sie es zweimal lesen müssen, um zu verstehen, was es tut, verwenden Sie stattdessen def.

Lambda mit mehreren Argumenten

Lambda-Funktionen können beliebig viele Argumente akzeptieren, einschließlich *args und **kwargs:

# Three arguments
volume = lambda l, w, h: l * w * h
print(volume(3, 4, 5))
# 60
 
# Using *args for variable arguments
sum_all = lambda *args: sum(args)
print(sum_all(1, 2, 3, 4, 5))
# 15
 
# Using **kwargs
build_greeting = lambda **kwargs: f"Hello, {kwargs.get('name', 'stranger')}!"
print(build_greeting(name="Alice"))
# Hello, Alice!
print(build_greeting())
# Hello, stranger!
 
# Conditional expression inside lambda
classify = lambda x: "positive" if x > 0 else ("zero" if x == 0 else "negative")
print(classify(5))
# positive
print(classify(0))
# zero
print(classify(-3))
# negative

Beachten Sie den bedingten Ausdruck (a if condition else b) im letzten Beispiel. Dies ist die einzige Möglichkeit, Verzweigungslogik in ein Lambda einzubauen. Es funktioniert, aber das Verschachteln mehrerer Bedingungen reduziert die Lesbarkeit schnell.

Lambda in Dictionary-Operationen

Lambda-Funktionen sind nützlich zum Transformieren und Sortieren von Dictionary-Daten:

# Sort a dictionary by value
scores = {"Alice": 88, "Bob": 95, "Charlie": 72, "Diana": 91}
sorted_scores = dict(sorted(scores.items(), key=lambda item: item[1], reverse=True))
print(sorted_scores)
# {'Bob': 95, 'Diana': 91, 'Alice': 88, 'Charlie': 72}
 
# Apply a transformation to all dictionary values
prices = {"apple": 1.20, "banana": 0.50, "cherry": 2.00}
discounted = {k: round(v * 0.9, 2) for k, v in prices.items()}
print(discounted)
# {'apple': 1.08, 'banana': 0.45, 'cherry': 1.8}
 
# Group items using a lambda as a key function
from itertools import groupby
 
data = ["apple", "avocado", "banana", "blueberry", "cherry", "cranberry"]
data_sorted = sorted(data, key=lambda x: x[0])
 
for letter, group in groupby(data_sorted, key=lambda x: x[0]):
    print(f"{letter}: {list(group)}")
# a: ['apple', 'avocado']
# b: ['banana', 'blueberry']
# c: ['cherry', 'cranberry']

Lambda mit Pandas: df.apply() und df.sort_values()

Lambda-Funktionen werden in pandas häufig für zeilenweise Transformationen und benutzerdefinierte Sortierung verwendet. Die apply()-Methode führt eine Funktion auf jeder Zeile oder Spalte eines DataFrame aus, und Lambda hält den Code inline.

import pandas as pd
 
df = pd.DataFrame({
    "name": ["Alice", "Bob", "Charlie", "Diana"],
    "score": [88, 95, 72, 91],
    "department": ["Engineering", "Marketing", "Engineering", "Marketing"]
})
 
# Add a new column with a grade label
df["grade"] = df["score"].apply(lambda x: "A" if x >= 90 else ("B" if x >= 80 else "C"))
print(df)
#       name  score   department grade
# 0    Alice     88  Engineering     B
# 1      Bob     95    Marketing     A
# 2  Charlie     72  Engineering     C
# 3    Diana     91    Marketing     A

Lambda mit sort_values(key=) verwenden

Der key-Parameter in sort_values() akzeptiert eine Funktion, die vor der Sortierung auf die Spalte angewendet wird:

import pandas as pd
 
df = pd.DataFrame({
    "product": ["Widget A", "Widget B", "Widget C"],
    "price": ["$29.99", "$9.50", "$149.00"]
})
 
# Sort by numeric price value (strip the $ sign first)
df_sorted = df.sort_values("price", key=lambda col: col.str.replace("$", "", regex=False).astype(float))
print(df_sorted)
#     product    price
# 1  Widget B    $9.50
# 0  Widget A   $29.99
# 2  Widget C  $149.00

Lambda mit apply() über Zeilen verwenden

Setzen Sie axis=1, um ein Lambda auf jede Zeile anzuwenden:

import pandas as pd
 
df = pd.DataFrame({
    "first_name": ["Ada", "Grace", "Alan"],
    "last_name": ["Lovelace", "Hopper", "Turing"],
    "birth_year": [1815, 1906, 1912]
})
 
# Create a full name column
df["full_name"] = df.apply(lambda row: f"{row['first_name']} {row['last_name']}", axis=1)
 
# Calculate age (approximate, as of 2026)
df["approx_age"] = df["birth_year"].apply(lambda y: 2026 - y)
 
print(df)
#   first_name last_name  birth_year       full_name  approx_age
# 0        Ada  Lovelace        1815  Ada Lovelace          211
# 1      Grace    Hopper        1906  Grace Hopper          120
# 2       Alan    Turing        1912    Alan Turing          114

Gängige Lambda-Muster und Idiome

Hier sind Muster, die Sie häufig in produktivem Python-Code antreffen werden:

# 1. Default factory for collections.defaultdict
from collections import defaultdict
 
word_count = defaultdict(lambda: 0)
for word in ["apple", "banana", "apple", "cherry", "banana", "apple"]:
    word_count[word] += 1
print(dict(word_count))
# {'apple': 3, 'banana': 2, 'cherry': 1}
 
# 2. Immediate invocation (IIFE - Immediately Invoked Function Expression)
result = (lambda x, y: x + y)(3, 4)
print(result)
# 7
 
# 3. Lambda as a callback in GUI or event-driven code
# button.on_click(lambda event: print(f"Clicked at {event.x}, {event.y}"))
 
# 4. Using lambda with min/max for custom comparisons
products = [
    ("Laptop", 999),
    ("Mouse", 25),
    ("Keyboard", 75),
    ("Monitor", 450),
]
cheapest = min(products, key=lambda p: p[1])
print(cheapest)
# ('Mouse', 25)
 
# 5. Lambda with conditional expression for data cleaning
clean = lambda s: s.strip().lower() if isinstance(s, str) else s
print(clean("  Hello World  "))
# hello world
print(clean(42))
# 42

Wann Lambda NICHT verwenden

Lambda-Funktionen haben klare Grenzen. Sie über diese Grenzen hinaus zu verwenden, führt zu Code, der schwerer zu lesen, zu debuggen und zu warten ist.

Vermeiden Sie Lambda, wenn:

1. Die Logik komplex ist. Wenn Sie verschachtelte Bedingungen, mehrere Operationen oder irgendeine Form der Fehlerbehandlung benötigen, verwenden Sie def.

# Bad -- hard to read
process = lambda x: x.strip().lower().replace(" ", "_") if isinstance(x, str) and len(x) > 0 else "empty"
 
# Good -- clear and testable
def process(x):
    """Normalize a string to a snake_case identifier."""
    if not isinstance(x, str) or len(x) == 0:
        return "empty"
    return x.strip().lower().replace(" ", "_")
 
print(process("  Hello World  "))
# hello_world

2. Sie das Lambda einer Variable zur Wiederverwendung zuweisen. PEP 8 empfiehlt ausdrücklich, stattdessen def zu verwenden, anstatt ein Lambda einem Namen zuzuweisen. Wenn die Funktion einen Namen verdient, geben Sie ihr eine ordentliche Definition.

3. Sie einen Docstring oder Type Hints benötigen. Lambda-Funktionen unterstützen keines von beidem. Benannte Funktionen schon.

4. Debugging wichtig ist. Lambda-Funktionen erscheinen als <lambda> in Tracebacks, was es schwer macht zu identifizieren, welches Lambda den Fehler verursacht hat, wenn Sie mehrere haben.

5. Die Lesbarkeit leidet. Wenn ein Kollege mehr als drei Sekunden braucht, um Ihr Lambda zu verstehen, schreiben Sie es als benannte Funktion um.

Lambda-Funktionen schreiben und refaktorisieren mit RunCell

Die Arbeit mit Lambda-Funktionen in Jupyter-Notebooks ist in Data-Science-Workflows üblich. Wenn Sie komplexe pandas apply()-Aufrufe schreiben oder mehrere map()- und filter()-Operationen verketten, kann es schwer sein zu wissen, ob ein Lambda das richtige Werkzeug ist oder ob Sie zu einer benannten Funktion refaktorisieren sollten.

RunCell (opens in a new tab) ist ein KI-Agent, der direkt in Jupyter-Notebooks arbeitet. Er versteht Ihren Notebook-Kontext -- die Variablen im Speicher, die DataFrames, mit denen Sie arbeiten, die geladenen Imports -- und gibt gezielte Vorschläge.

So hilft RunCell speziell bei Lambda-Funktionen:

• Lambda-zu-def-Refactoring. Wenn ein Lambda zu lang wird, kann RunCell eine saubere def-Version mit Type Hints und einem Docstring vorschlagen, wobei das exakte Verhalten erhalten bleibt.
• Performance-Hinweise. Wenn Sie df.apply(lambda ...) auf einem großen DataFrame verwenden, kann RunCell vektorisierte Alternativen mit nativen pandas- oder NumPy-Operationen vorschlagen, die 10-100x schneller laufen.
• Inline-Erklärungen. Arbeiten mit fremdem Code voller verschachtelter Lambdas? RunCell kann aufschlüsseln, was jedes Lambda tut, direkt im Notebook.
• Muster-Vorschläge. Beschreiben Sie, was Sie wollen -- "sortiere diese Liste von Dicts nach Datum, dann nach Name" -- und RunCell generiert den korrekten sorted()-Aufruf mit der richtigen Lambda-Schlüsselfunktion.

Da RunCell in Ihrer bestehenden Jupyter-Umgebung läuft, gibt es keinen Kontextwechsel. Sie bleiben im Notebook, und der KI-Agent arbeitet an Ihrer Seite.

FAQ

Was ist eine Lambda-Funktion in Python?

Eine Lambda-Funktion ist eine kleine, anonyme Funktion, die mit dem Schlüsselwort lambda definiert wird. Sie kann beliebig viele Argumente akzeptieren, aber nur einen einzelnen Ausdruck enthalten. Das Ausdrucksergebnis wird automatisch zurückgegeben. Lambda-Funktionen werden typischerweise für kurze Einweg-Operationen wie Sortierschlüssel, map/filter-Callbacks und Inline-Transformationen verwendet.

Kann ein Python Lambda mehrere Zeilen haben?

Nein. Ein Python Lambda ist auf einen einzelnen Ausdruck beschränkt. Sie können keine mehreren Anweisungen, Schleifen oder Zuweisungen in einem Lambda verwenden. Wenn Sie mehrzeilige Logik benötigen, verwenden Sie eine reguläre def-Funktion. Sie können jedoch einen bedingten Ausdruck (a if condition else b) innerhalb eines Lambda für einfache Verzweigungen verwenden.

Was ist der Unterschied zwischen lambda und def in Python?

Beide erstellen Funktionsobjekte, aber sie unterscheiden sich im Umfang: lambda erstellt anonyme Einzelausdruck-Funktionen, die inline verwendet werden, während def benannte Funktionen erstellt, die mehrere Anweisungen, Docstrings, Type Hints und Dekoratoren enthalten können. Verwenden Sie lambda für einfache Einmal-Operationen; verwenden Sie def für alles, was einen Namen, Dokumentation oder komplexe Logik benötigt.

Wann sollte ich Lambda statt einer List Comprehension verwenden?

Verwenden Sie Lambda mit map() oder filter(), wenn die Operation eine einfache, einzelne Transformation oder ein Prädikat ist. Verwenden Sie List Comprehensions, wenn Sie sowohl Filterung als auch Transformation in einem Schritt benötigen, oder wenn die Logik von der Struktur [expr for x in iterable if condition] profitiert. In modernem Python werden List Comprehensions im Allgemeinen wegen der Lesbarkeit bevorzugt, aber Lambda ist Standard für Sortierschlüssel und Callback-Parameter.

Sind Python Lambda-Funktionen langsam?

Nein. Lambda-Funktionen haben die gleiche Leistung wie äquivalente def-Funktionen. Der Overhead beim Aufrufen beider ist identisch. Allerdings ist die Verwendung von df.apply(lambda ...) in pandas langsam im Vergleich zu vektorisierten Operationen. Der Engpass ist die zeilenweise Python-Ausführung, nicht das Lambda selbst. Wann immer möglich, ersetzen Sie apply(lambda ...) durch eingebaute pandas- oder NumPy-Methoden für bessere Leistung.

Fazit

Python Lambda-Funktionen füllen eine bestimmte Nische: kurze, anonyme Funktionen, die Sie genau dort definieren, wo Sie sie brauchen. Sie sind am besten als Sortierschlüssel, map()/filter()-Callbacks und Inline-Transformationen. Sie passen natürlich zu sorted(), map(), filter(), reduce() und pandas apply().

Die Regeln für ihre gute Verwendung sind einfach:

• Beschränken Sie sie auf einen einfachen Ausdruck.
• Verwenden Sie sie inline, nicht einer Variablen zugewiesen (PEP 8-Richtlinie).
• Wechseln Sie zu def, sobald die Logik schwer lesbar wird.
• In pandas bevorzugen Sie vektorisierte Operationen gegenüber apply(lambda ...) für die Leistung.
• Verwenden Sie bedingte Ausdrücke sparsam -- verschachtelte Ternäre in einem Lambda sind eine Lesbarkeitsfalle.

Lambda ist ein Werkzeug, kein Zeichen von Cleverness. Der beste Python-Code verwendet Lambda, wo es vereinfacht, und def, wo es klarstellt. Die Grenze zwischen den beiden zu kennen, unterscheidet lesbaren Code von Code, der Ihr zukünftiges Ich (oder Ihre Teammitglieder) kämpfen lässt.