Zurück zu: Python Tutorial

Was sind Lambda-Funktionen?

Eine Lambda-Funktion ist eine kleine, anonyme Funktion, die in einer einzigen Zeile definiert wird. Sie eignet sich besonders dann, wenn eine Funktion nur einmal benötigt wird oder sehr kurz ist. Manchmal wird die Lambda-Funktion auch als Wegwerf-Funktion bezeichnet, weil Du sie kurz vor der Verwendung definieren kannst, sie dann gleich verwendest und dann später nicht mehr nutzt.

Anstatt eine Funktion mit def (und Funktionsname mit Parametern) zu definieren, kann sie direkt mit lambda (und Parametern) geschrieben werden.

Allgemeine Syntax

lambda parameter1, parameter2, ... , parameterN: ausdruck

lambda ist dabei das notwendige Schlüsselwort, speziell für die Definition einer Lambda-Funktion. Anschließend müssen alle Parameter durch Komma getrennt genannt werden. Du brauchst mindestens einen Parameter, kannst aber auch beliebig viele Parameter festlegen.

Nach dem letzten Parameter folgt der Doppelpunkt („:“) und danach ist genau ein Ausdruck zugelassen für die Ausführung in der Lambda-Funktion. Wenn Du mehrere Anweisungen hast, dann kannst Du sie nicht in einer Lambda-Funktion unterbringen. Dann brauchst Du eine Funktion, die Du mit def deklarierst.

Beispiel Quadrat berechnen:

Hier wird nun eine einfache Lambda-Funktion mit einem Paramter (x) festgelegt. Nach dem Doppelpunkt wird das Quadrieren definiert, für den Parameter x. Die Lambda-Funktion wird der Variable quadriere zugewiesen. Deshalb kannst Du die Lambda-Funktion nun auch mit dem Namen quadriere und dem Parameterwert in den Klammern aufrufen.

quadriere = lambda x: x * x

print(quadriere(5))

Ausgabe Quadrat berechnen:

Mit dem print() wird dann ausgegeben, was die Lambda-Funktion für den Parameterwert 5 berechnen – also 25.

Wenn Du das mit einer herkömmlichen Funktion aufschreiben würdest, dann sähe das so aus.

def quadriere(x):
    return x * x

print(quadriere(5))

Einerseits wäre es ein bisschen länger. Und andererseits, vielleicht ist das sogar noch viel entscheidender, musst Du die Funktion quadriere() vor Deinem Skript definieren. Wenn Du Dir jetzt vorstellst, dass vor dem print() noch ganz viel anderer Python-Programmcode steht, dann musst Du erst weit nach oben scrollen im Programmcode, um zu sehen, was quadriere() macht. Mit der Lambda-Funktion kannst Du die Funktion quadriere() aber direkt vor der Verwendung deklarieren. Und damit siehst Du auch direkt, was sie macht.

Mehrere Parameter

Lambda-Funktionen können beliebig viele Parameter besitzen. Hier werden die zwei Parameter a und b von der Lambda-Funktion aufgenommen und addiert. Wie Du oben schon gesehen hast, können auch noch mehr Parameter definiert werden.

addiere = lambda a, b: a + b

print(addiere(7, 5))

Ausgabe:

Mit dem Aufruf addiere(7,5) übergibst Du zwei Parameter an die Lambda-Funktion. Diese Werte werden dann addiert und zurückgegeben. Beim Zurückgeben kannst Du es Dir so vorstellen, dass das Ergebnis an genau die Stelle geschrieben wird, von wo der Aufruf der Funktion passiert ist.

Also ist der konkrete Ablauf hier so:

Lambda-Funktion definieren und der Variable addiere zuweisen
addiere() mit den Parametern 7 und 5 aufrufen
Sprung zur Lambda-Funktion
Addieren von 7 und 5
Rückgabe des Ergebnisses 12
print()-Aufruf mit dem dann zurückgegebenen Wert 12 und damit Ausgabe von 12

Lambda mit Bedingungen

