Python anonyme Funktionen Lambda: Einfach erklärt mit Beispielen

Du sitzt über einer Prüfungsaufgabe oder dem Code deines Kollegen und liest folgende Zeile:

sortiert = sorted(mitarbeiter, key=lambda m: m[1])

`sorted()` leuchtet ein - aber was zum Geier ist `lambda`? Keine Sorge: Anonyme Funktionen mit `lambda` sind in Python einfacher, als sie aussehen. Nach diesem Beitrag kannst du solche Zeilen nicht nur lesen, sondern selbst schreiben.

Was sind anonyme Funktionen (Lambda) in Python?

Eine anonyme Funktion ist eine Funktion ohne Namen, die du in Python mit dem Schlüsselwort `lambda` erstellst. Anders als bei einer normalen Funktion mit `def` vergibst du keinen Funktionsnamen - du schreibst die Funktion direkt an die Stelle, wo du sie brauchst.

Stell dir vor, du schreibst eine Notiz auf einen Klebezettel und gibst sie direkt weiter. Das ist ein Lambda. Eine Funktion mit `def` ist dagegen wie ein sauberer Eintrag in deinem Notizbuch: Sie hat einen Namen, bleibt abgelegt und du kannst sie jederzeit wieder aufrufen.

Merke: „Anonym" bedeutet einfach „namenlos". Das Lambda selbst ist die Funktion - der Name kommt nur daher, dass sie keinen besitzt. Der Begriff stammt aus dem Lambda-Kalkül, einem mathematischen Modell für Funktionen.

Die offizielle Beschreibung findest du in der Python-Dokumentation.

Wie sieht die Syntax eines Lambda aus?

Ein Lambda besteht aus dem Schlüsselwort `lambda`, beliebig vielen Parametern, einem Doppelpunkt und genau einem Ausdruck, dessen Ergebnis automatisch zurückgegeben wird.

Das Schema:

lambda parameter: ausdruck

Ein konkretes Beispiel:

addiere = lambda a, b: a + b
print(addiere(3, 4))  # Ausgabe: 7

Das gleiche Ergebnis erreichst du mit `def`:

def addiere(a, b):
    return a + b

Zwei Besonderheiten fallen auf:

• Es gibt kein `return` - das Ergebnis des Ausdrucks wird automatisch zurückgegeben.

• Es ist genau ein Ausdruck erlaubt. Keine Zuweisungen, keine Schleifen, keine mehrzeilige Logik.

Ein bedingter Ausdruck geht trotzdem, weil er ein Ausdruck ist:

bewertung = lambda alter: "volljaehrig" if alter >= 18 else "minderjaehrig"
print(bewertung(20))  # Ausgabe: volljaehrig

Kernregel: Ein Lambda besteht aus genau einem Ausdruck. Das Ergebnis wird automatisch zurückgegeben - ein `return` ist weder nötig noch erlaubt.

Lambda oder def? Der Unterschied im Überblick

Beide erzeugen Funktionsobjekte - der Unterschied liegt in Einsatz und Umfang. In Python sind Funktionen nämlich Objekte wie alles andere, deshalb kannst du sie wie Werte übergeben.

Ein ehrlicher Hinweis: Das Beispiel oben mit `addiere = lambda ...` dient nur zum Verstehen. Die PEP 8, der offizielle Python-Styleguide, empfiehlt ausdrücklich: Wenn du einer Funktion einen Namen gibst, nutze `def`. Warum? Weil der Name bei `def` direkt in der Fehlermeldung und im Debugger auftaucht.

Wann nutzt man Lambda-Funktionen?

Lambdas werden fast immer als Argument an Funktionen übergeben, die selbst eine Funktion erwarten - vor allem `sorted()`, `map()` und `filter()`.

Kernantwort: Du brauchst ein Lambda immer dann, wenn eine Funktion eine andere Funktion als Argument erwartet - typischerweise als `key` bei `sorted()`, `min()` und `max()` sowie bei `map()` und `filter()`.

Der Klassiker ist das Sortieren mit dem `key`-Argument. Warum? Weil `sorted()` bei einer Liste von Tupeln standardmäßig nach dem ersten Element sortiert. Sagst du ihm mit `key`, wonach es sortieren soll - wie „Sortiere nach dieser Spalte" in Excel.

produkte = [("Tastatur", 49.99), ("Maus", 19.99), ("Monitor", 189.00)]

nach_preis = sorted(produkte, key=lambda p: p[1])
print(nach_preis)
# Ausgabe: [('Maus', 19.99), ('Tastatur', 49.99), ('Monitor', 189.0)]

Hier bekommt jedes Produkt das Lambda übergeben, das den Preis (Index 1) zurückgibt. Genau nach diesem Wert sortiert `sorted()` dann. Details dazu erklärt der Sorting-HOW-TO der Python-Dokumentation.

Auch bei `map()` (wende an auf jedes Element) und `filter()` (behalte nur passende Elemente) begegnet dir Lambda ständig:

zahlen = [1, 2, 3, 4, 5]

quadrate = list(map(lambda x: x**2, zahlen))
print(quadrate)  # Ausgabe: [1, 4, 9, 16, 25]

gerade = list(filter(lambda x: x % 2 == 0, zahlen))
print(gerade)  # Ausgabe: [2, 4]

Nebenbei: `map()` und `filter()` geben in Python 3 Iteratoren zurück - deshalb wertest du sie mit `list()` aus.

Ehrlich gesagt: Viele Python-Entwickler schreiben stattdessen List Comprehensions wie `[x ** 2 for x in zahlen]`, weil die oft lesbarer sind. Aber Lambdas bei `map()` und `filter()` triffst du in fremdem Code, in Prüfungen und im Job überall an - deshalb musst du sie sicher lesen können.

