Python Lambda: Anonyme Funktionen in Python

Einführung

Eine Funktion in der Programmierung beschreibt einen Block aus Code, der eine spezifische und vordefinierte Aufgabe erfüllt. Dabei sollten Funktionen so oft wie möglich verwendet werden. Der ausschlaggebende Grund dafür ist die Wiederverwendbarkeit von Funktionen.

Während das Definieren von Funktionen sich zwischen den verschiedenen Programmiersprachen unterscheiden kann, bleibt das grundsätzliche Konzept das Gleiche. Eine Funktion akzeptiert dabei Werte und führt programmierte Anweisungen aus. Gegebenenfalls wird auch ein Wert zurückgegeben. In der jüngeren Vergangenheit haben einige Programmiersprachen den traditionellen Ansatz der Funktion modifiziert. Beispiel dafür sind die Pfeilfunktionen in JavaScript und die Lambdafunktionen in Python.

In diesem Artikel werden wir die Python Lambda-Funktionen, ihren Verwendungszweck und die daraus resultierende Vorteile thematisieren.

Python Lambda-Funktionen

Die Lambdafunktion, auch als anonyme Funktion in Python bekannt, ist eine Funktion, dies ohne das Stichwort „def“ definiert wird. Stattdessen verwenden wir das Wort „lambda“.

Betrachten wir im Folgenden die Syntax der Lambdafunktion:

lambda Parameter: Anweisung

Wahrscheinlich verstehen wir jetzt noch nicht, was mit diesem Ausdruck passieren soll. Dafür können wir uns ein Beispiel zur Hilfe nehmen.

Betrachten wir nun den Code:

def sagHallo():
	print("Hallo Welt!")

sagHallo()

sagHallo() ist eine normale Funktion in Python. Diese gibt den Ausdruck „Hallo Welt!“ aus. Führen wir den Code aus:

Jetzt wollen wir den Code neu schreiben und dabei die Python Lambdafunktion verwenden.

sagHallo = lambda:print("Hallo Welt!")
sagHallo()

Im obigen Code erfüllt die Funktion genau die gleichen Bedingungen wie in der Definition mit einer normalen Python Funktion über das Stichwort „def“. Auf der linken Seite des Doppelpunktes haben wir den „lambda“-Ausdruck, auf der Rechten steht wiederum die eigentliche Anweisung. Führen wir den Code aus und betrachten das Ergebnis:

Betrachten wir jetzt, wie wir eine Lambdafunktion mit Parametern erstellen können.

def findeDopplung(x):
	print("Das Doppelte: ", x * 2)

findeDopplung (10)

Die findeDopplung()-Funktion akzeptiert eine einzelne Nummer und wird das Doppelte dieser ausgeben.

Jetzt können wir versuchen, diese Funktionsweise mittels einer Lambdafunktion umzusetzen.

findeDopplung = lambda x: print("Das Doppelte: ", x * 2)
findeDopplung(10)

Der zu übergebende Parameter wird zwischen dem Stichwort „lambda“ und dem Doppelpunkt eingefügt. Betrachten wir erneut das Ergebnis:

Eine Lambdafunktion kann auch mehrere Parameter akzeptieren. Erstellen wir dafür eine Funktion, die die Werte von drei zahlen addiert und ausgibt.

summe = lambda x, y, z: print("Summe: ", x + y + z)
summe(10,20,30)

In diesem Fall akzeptiert die Lambdafunktion drei Parameter. Dabei werden die Parameter mittels eines Kommas getrennt.

Bei der Verwendung der Lambdafunktion haben wir den großen Vorteil, dass wir die Größe unseres Quellcode reduzieren können, wenn die Funktion lediglich eine Anweisung enthält. Betrachten wir dafür folgenden Code:

def findeDopplung1(x):
	print("Dopplung: ", x * 2)
findeDopplung2 = lambda x: print("Dopplung: ", x * 2)

Die findeDopplung1()-Funktion ist auf dem normalen Weg in Python definiert. Dabei haben wir das Stichwort „def“ verwendet. Die findeDopplung2()-Funktion andererseits verwendet die Lambdafunktion. Beide Funktionen führen die gleiche Aufgabe aus. Für die findeDopplung1()-Funktion haben wir allerdings zwei Zeilen im Code benötigt. Für die zweite Funktion haben wir lediglich eine Zeile genutzt. Das mag zunächst nach keinem riesigen Unterschied aussehen, kann in großen Programmen allerdings eine enorme Differenz ausmachen.

In der Lambdafunktion wird grundsätzlich die Anweisung ohne das Wort „return“ zurückgegeben.

get = lambda: "Zurueckgegebener Wert!"
get()

Der obige Code ist gleich zu Folgendem:

def get():
	return " Zurueckgegebener Wert!"

get()

Die Python Lambda-Funktion in Verbindung mit map und filter

„map“ und „filter“ sind integrierte Funktionen in Python, die zum Iterieren über Sammlungen genutzt werden. Die Funktionen können in Kombination mit der Lambdafunktion verwendet werden und so für eine bessere Effizienz und einen kürzeren Code sorgen.

Versuchen wir dies zu verstehen, indem wir die Python map-Funktion nutzen.

def erhöhe(x):
	return x + 1

list1 = [1, 2, 3, 4, 5]
list2 = list(map(erhöhe, list1))
print(list2)

Im obigen Code iterieren wir mittels der map-Funktion über die „list1“. Dabei wird jedes unserer Elemente in die erhöhe()-Funktion übergeben und jeweils um eins erhöht. „list2“ bildet dann die neue Liste.

Da die erhöhe()-Funktion nur eine Zeile mit einer Anweisung umfasst, können wir eine Lambdafunktion erstellen, um keine separate Funktion zu benötigen.

list1 = [1, 2, 3, 4, 5]
list2 = list(map(lambda x: x + 1, list1))

Der obige Code funktioniert gleich zu unserem bereits betrachteten Beispiel. Betrachten wir die map()-Funktion einmal genauer:

map(lambda x: x + 1, list1)

Die erhöhe()-Funktion wurde durch eine Lambdafunktion ersetzt, die einen Parameter empfängt. Dieses wird dann um eins erhöht.

Neben der Reduzierung von Quellcode sinkt auch der Aufwand für uns.

Betrachten wir jetzt die filter()-Funktion.

list1 = [1, 2, 3, 4, 5]
list2 = list(filter(lambda x: x > 2, list1))

Die filter()-Funktion wird das jeweilige Element nur hinzufügen, wenn dieses größer als zwei ist.

Wann sollte man die Python Lambda-Funktion verwenden?

1. Die Funktion soll nur eine (oder wenige) Anweisung enthalten
2. Eine Anweisung ist nicht komplex
3. Die Aufgabe ist temporär und wiederkehrend
4. Wenn integrierte Funktionen wie die map()- und filter()-Funktion verwendet werden

Zusammenfassung

Die Lambdafunktion ist eine neue Herangehensweise, um Funktionen in Python zu nutzen. Zunächst erscheint die Verwendung relativ kompliziert, allerdings ist die Funktion sehr hilfreich. In diesem Artikel habe wir besprochen, wie wir im Vergleich zur traditionellen Schreibweise eine Lambdafunktion nutzen können. Außerdem haben wir die Funktion in Verbindung mit integrierten Funktionen nutzen können. Dabei haben wir die map()- und filter()-Funktion näher betrachtet. Zusammenfassend, sind Python Lambda-Funktionen nützlich, wenn wir nur eine, oder wenige, Anweisung innerhalb der gewünschten Funktion ausführen.