In der Lambda-Funktion kannst Du nicht nur rechnen. Auch einfache Bedingungen können verwendet werden. Mit der Entscheidung, ob „positiv“ oder „negativ“ ausgegeben wird, ist das dann immer noch eine Anweisung, die innerhalb der Lambda-Funktion ausgeführt wird.

groesser = lambda x: "positiv" if x >= 0 else "negativ"

print(groesser(4))
print(groesser(-3))

Im Test-Programmcode werden der Lambda-Funktion nacheinander zwei unterschiedliche Werte übergeben, ein positiver und ein negativer Wert. Dementsprechend werden auch die beiden Ausgaben „positiv“ und „negativ“ erzeugt.

positiv
negativ

Verwendung mit sorted()

Wenn Du mit Daten in Programmen arbeitest, dann kommt es immer mal wieder vor, dass sortiert werden muss. Das stellt dann für die Daten eine bestimmte Reihenfolge her. Die Funktion sorted() hilft Dir genau dabei. Wenn Du eine Liste an die Funktion übergibst, dann wird die Funktion einfach nur sortieren. Bei numerischen Werten ist das dann eine aufsteigende Sortierung. Zeichenketten werden alphabetisch aufsteigend sortiert.

Beispiel 1: Nach dem Alter sortieren

Hier hast Du jetzt allerdings keine reine Liste personen vor Dir, sondern es ist eine Liste von Tupeln. Wenn Du sorted nur für die Liste aufrufen würdest, ohne einen weiteren Parameter, dann würde einfach nach dem ersten Wert innerhalb der Tupel sortiert – also alphabetisch nach dem Namen.

Wenn Du aber speziell nach dem zweiten Wert im Tupel sortieren möchtest, dann musst Du das der Funktion sorted() auch explizit sagen. Das kannst Du über den Parameter key machen. Und dieser Parameter nimmt dann eine Funktion auf, mit welcher der zu vergleichende Wert im Tupel definiert wird. Die Lambda-Funktion macht genau das. Der Parameter ist person. Das bedeutet, dass für jedes einzelne Element der Liste das Tupel an die Lambda-Funktion gegeben wird. In der Lambda-Funktion wird dann aus dem Tupel nur der numerische Wert genommen (Index [1]) und der Funktion sorted() als Sortierkriterium übergeben.

personen = [
    ("Anna", 22),
    ("Peter", 18),
    ("Lisa", 25)
]

sortiert = sorted(personen, key=lambda person: person[1])

print(sortiert)

Die nach Zahlenwert sortierte Ausgabe sieht dann so aus:

[('Peter', 18), ('Anna', 22), ('Lisa', 25)]

Es liefert also die Lambda-Funktion

lambda person: person[1]

für jede Person den Zahlenwert zurück.

Beispiel 2: Nach der Namenslänge

Hier wird jetzt mal nur eine Liste aufgebaut und es soll mit sorted() wieder sortiert werden. Und Du siehst auch, dass die Lambda-Funktion durch lambda name wieder jeden einzelnen Namen bekommt. Und hier wird dann aber die Länge des Namens mit Hilfe von len() ermittelt.

namen = ["Alexander", "Tom", "Lisa", "Max"]

sortiert = sorted(namen, key=lambda name: len(name))

print(sortiert)

Also führt das zur Ausgabe der Namen, sortiert nach der Länge der Namen. Die ersten beiden Namen sind gleich lang, die weiteren Namen sind jeweils länger.

['Tom', 'Max', 'Lisa', 'Alexander']

Verwendung mit filter()

Mit der Funktion filter() können Elemente aus einer Liste herausgefiltert werden. Und auch dafür kannst Du eine Lambda-Funktion einsetzen, um den Filter genauer zu definieren.

Die grundsätzliche Syntax der Funktion filter() ist:

filter(funktion, liste)

Und das siehst Du schon bei den Parametern, dass im ersten Parameter eine Funktion verlangt wird. Ganz ähnlich wie der Parameter key in der Funktion sorted(). Da filter() einen Iterator liefert, wird häufig list() verwendet, um dann das Ergebnis von filter() noch in eine Liste umzuwandeln.

Beispiel: Gerade Zahlen