Praxisbeispiel: Gehaltsliste sortieren

Hier ein vollständiges, lauffähiges Beispiel, wie es dir im Berufsalltag begegnen könnte - etwa bei einer kleinen Auswertung:

mitarbeiter = [
    ("Anna", 28, 3200),
    ("Ben", 35, 4100),
    ("Cem", 41, 2800),
    ("Dilara", 23, 3600),
]

# Sortierung nach Gehalt (Index 2), absteigend
nach_gehalt = sorted(mitarbeiter, key=lambda m: m[2], reverse=True)

# Sortierung nach Name (Index 0)
nach_name = sorted(mitarbeiter, key=lambda m: m[0])

print("Gehalt absteigend:")
for name, alter, gehalt in nach_gehalt:
    print(f"  {name}: {gehalt} Euro")

print("Alphabetisch:")
for name, alter, gehalt in nach_name:
    print(f"  {name}")

Beide Sortierungen laufen auf dieselbe Liste - nur das Lambda entscheidet, welcher Wert als Sortierkriterium dient. Genau das ist die Stärke: eine Zeile, ein klarer Zweck.

Diese 3 Fehler machen Anfänger

Fehler 1: Anweisungen im Lambda

Ein Lambda darf nur einen Ausdruck enthalten. Zuweisungen sind keine Ausdrücke, sondern Anweisungen - das Lambda bricht mit einem `SyntaxError`:

# FALSCH: Zuweisung ist nicht erlaubt
verdoppeln = lambda x: x = x * 2  # SyntaxError


# RICHTIG: normale Funktion dafuer nutzen
def verdoppeln(x):
    x = x * 2
    return x

Fehler 2: Lambdas an Namen binden statt `def` zu nutzen

Wie oben erwähnt: Wenn die Funktion einen Namen braucht und länger als ein Ausdruck sein könnte, nimm `def`. Lambda ist für Einweg-Logik direkt als Argument gedacht.

Fehler 3: Late Binding in Schleifen

Der tückischste Fall - oft in der IHK-Prüfung oder in Vorlesungen als Fangfrage verwendet:

funktionen = [lambda: i for i in range(3)]
print(funktionen[0]())  # Ausgabe: 2 (nicht 0!)

# RICHTIG: Parameter mit Default-Wert fixiert den Wert
funktionen = [lambda i=i: i for i in range(3)]
print(funktionen[0]())  # Ausgabe: 0

Warum? Das Lambda merkt sich die Variable `i`, nicht ihren Wert zum Erstellungszeitpunkt. Nach der Schleife ist `i` gleich 2 - und genau das geben alle drei Funktionen zurück. Mit dem Default-Parameter `i=i` wird der Wert beim Erstellen „eingefroren".

Dein Übungstipp

Nimm diese Liste und sortiere sie zuerst nach Note, dann nach Name - mit zwei verschiedenen Lambdas:

schueler = [
    {"name": "Lena", "note": 2},
    {"name": "Tim", "note": 1},
    {"name": "Aisha", "note": 2},
    {"name": "Nico", "note": 3},
]

# Dein Code hier:
# sortiert_nach_note = sorted(schueler, key=...)

Tipp: Bei Dictionaries greifst du mit `key=lambda s: s["note"]` auf das Feld zu. Bau die Liste danach um und füge ein drittes Feld hinzu, nach dem du ebenfalls sortierst. So verinnerlichst du das Muster.

FAQ: Häufige Fragen zu Lambda in Python

Was ist eine anonyme Funktion in Python?

Eine Funktion ohne Namen, die mit dem Schlüsselwort `lambda` in einer einzigen Zeile erstellt wird. Sie besteht aus Parametern und genau einem Ausdruck, dessen Ergebnis automatisch zurückgegeben wird.

Was ist der Unterschied zwischen lambda und def?

`def` definiert eine benannte Funktion mit beliebig vielen Anweisungen und explizitem `return`. Ein Lambda ist namenlos, auf einen Ausdruck beschränkt und gibt dessen Ergebnis implizit zurück.

Wie viele Parameter kann ein Lambda haben?

Beliebig viele - von null (`lambda: 42`) bis zu so vielen, wie du brauchst. Der Rückgabewert bleibt aber immer ein einziger Ausdruck.

Kann ein Lambda mehrere Zeilen haben?

Nein. Sobald du mehrere Schritte, Zuweisungen oder Schleifen brauchst, ist `def` das richtige Werkzeug.

Wann sollte ich kein Lambda verwenden?

Wenn die Logik komplex ist, an mehreren Stellen gebraucht wird oder einen aussagekräftigen Namen verdient. Lesbarkeit schlägt Kürze.

Fazit

Anonyme Funktionen mit `lambda` sind kurze, namenlose Funktionen für den Direkteinsatz - vor allem als `key`-Argument bei `sorted()` sowie bei `map()` und `filter()`. Merk dir drei Dinge: ein Ausdruck, kein `return`, und sobald es komplex wird, her mit `def`. Wenn dich das Thema Funktionen in Klassen interessiert, lies danach unseren Beitrag zu self in Python verstehen: Wozu dient es?.

Und wenn du bei Python oder anderen IT-Themen auf dem Schlauch stehst - ob für die IHK-Prüfung, die nächste Hausaufgabe oder den Berufseinstieg - dann schau dir study-it.education an. Dort bekommst du persönliche Nachhilfe, die genau da ansetzt, wo du gerade stehst.