Wie nutzt man die Python Lambdas?

Python Lambdas sind sogenannte anonyme Funktionen mit denen man schnell Funktionen definieren kann, die mehrere Inputs haben können, aber nur einen Output. Solche anonymen Funktionen werden nicht nur in Python, sondern auch in anderen Programmiersprachen, wie Java, C# oder C++ verwendet.

Wie werden normale Funktionen in Python definiert?

In Python wird die Definition einer Funktion mit “def” gekennzeichnet. Anschließend wird ihr Name definiert und in runden Klammern die Argumente mit Namen aufgelistet. Die folgende Funktion mit dem Namen “sum” nimmt einfach zwei Argumente und addiert diese zusammen:

Der Vorteil an diesen Funktionen ist, dass sie über einen eindeutigen Namen aufgerufen werden können. Dieser hilft sowohl die Funktionalität besser zu umschreiben, als auch zu einem späteren Zeitpunkt wieder auf die Funktion zu referenzieren. Zusätzlich können auch die Argumente Namen haben, die helfen, das Resultat besser zu verstehen. Ein weiterer Vorteil ist, dass explizit definierte Funktionen auch mehr als ein Argument ausgeben können.

Unsere anfängliche Funktion beispielsweise kann neben der Summe auch zusätzlich noch die Differenz der beiden Argumente ausgeben:

Was sind anonyme Funktionen?

Es gibt jedoch auch eine zweite Art, wie Funktionen in Python definiert werden können. Mithilfe von sogenannten anonymen Funktionen können diese mit wenigen Zeilen, meist sogar nur einer einzigen, definiert werden. Diese anonymen Funktionen gibt es auch in anderen Programmiersprachen, wie Java oder C#. In Python nutzt man dafür das Argument “lambda”, weshalb anonyme Funktionen in Python auch oft lediglich Python Lambdas genannt werden.

Diese Funktionen lassen sich ganz einfach mit dem Parameter “lambda”, der Nennung der Variablen und dem Ausdruck, den die Funktion berechnen soll definieren:

An diesem Beispiel erkennt man auch deutlich, warum Python Lambdas anonyme Funktionen sind: Der Funktion selbst kann man nämlich keinen Namen geben, man kann sie lediglich in einer Variablen (“function”) abspeichern.

Wenn wir also die Summenfunktion aus unserem anfänglichen Beispiel mithilfe von Python Lambdas nachbauen wollen, sieht das folgendermaßen aus:

Wie man sieht, können auch mehr als ein Argument an Python Lambdas weitergegeben werden. Die Funktion “sum_difference” können wir jedoch nicht mit Python Lambdas nachbauen, da die anonymen Funktionen immer nur ein Resultat ausgeben können. Stattdessen müssen also zwei unterschiedliche Funktionen definiert werden und auch doppelt gerufen werden:

Warum sollte man Python Lambdas nutzen?

Es gibt verschiedene Fälle in denen es sinnvoll sein kann, Python Lambdas zu nutzen:

Wenn simple Funktionen definiert werden, die lediglich einen Output haben und eine geringe Zahl an Inputs. In großen Projekten kann es sinnvoll sein, eine solche Funktion nicht explizit zu definieren, um Platz zu sparen und nicht unnötig für Verwirrung zu sorgen. Des weiteren erspart man sich in umfangreichen Klassen Probleme bei der Vererbung etc.
Dasselbe Argument zieht auch dann, wenn Funktionen nur ein einziges Mal zum Einsatz kommen. Dann kann man auch auf die explizite Definition verzichten, da sowieso niemand mehr auf die Funktion zugreifen muss.
Zusätzlich können anonyme Funktionen dafür sorgen, dass der Inhalt der Funktion schneller und einfacher verständlich wird, da es in einer einzige Zeile definiert ist. Die explizite Definition von Funktionen kann dazu führen, dass eine gewisse Verständlichkeit verloren geht.
Darüber hinaus gibt es in Python Funktionen, wie beispielsweise “filter” oder “map”, die Funktionen als Input nehmen. In diesen Fällen ist es also sinnvoll, Python Lambda zu nutzen.

