So verwenden Sie Lambda-Funktionen in Python [With Examples]

von

In dieser Anleitung tauchen wir tief in die Welt der Lambda-Funktionen in Python ein. Wir werden die Syntax kennenlernen, die zum Definieren von Lambda-Funktionen erforderlich ist, und ihre vielfältigen Anwendungsmöglichkeiten anhand von praktischen Codebeispielen untersuchen.

Lambda-Funktionen in Python sind anonyme Funktionen, die sich durch ihre prägnante Schreibweise auszeichnen und hervorragend mit anderen nützlichen, integrierten Funktionen zusammenarbeiten. Am Ende dieser Lektion werden Sie in der Lage sein, Lambda-Funktionen zu definieren und zu verstehen, wann es sinnvoll ist, sie anstelle von herkömmlichen Python-Funktionen einzusetzen.

Los geht’s!

Lambda-Funktionen in Python: Syntax und Anwendungsbeispiele

Hier ist die grundlegende Struktur für die Definition einer Lambda-Funktion in Python:

lambda Parameter: Rückgabewert

Betrachten wir die einzelnen Bestandteile dieser Syntax:

  • Das Schlüsselwort lambda leitet die Definition einer Lambda-Funktion ein. Es folgt eine Liste von Parametern, die die Funktion entgegennimmt.
  • Ein Doppelpunkt (:) trennt die Parameter von dem Ausdruck, der den Rückgabewert bestimmt.

💡 Bei der Erstellung einer Lambda-Funktion ist es wichtig, dass der Rückgabewert durch die Auswertung eines Ausdrucks berechnet wird, der aus einer einzigen Codezeile besteht. Dies wird durch die Beispiele, die wir gleich behandeln, deutlicher.

Demonstrative Beispiele für Lambda-Funktionen in Python

Die beste Art, Lambda-Funktionen zu verstehen, ist, sie als alternative Implementierung von Standard-Python-Funktionen zu betrachten.

👩🏽‍💻 Sie können die Beispiele in einer Python-REPL oder einem Online-Python-Editor, wie dem von wdzwdz, direkt mitprogrammieren.

#1. Nehmen wir an, wir haben die folgende Funktion square(), die eine Zahl num als Eingabe nimmt und das Quadrat dieser Zahl zurückgibt.

def square(num):
    return num*num

Wir können die Funktion mit Argumenten aufrufen und uns von ihrer Funktionalität überzeugen.

>>> square(9)
81
>>> square(12)
144

Wir könnten diesem Lambda-Ausdruck einen Variablennamen zuordnen, z.B. square1, um die Funktionsdefinition expliziter zu gestalten: square1 = lambda num: num*num. Dann könnten wir die Funktion square1 mit einer beliebigen Zahl als Argument aufrufen. Aber, da Lambdas anonyme Funktionen sind, ist es ratsam, sie keiner Variablen zuzuweisen.

In der Funktion square() ist num der Parameter und num*num der Rückgabewert. Diese Elemente können wir nun in einen Lambda-Ausdruck integrieren und ihn wie folgt mit einem Argument aufrufen:

>>> (lambda num: num*num)(2)
4

Das ist das Prinzip eines „immediately invoked function expression“ (IIFE), bei dem wir eine Funktion unmittelbar nach ihrer Definition aufrufen.

#2. Als Nächstes wandeln wir die einfache Funktion add() um, die zwei Zahlen, num1 und num2, als Eingabe nimmt und ihre Summe num1 + num2 zurückgibt.

def add(num1,num2):
    return num1 + num2

Lassen Sie uns die Funktion add() mit zwei Zahlen als Argumente aufrufen:

>>> add(4,3)
7
>>> add(12,5)
17
>>> add(12,6)
18

Hier sind num1 und num2 die beiden Parameter, und der Rückgabewert ist num1 + num2.

>>> (lambda num1, num2: num1 + num2)(3,7)
10

