Die Lambda-Funktion in Python

In Python 3 und in Python 2 gibt es den sogenannten Lambda Operator. Dieser wurde bereits mit Version 1.0 in Python hinzugefügt. Es wurde schon 2005 diskutiert, dieses Feature wieder zu entfernen, da man es nicht benötigen würde; Guido van Rossum ist nun einmal kein Freund von lambda, reduce, filter und map.

Die Diskussion zu dieser Thematik ist hier zu finden: https://www.artima.com/forums/flat.jsp?forum=106&thread=98196&start=0&msRange=15.

Mit Python 3 wurde die Reduce-Funktion dann allerdings doch aus der Standardbibliothek entfernt, und in das Module "functools" verschoben. Die Funktionen filter und map sind in der Standardbibliothek weiterhin enthalten, sowie der Lambda Operator.

Was ist der Lambda Operator?

Der Lambda Operator ist dazu da, in Python anonyme Funktionen zu erstellen. Es ist nicht notwendig, eine Lambda Funktion zu benennen. Sie kann allerdings in einer Variable gespeichert werden. Ursprünglich kommen die Lambda-Funktionen aus der funktionalen Programmierung.

Der Aufbau ist immer der selbe am Anfang steht das keyword Lambda. Dann folgen die Parameter und nach einem Doppelpunkt steht ein Ausdruck, dessen Ergebnis der Rückgabewert (Return) ist. Es ist nicht notwendig und auch nicht möglich, einen Return im Ausdruck zu verwenden, und andere Keywords wie zum beispiel "pass".

lambda parameterliste: ausdruck

Die Parameter werden wie gewohnt mit Komma getrennt angegeben. Eine exemplarische Lambda-Funktion kann zum Beispiel so aussehen:

(lambda x,y: x+y)(5,6)

add = lambda x,y: x+y

Im Beispiel haben wir unsere anonyme Funktion (Lambda) definiert und können diese direkt mit zwei Werten ausführen. Alternativ können wir die Lambda-Funktion in eine Variable speichern. Diese Variable können wir eine normale Funktion abrufen.

Warum sollte ich den Lambda Operator einsetzen?

Der Lambda Operator erspart dir oft Schreibarbeit oder Zeilen, manchmal sieht es aber auch einfach eleganter aus; da die Lambda-Funktion direkt in der Zeile steht, wo diese auch Verwendung findet, ist alles oft verständlicher.

Im nachfolgenden Beispiel habe ich für die vier Grundrechenarten Funktionen geschrieben; einmal mit klassischen Funktionen, die über das "def" Keyword definiert worden sind. Und im Folgenden einmal über die Lambda-Funktion.

Ihr könnt in dem Beispiel acht Zeilen sehen, die ohne Probleme über die Lambda-Funktion eingespart werden können.

def add(x,y):
    return x + y

def sub(x,y):
    return x - y

def mul(x,y):
    return x * y

def div(x,y):
    return x / y

operators = { "+":add,"-":sub,"*":mul,"/":div}

print(operators["*"](5,5))

## Print >> 25

In diesem Beispiel habe ich nun den Operatoren direkt die Funktionen zugeordnet, so haben wir eine deutliche Ersparnis an Zeilen.

operators = { "+":lambda a,b : a+b,"-":lambda a,b : a-b,"*": lambda a,b: a*b,"/": lambda a,b: a/b}

operators["*"](5,5)

## Print >> 25

Durch die Codeersparnis und die direkte Zuordnung von Keys ist es einfacher nachzuvollziehen, wofür "+" steht. Das könnte natürlich auch ein total abstrakter Name sein, wo es dann durch die inline-Funktion einfacher zu verstehen wäre.

Die Map Funktion

Die Map-Funktion in Kombination mit Lambda ist äußerst interessant, da es direkt zeigt, mit welcher Formel die Liste behandelt wird. Als erstes wird bei der Map-Funktion eine Funktion übergeben. Diese Funktion sollte so viele Parameter wie später angehängte Listen haben. Und diese können dann zum Beispiel addiert werden.

In unserem Beispiel benutzen wir allerdings die Lambda-Funktion. Als Werte erstellen wir uns eine Liste mit zwei Listen in der Range von 10 bis exclusive 15.

numbers = [range(10,15),range(10,15)]

print(list(map(lambda a,b: a+b,numbers[0],numbers[1])))

## Print >> [20, 22, 24, 26, 28]

Seit Python 3 gibt die Map-Funktion keine direkte Liste oder ähnliches zurück. Es ist noch immer ein Objekt. Um nun das Ergebnis als Liste zu erhalten, müssen wir eine Typenumwandlung zur Liste vornehmen. Diese gilt ebenfalls für die Filterfunktion im nachfolgenden Beispiel.

Die Filterfunktion zum Filtern

Ein weiteres schönes Beispiel für den Lambda Operator und seine Sinnhaftigkeit ist die Filterfunktion. Wie auch bei der Map-Funktion können wir uns dadurch Code sparen. Die Filterfunktion erwartet eine Funktion, die einen Wahrheitswert (Boolen) zurückgibt, als zweiten Parameter wird eine Itterierbare Liste erwartet. Dann kann die Filterfunktion die einzelnen Werte prüfen!

print(list(filter(lambda x: x > 13,range(10,20)))

## Print >> [14, 15, 16, 17, 18, 19]

Diese Filterfunktion könnt ihr nun wieder eine Liste für die Ausgabe umwandeln.

Die Reduce-Funktion zur Addition von Objekten

Bei der Reduce-Funktion wird die angegebene Funktion, in unserem Fall eine Lambda-Funktion, auf die ersten beiden Werte der Liste angewendet und nun das Ergebnis wieder mit dem nächsten Listenpunkt zusammengearbeitet.

from functools import reduce

lst = [100,200,300,400]

print(reduce(lambda x,y: x+y,lst))

## Print -> 1000