Was solltest Du in Bezug auf den Gültigkeitsbereich und den Abschluss beachten, wenn Du Python Lambdas verwendest?

Das Verständnis des Gültigkeitsbereichs und des Abschlusses von Python Lambdas ist entscheidend, um diese anonymen Funktionen effektiv zu nutzen. In Python folgen Lambdas denselben Regeln für den Gültigkeitsbereich und den Abschluss wie reguläre (benannte) Funktionen, aber ihre knappe Natur kann manchmal zu subtilen Unterschieden führen.

Gültigkeitsbereich von Lambdas:

Lokaler Gültigkeitsbereich: Lambdas können auf Variablen aus ihrem umgebenden lokalen Gültigkeitsbereich zugreifen. Das bedeutet, dass jede Variable, die in derselben Funktion oder im selben Block definiert ist, in dem die Lambda-Funktion definiert ist, innerhalb der Lambda verwendet werden kann.

Globaler Gültigkeitsbereich: Lambdas können auch auf Variablen aus dem globalen Gültigkeitsbereich zugreifen. Dies wird jedoch nicht als bewährte Praxis angesehen, da der Code weniger lesbar und wartbar werden kann.

Abschluss von Lambdas:

Ein Abschluss ist ein Funktionsobjekt, das Zugriff auf Variablen in seinem umgebenden lexikalischen Gültigkeitsbereich hat, auch wenn die umgebende Funktion ihre Ausführung abgeschlossen hat. Lambdas erstellen von Natur aus Abschlüsse, wenn sie auf Variablen aus einem umgebenden Gültigkeitsbereich verweisen.

In dem obigen Beispiel “schließt” die Lambda-Funktion lambda_function die Variable x ein. Auch nach dem Abschluss der outer_function behält die Lambda-Funktion den Zugriff auf den Wert von x in ihrem Abschluss bei. Das ist der Grund, warum sie x später als lf(5) verwenden kann.

Vorsichtsmaßnahmen:

Späte Bindung: Lambdas in Python verwenden eine späte Bindung für Variablenwerte. Das bedeutet, dass die Werte von Variablen zur Zeit der Ausführung der Lambda-Funktion gesucht werden, nicht zur Zeit ihrer Definition. Dies kann zu unerwartetem Verhalten führen, wenn sich der umgebende Gültigkeitsbereich zwischen der Erstellung und der Ausführung der Lambda ändert.

Um Probleme mit der späten Bindung zu vermeiden, kannst Du Standardargumente verwenden, um den aktuellen Wert der Variable zu erfassen:

Einkapselung: Obwohl Lambdas auf Variablen aus umgebenden Gültigkeitsbereichen zugreifen können, wird im Allgemeinen empfohlen, benannte Funktionen zu verwenden, wenn Du Logik oder Wartbarkeit einschließen möchtest, insbesondere bei komplexen Operationen.

Das Verständnis des Gültigkeitsbereichs und des Abschlusses von Lambdas ist entscheidend, um Code vorhersehbar und wartbar zu schreiben. Wenn sie richtig verwendet werden, bieten sie eine leistungsstarke Möglichkeit, prägnante Funktionen für spezifische Aufgaben zu erstellen.

Wie funktioniert die Funktion filter() mit Python Lambdas?

Die Funktion “filter()” kann genutzt werden, um eine Liste mit einer gewissen Bedingung zu filtern. Das Resultat ist eine neue Liste, die lediglich noch aus denen Elementen besteht, welche die Bedingung erfüllen. Ohne die explizite Funktion könnte man das auch wie folgt lösen:

Die Funktion “filter()” hat insgesamt zwei Inputs, zum einen die Liste, welche gefiltert werden soll, und zum anderen die Bedingung, die für die Filterung genutzt werden soll. Diese Filterbedingung muss dabei eine Funktion sein, weshalb sich Python Lambdas dafür anbietet:

Für solche Anwendungen sind Python Lambdas natürlich auch eine optimale Alternative.

Welche bewährten Methoden sollte man befolgen, wenn Du Python Lambdas verwendest?