Python-Funktionen können auch Standardwerte für Parameter definieren. Verändern wir die Definition der Funktion add() und setzen den Standardwert des Parameters num2 auf 10.

def add(num1, num2=10):
    return num1 + num2

In den folgenden Funktionsaufrufen gilt:

  • Beim ersten Aufruf ist num1 gleich 1 und num2 gleich 3. Da der Wert für num2 im Funktionsaufruf angegeben wurde, wird dieser verwendet; die Funktion gibt 4 zurück.
  • Wenn wir jedoch nur ein Argument (num1 gleich 7) übergeben, wird der Standardwert 10 für num2 benutzt; die Funktion gibt 17 zurück.
>>> add(1,3)
4
>>> add(7)
17

Beim Erstellen von Funktionen, die Standardwerte für Parameter als Lambda-Ausdrücke nutzen, können diese Standardwerte direkt bei der Parameterdefinition angegeben werden.

>>> (lambda num1, num2 = 10: num1 + num2)(1)
11

Wann ist der Einsatz von Lambda-Funktionen in Python sinnvoll?

Nachdem wir nun die Grundlagen von Lambda-Funktionen in Python behandelt haben, betrachten wir einige konkrete Anwendungsfälle:

  • Lambda-Funktionen sind ideal, wenn Sie eine Funktion benötigen, deren Rückgabeausdruck nur eine einzelne Codezeile umfasst, und diese Funktion nicht an anderer Stelle im gleichen Modul verwendet werden soll. Wir haben bereits einige Beispiele dafür gesehen.
  • Lambda-Funktionen sind besonders nützlich in Kombination mit eingebauten Funktionen wie map(), filter() und reduce().
  • Sie können Lambda-Funktionen einsetzen, wenn Sie Python-Datenstrukturen wie Listen oder Dictionaries sortieren möchten.

Verwendung von Python Lambda mit eingebauten Funktionen

1. Lambda in Verbindung mit map()

Die Funktion map() nimmt eine Iterable und eine Funktion entgegen und wendet die Funktion auf jedes Element der Iterable an:

Erstellen wir eine Liste von Zahlen und benutzen die Funktion map(), um eine neue Liste zu generieren, die das Quadrat jeder Zahl aus der ursprünglichen Liste enthält. Beachten Sie die Verwendung der Lambda-Funktion, um die Quadrierungsoperation zu definieren.

>>> nums = [4,5,6,9]
>>> list(map(lambda num:num*num,nums))
[16, 25, 36, 81]

Da die Funktion map() ein Map-Objekt zurückgibt, müssen wir dieses in eine Liste konvertieren.

▶️ Vertiefen Sie Ihr Wissen mit dieser ausführlichen Anleitung zur Funktion map() in Python.

2. Lambda in Verbindung mit filter()

Definieren wir nums als eine Liste von Zahlen:

>>> nums = [4,5,6,9]

Nehmen wir an, wir wollen diese Liste filtern und nur die ungeraden Zahlen beibehalten.

Dafür können wir die eingebaute filter()-Funktion von Python nutzen.

Die Funktion filter() erwartet eine Bedingung und eine Iterable: filter(bedingung, iterable). Das Ergebnis beinhaltet nur die Elemente der ursprünglichen Iterable, die die Bedingung erfüllen. Das zurückgegebene Objekt lässt sich dann in eine Python-Iterable, wie z.B. eine Liste, umwandeln.

Um alle geraden Zahlen herauszufiltern, möchten wir nur die ungeraden Zahlen behalten. Der Lambda-Ausdruck sollte also lambda num: num%2!=0 lauten. Der Ausdruck num%2 liefert den Rest, der bei der Division von num durch 2 entsteht.

  • num%2!=0 ist True, wenn num ungerade ist, und
  • num%2!=0 ist False, wenn num gerade ist.
>>> nums = [4,5,6,9]
>>> list(filter(lambda num:num%2!=0,nums))
[5, 9]

3. Lambda in Verbindung mit reduce()