Hier wird eine Liste von Zahlen definiert, auf die die Funktion filter() angewendet werden soll. Und Du siehst beim ersten Parameter der Funktion filter(), dass dort eine Lambda-Funktion eingesetzt wird. Wenn diese Funktion True zurückgibt, dann wird der Wert in der Liste übernommen, also als Ergebnis herausgefiltert. Dadurch wird mit lambda x: x % 2 == 0 jedes Element geprüft und dann übernommen, wenn es auch gerade ist.

zahlen = [3, 8, 11, 14, 20, 5]

gerade = list(filter(lambda x: x % 2 == 0, zahlen))

print(gerade)

Im Ergebnis siehst Du dann, dass alle geraden Werte ins Ergebnis übernommen wurden.

[8, 14, 20]

Beispiel: Lange Wörter

Du könntest auch anhand der Länge der Wörter einen Filter aufbauen. Hier siehst Du eine Liste mit Zeichenketten. Und Du könntest Dir mit Hilfe der Lambda-Funktion nun jede einzelne Zeichenkette herausnehmen und ihre Länge anschauen. Wenn die Länge größer als 5 ist, dann übernimmst Du die Zeichenkette ins Ergebnis, ansonsten nicht. Mit der Lambda-Funktion und ein bisschen Übung beim Lesen dieser Anweisungen kannst Du also ganz einfach erkennen, wie hier gefiltert wird.

woerter = ["Auto", "Programmierung", "Baum", "Python"]

lang = list(filter(lambda wort: len(wort) > 5, woerter))

print(lang)

Dementsprechend wird Dir das Programm dann die Ausgabe liefern:

['Programmierung', 'Python']

Verwendung mit map()

Mit der Funktion map() wird jedes Element einer Liste verändert. Das passiert wieder ganz ähnlich wie schon zuvor bei sorted() und filter(). Jedes Element einer Liste wird mit Hilfe der Lambda-Funktion herausgenommen und in einen anderen Wert überführt.

Die allgemeine Syntax ist:

map(funktion, liste)

Auch hier wird häufig list() verwendet, denn map() liefert einen Iterator und das kann in eine Liste umgewandelt werden. Eine Liste lässt sich dann beispielsweise gut im print() ausgeben.

Beispiel: Zahlen quadrieren

Für die gegebene Liste zahlen möchtest Du jeweils das Quadrat berechnen. Die Lambda-Funktion für das Berechnen des Quadrats hast Du oben schon gesehen. Dort wurde die Lambda-Funktion dann einer Variable zugewiesen. Hier wird jetzt die Lambda-Funktion nur als Parameter in map() eingefügt. Und damit wird jedes einzelne Element der Liste quadriert. Du brauchst keine for-Schleife mehr.

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

quadrate = list(map(lambda x: x * x, zahlen))

print(quadrate)

In der Ausgabe siehst Du dann entsprechend alle Elemente der ursprünglichen Liste quadriert.

[1, 4, 9, 16, 25]

Beispiel: Großbuchstaben

Und schließlich kannst Du auch Funktionen für die Bearbeitung von Zeichenketten (Strings) verwenden in map(). Damit änderst Du jeden einzelnen String einer Liste. Hier werden mit der Funktion upper() alle Buchstaben in Großbuchstaben umgewandelt. Und auch das ist wieder ein sehr gutes Beispiel für die Verwendung einer Lambda-Funktion.

namen = ["anna", "tom", "lisa"]

gross = list(map(lambda name: name.upper(), namen))

print(gross)

Der Programmcode erzeugt Dir dann wieder die folgende Ausgabe:

['ANNA', 'TOM', 'LISA']

Wann sollte man Lambda verwenden?

Geeignet für

kurze Funktionen
einmalige Berechnungen
sorted()
filter()
map()

Nicht geeignet für

längere Programme
komplexe Berechnungen
Funktionen mit vielen Anweisungen

Dann sollte lieber def verwendet werden.

Zusammenfassung

Lambda-Funktionen sind kurze anonyme Funktionen.
Sie bestehen aus genau einem Ausdruck.
Sie eignen sich besonders für kleine Hilfsfunktionen.
Besonders häufig werden sie mit sorted(), filter() und map() eingesetzt.