Python Lambdas sind eine prägnante Möglichkeit, kleine, anonyme Funktionen zu erstellen, sollten jedoch sorgfältig verwendet werden, um die Code-Lesbarkeit und -Wartbarkeit zu gewährleisten. Hier sind einige bewährte Methoden und Richtlinien, die Du befolgen solltest, wenn Du mit Python Lambdas arbeitest:

Halte es einfach und kurz: Lambdas sind für kleine Einzeiler-Funktionen gedacht. Vermeide komplexe Logik oder mehrere Ausdrücke innerhalb einer Lambda-Funktion. Wenn Deine Funktion zu kompliziert wird, ist das ein Zeichen dafür, dass Du stattdessen eine reguläre benannte Funktion verwenden solltest.
Verwende sie mit Higher-Order-Funktionen: Lambdas glänzen, wenn sie mit Higher-Order-Funktionen wie map(), filter() und sorted() verwendet werden. Sie eignen sich hervorragend, um benutzerdefinierte Schlüsselfunktionen oder Filterbedingungen prägnant zu definieren.
Füge beschreibende Variablennamen hinzu: Wenn Du Lambdas Variablen zuweist oder sie als Argumente verwendest, gib beschreibende Variablennamen an. Dies verbessert die Code-Lesbarkeit.
Beachte PEP 8: Befolge den Python-Style-Guide PEP 8, der vorschlägt, Lambdas sparsam zu verwenden. Obwohl sie ein leistungsfähiges Werkzeug sind, kann übermäßiger Gebrauch den Code weniger lesbar machen.
Bevorzuge benannte Funktionen für die Wiederverwendbarkeit: Für Funktionen, die an mehreren Stellen wiederverwendet werden müssen, solltest Du benannte Funktionen mit def verwenden. Lambdas eignen sich am besten für einfache, einmalige Operationen.
Vermeide den Einsatz von Lambdas in komplexen Ausdrücken: Wenn Du komplexe Ausdrücke oder Verständlichkeit konstruierst, solltest Du in Erwägung ziehen, das Problem in kleinere, benannte Funktionen aufzuteilen. Dies verbessert die Code-Wartbarkeit und das Debugging.
Teste und dokumentiere: Wenn eine Lambda-Funktion eine wichtige Rolle in Deinem Code spielt, ziehe in Betracht, Unit-Tests hinzuzufügen und deren Zweck zu dokumentieren. Dies kann anderen Entwicklern helfen, ihre beabsichtigte Verwendung zu verstehen.
Verwende Lambdas zur Kapselung von Konstanten: Python Lambdas können Konstanten oder Standardwerte prägnant kapseln.
Sei Dir der Variablensichtbarkeit bewusst: Denke daran, dass Lambdas Variablen aus ihrem umgebenden Scope erfassen. Sei vorsichtig, wenn Du sie in Comprehensions oder Funktionen verwendest, in denen die Variablensichtbarkeit zu unerwartetem Verhalten führen kann.

Durch Befolgen dieser bewährten Methoden und Richtlinien kannst Du die Kraft von Python Lambdas nutzen und gleichzeitig sauberen, lesbaren und wartbaren Code beibehalten. Denke daran, dass Lambdas zwar elegant für einfache Operationen sein können, komplexe Aufgaben jedoch oft besser für reguläre benannte Funktionen geeignet sind. Das richtige Gleichgewicht zwischen Prägnanz und Klarheit ist der Schlüssel zu einer effektiven Verwendung von Python Lambdas.

Das solltest Du mitnehmen

Anonyme Funktionen werden genutzt, um schnell Funktionen definieren zu können, die keinen Namen tragen müssen.
Das kann sinnvoll sein, wenn Funktionen lediglich ein einziges Mal verwendet werden sollen oder man den Namespace von Variablen und Funktionen klein halten will.
In Python nutzt man anonyme Funktionen mit dem Parameter “lambda”, weshalb anonyme Funktionen in Python auch Python Lambdas genannt werden.

Vielen Dank an Deepnote für das Sponsoring dieses Artikels! Deepnote bietet mir die Möglichkeit, Python-Code einfach und schnell auf dieser Website einzubetten und auch die zugehörigen Notebooks in der Cloud zu hosten.