Die Funktion reduce() nimmt eine Iterable und eine Funktion als Eingabe. Sie reduziert die Iterable durch iteratives Anwenden der Funktion auf ihre Elemente.

Um die Funktion reduce() nutzen zu können, müssen wir sie aus dem eingebauten functools-Modul von Python importieren:

>>> from functools import reduce

Wir verwenden nun reduce(), um die Summe aller Zahlen in der nums-Liste zu berechnen. Wir definieren einen Lambda-Ausdruck: lambda num1,num2:num1+num2 als die Funktion, die die Summe bildet.

Die Reduktionsoperation erfolgt wie folgt: f(f(f(4,5),6),9) = f(f(9,6),9) = f(15,9) = 24. Hierbei ist f die Summenbildung der beiden Elemente der Liste, definiert durch die Lambda-Funktion.

>>> from functools import reduce
>>> nums = [4,5,6,9]
>>> reduce(lambda num1,num2:num1+num2,nums)
24

Python Lambda-Funktionen zur Anpassung von Sortierungen

Neben der Verwendung von Lambda-Funktionen mit eingebauten Python-Funktionen wie map(), filter() und reduce(), können Sie diese auch einsetzen, um das Sortierverhalten von integrierten Funktionen und Methoden zu konfigurieren.

1. Sortieren von Python-Listen

Bei der Arbeit mit Python-Listen ist es oft nötig, diese nach bestimmten Kriterien zu sortieren. Um Python-Listen direkt zu sortieren, können Sie die eingebaute Methode sort() verwenden. Wenn Sie eine sortierte Kopie der Liste benötigen, nutzen Sie die Funktion sorted().

Die Syntax für die Verwendung der Funktion sorted() lautet: sorted(iterable, key=…, reverse= True | False).

  • Der Parameter key wird verwendet, um die Sortierung zu individualisieren.
  • Der Parameter reverse kann auf True oder False gesetzt werden; der Standardwert ist False.

Beim Sortieren von Listen von Zahlen und Strings erfolgt die Sortierung standardmäßig in aufsteigender bzw. alphabetischer Reihenfolge. Manchmal ist es jedoch notwendig, ein eigenes Sortierkriterium zu definieren.

Betrachten wir die folgende Liste von fruits. Nehmen wir an, wir möchten eine sortierte Kopie der Liste haben, bei der die Strings nach der Häufigkeit des Auftretens des Buchstabens „p“ sortiert werden – in absteigender Reihenfolge.

>>> fruits = ['apple','pineapple','grapes','mango']

Hier kommt der optionale Parameter key ins Spiel. Ein String ist in Python eine Iterable, und um die Anzahl der Vorkommen eines Zeichens darin zu bestimmen, verwenden wir die eingebaute Methode .count(). Wir setzen also key auf lambda x:x.count('p'), so dass die Sortierung nach der Häufigkeit des Vorkommens von „p“ in einem String erfolgt.

>>> fruits = ['apple','pineapple','grapes','mango']
>>> sorted(fruits,key=lambda x:x.count('p'),reverse=True)
['pineapple', 'apple', 'grapes', 'mango']

In diesem Beispiel gilt:

  • Der Schlüssel für die Sortierung ist die Anzahl der Vorkommen des Zeichens „p“, definiert als Lambda-Ausdruck.
  • Da der Parameter reverse auf True gesetzt ist, erfolgt die Sortierung in absteigender Reihenfolge der Anzahl der „p“.

In der fruits-Liste enthält „pineapple“ drei „p“, während „apple“, „grapes“ und „mango“ zwei, eines bzw. kein „p“ enthalten.

Verständnis von Stable Sort

Betrachten wir ein weiteres Beispiel. Unter Verwendung des gleichen Sortierkriteriums haben wir die fruits-Liste neu definiert. Hier kommt der Buchstabe „p“ zweimal in „apple“ bzw. einmal in „grapes“ vor. In den Strings „mango“ und „melon“ kommt er gar nicht vor.

>>> fruits = ['mango','apple','melon','grapes']
>>> sorted(fruits,key=lambda x:x.count('p'),reverse=True)
['apple', 'grapes', 'mango', 'melon']

In der ausgegebenen Liste steht „mango“ vor „melon“, obwohl beide kein „p“ enthalten. Aber warum ist das so? Die Funktion sorted() führt eine stabile Sortierung durch. Wenn also die Anzahl der „p“ für zwei Strings gleich ist, bleibt die ursprüngliche Reihenfolge dieser Elemente in der Liste erhalten.

Als schnelle Übung können Sie die Positionen von „mango“ und „melon“ in der fruits-Liste tauschen, die Liste nach demselben Kriterium sortieren und die Ausgabe beobachten.

▶️ Erfahren Sie mehr über das Sortieren von Python-Listen.

2. Sortieren eines Python-Dictionaries

Lambda-Funktionen können auch beim Sortieren von Python-Dictionaries verwendet werden. Betrachten wir das folgende Dictionary price_dict, das Artikel und deren Preise enthält.

>>> price_dict = {
... 'Milk':10,
... 'Honey':15,
... 'Bread':7,
... 'Candy':3
... }

Um die Schlüssel-Wert-Paare eines Dictionaries als Liste von Tupeln zu erhalten, können Sie die eingebaute Dictionary-Methode .items() nutzen:

>>> price_dict_items = price_dict.items()
dict_items([('Milk', 10), ('Honey', 15), ('Bread', 7), ('Candy', 3)])

In Python folgen alle Iterables: Listen, Tupel, Strings usw. der Nullindizierung. Das erste Element befindet sich also an Index 0, das zweite Element an Index 1 usw.

Wir möchten nach dem Wert sortieren, der dem Preis jedes Elements im Dictionary entspricht. In jedem Tupel der Liste price_dict_items ist das Element an Index 1 der Preis. Daher setzen wir key auf lambda x:x[1], da dies das Element an Index 1, den Preis, für die Sortierung des Dictionaries verwendet.

>>> dict(sorted(price_dict_items,key=lambda x:x[1]))
{'Candy': 3, 'Bread': 7, 'Milk': 10, 'Honey': 15}

In der Ausgabe wurden die Dictionary-Einträge in aufsteigender Reihenfolge der Preise sortiert: beginnend mit „Candy“ zu einem Preis von 3 Einheiten bis zu „Honey“ zu einem Preis von 15 Einheiten.

▶️ Erfahren Sie mehr in dieser detaillierten Anleitung zum Sortieren eines Python-Dictionaries nach Schlüssel und Wert.

Zusammenfassung

Und das war es! Wir haben gelernt, wie man Lambda-Funktionen definiert und sie effektiv mit anderen eingebauten Python-Funktionen einsetzt. Hier ist eine Zusammenfassung der wichtigsten Erkenntnisse:

  • In Python sind Lambda-Funktionen anonyme Funktionen, die mehrere Argumente entgegennehmen und einen Wert zurückgeben können; der Ausdruck, der den Rückgabewert bestimmt, sollte aus einer einzigen Codezeile bestehen. Sie können verwendet werden, um kleine Funktionsdefinitionen prägnanter zu gestalten.
  • Zur Definition einer Lambda-Funktion kann die folgende Syntax genutzt werden: lambda Parameter: Rückgabewert.
  • Wichtige Anwendungsfälle sind die Verwendung mit den Funktionen map(), filter() und reduce() sowie als Schlüsselparameter zur individuellen Gestaltung der Sortierung von Python-Iterables.

Im nächsten Schritt werden wir uns damit beschäftigen, wie man die Ganzzahldivision in Python durchführt.

Weitere Artikel:

  1. Was ist ein Unterprozess in Python? [5 Usage Examples]
  2. Eine Einführung in AWS Lambda für Anfänger
  3. Moderne C++-Entwicklung: Lambda-Ausdrücke und Funktionsobjekte
  4. So schreiben Sie einen Elevator-Pitch [+ 7 Examples]