Lambda-Funktionen in Python verwenden

Einleitung

In diesem Lab lernen Sie, wie Sie Lambda-Funktionen in Python verwenden. Wir beginnen mit dem Verständnis des Konzepts anonymer Funktionen und des Schlüsselworts lambda und vergleichen diese mit traditionellen Funktionsdefinitionen. Anschließend erstellen Sie einfache Lambda-Funktionen mit unterschiedlicher Anzahl von Parametern.

Das Lab wird weiter untersuchen, wie Lambda-Funktionen effektiv mit integrierten Python-Funktionen wie sorted verwendet werden können. Abschließend werden wir Best Practices für die Verwendung von Lambda-Funktionen diskutieren, um sicherzustellen, dass Ihr Code lesbar und wartbar ist.

Anonyme Funktionen und Lambda verstehen

In diesem Schritt führen wir das Konzept anonymer Funktionen in Python ein und konzentrieren uns dabei speziell auf das Schlüsselwort lambda. Anonyme Funktionen sind Funktionen ohne Namen und bieten eine prägnante Möglichkeit, einfache Funktionen zu definieren.

In Python definieren wir Funktionen normalerweise mit dem Schlüsselwort def. Für kleine Funktionen mit einem einzigen Ausdruck bietet lambda jedoch eine kompaktere Syntax.

Beginnen wir mit der Definition einer einfachen Funktion mit def, die eine Zahl verdoppelt:

def double(x):
    return x * 2

print(double(10))

Nun erzielen wir dasselbe Ergebnis mit einer lambda-Funktion. Öffnen Sie das integrierte Terminal in der WebIDE und navigieren Sie zum Verzeichnis ~/project, falls Sie sich nicht bereits dort befinden.

Erstellen Sie eine neue Python-Datei namens lambda_example1.py im Verzeichnis ~/project über den Dateiexplorer der WebIDE. Öffnen Sie die Datei und fügen Sie den folgenden Code hinzu:

## Define a lambda function to double a number
double_lambda = lambda x: x * 2

## Call the lambda function and print the result
print(double_lambda(10))

Speichern Sie die Datei. Führen Sie nun das Skript im Terminal aus:

python ~/project/lambda_example1.py

Sie sollten die Ausgabe sehen:

20

In der lambda-Funktion lambda x: x * 2 ist lambda das Schlüsselwort, das zur Definition einer anonymen Funktion verwendet wird. x ist der Parameter, den die Funktion entgegennimmt, und x * 2 ist der Ausdruck, dessen Ergebnis von der Funktion zurückgegeben wird. Beachten Sie, dass kein return-Schlüsselwort vorhanden ist. Der Ausdruck nach dem Doppelpunkt wird implizit zurückgegeben.

Lambda-Funktionen werden oft verwendet, wenn eine kleine Funktion für kurze Zeit benötigt wird, typischerweise als Argument für höherwertige Funktionen (Funktionen, die andere Funktionen als Argumente entgegennehmen).

Einfache Lambda-Funktionen erstellen

Im vorherigen Schritt haben wir ein grundlegendes Beispiel für eine Lambda-Funktion mit einem einzelnen Parameter gesehen. In diesem Schritt werden wir die Erstellung einfacher Lambda-Funktionen mit unterschiedlicher Anzahl von Parametern untersuchen, einschließlich null Parametern und mehreren Parametern.

Lambda-Funktionen können null oder mehr Argumente haben, aber sie können nur einen einzigen Ausdruck enthalten.

Erstellen wir eine Lambda-Funktion, die keine Argumente entgegennimmt und einen einfachen booleschen Wert zurückgibt.

Erstellen Sie eine neue Python-Datei namens lambda_example2.py im Verzeichnis ~/project. Öffnen Sie die Datei und fügen Sie den folgenden Code hinzu:

## Define a lambda function with no arguments
always_true = lambda: True

## Call the lambda function and print the result
print(always_true())

Speichern Sie die Datei. Führen Sie das Skript im Terminal aus:

python ~/project/lambda_example2.py

Sie sollten die Ausgabe sehen:

True

Nun erstellen wir eine Lambda-Funktion, die mehrere Argumente entgegennimmt und eine Operation darauf ausführt. Wir erstellen eine Lambda-Funktion, die zwei Zahlen addiert.

Fügen Sie den folgenden Code zur Datei lambda_example2.py hinzu:

## Define a lambda function that adds two numbers
add_numbers = lambda x, y: x + y

## Call the lambda function with two arguments and print the result
print(add_numbers(5, 3))

Speichern Sie die Datei. Führen Sie das Skript erneut aus:

python ~/project/lambda_example2.py

Die Ausgabe sollte nun das Ergebnis der Addition enthalten:

True
8

Dies zeigt, dass Lambda-Funktionen mehrere Parameter, durch Kommas getrennt, genau wie reguläre Funktionsdefinitionen verarbeiten können. Der Ausdruck nach dem Doppelpunkt verwendet diese Parameter, um den Rückgabewert zu berechnen.

Lambda mit integrierten Funktionen verwenden (sortiert)

In diesem Schritt sehen wir einen gängigen und praktischen Anwendungsfall für Lambda-Funktionen: ihre Verwendung mit den integrierten Funktionen von Python, die eine Funktion als Argument akzeptieren. Ein hervorragendes Beispiel ist die Funktion sorted(), die ein key-Argument entgegennehmen kann, um eine Funktion anzugeben, die für jedes Listenelement aufgerufen wird, bevor Vergleiche durchgeführt werden.

Nehmen wir an, wir haben eine Liste von Zeichenketten und möchten diese basierend auf dem letzten Zeichen jeder Zeichenkette sortieren.

Zuerst sehen wir, wie wir dies mit einer regulären Funktion tun würden.

Erstellen Sie eine neue Python-Datei namens lambda_sorted.py im Verzeichnis ~/project. Öffnen Sie die Datei und fügen Sie den folgenden Code hinzu:

## List of strings
words = ['dog', 'abandon', 'cool', 'black']

## Define a regular function to get the last character
def get_last_char(s):
    return s[-1]

## Sort the list using the regular function as the key
sorted_words_def = sorted(words, key=get_last_char)

## Print the sorted list
print(sorted_words_def)

Speichern Sie die Datei. Führen Sie das Skript im Terminal aus:

python ~/project/lambda_sorted.py

Sie sollten die Ausgabe sehen:

['abandon', 'cool', 'black', 'dog']

Die Liste ist sortiert nach dem letzten Zeichen: 'n', 'l', 'k', 'g'.

Nun erzielen wir dasselbe Ergebnis mit einer lambda-Funktion. Wir können die Definition der Funktion get_last_char und ihre Verwendung im sorted()-Aufruf durch einen einzigen Lambda-Ausdruck ersetzen.

Fügen Sie den folgenden Code zur Datei lambda_sorted.py hinzu:

## Sort the list using a lambda function as the key
sorted_words_lambda = sorted(words, key=lambda s: s[-1])

## Print the sorted list
print(sorted_words_lambda)

Speichern Sie die Datei. Führen Sie das Skript erneut aus:

python ~/project/lambda_sorted.py

Die Ausgabe sollte dieselbe sein und die Kompaktheit der Verwendung einer Lambda-Funktion demonstrieren:

['abandon', 'cool', 'black', 'dog']
['abandon', 'cool', 'black', 'dog']

Die direkte Verwendung von lambda s: s[-1] innerhalb der sorted()-Funktion ist für diese einfache Operation kompakter und besser lesbar als die Definition einer separaten Funktion. Dies ist ein gängiges Muster, wenn die für das key-Argument benötigte Funktion einfach ist und nicht an anderer Stelle wiederverwendet wird.

Fortgeschrittene Lambda-Nutzung erkunden

In diesem Schritt betrachten wir einige etwas fortgeschrittenere Möglichkeiten, Lambda-Funktionen zu verwenden, einschließlich der Festlegung von Standard-Parameterwerten und der sofortigen Ausführung einer Lambda-Funktion.

Genau wie reguläre Funktionen können Lambda-Funktionen Parameter mit Standardwerten haben.

Erstellen Sie eine neue Python-Datei namens lambda_advanced.py im Verzeichnis ~/project. Öffnen Sie die Datei und fügen Sie den folgenden Code hinzu:

## Define a lambda function with a default parameter value
square_with_default = lambda x=5: x**2

## Call the lambda function without an argument (uses default)
print(square_with_default())

## Call the lambda function with an argument
print(square_with_default(3))

Speichern Sie die Datei. Führen Sie das Skript im Terminal aus:

python ~/project/lambda_advanced.py

Sie sollten die Ausgabe sehen:

25
9

Dies zeigt, dass der Standardwert x=5 verwendet wird, wenn kein Argument übergeben wird, und das übergebene Argument 3 den Standardwert überschreibt.

Eine weitere interessante Möglichkeit, Lambda-Funktionen zu verwenden, ist die Definition und sofortige Ausführung. Dies wird manchmal als Immediately Invoked Function Expression (IIFE) bezeichnet.

Fügen Sie den folgenden Code zur Datei lambda_advanced.py hinzu:

## Define and immediately invoke a lambda function
result = (lambda x: x * 10)(7)

## Print the result
print(result)

Speichern Sie die Datei. Führen Sie das Skript erneut aus:

python ~/project/lambda_advanced.py

Die Ausgabe sollte nun das Ergebnis der sofort aufgerufenen Lambda-Funktion enthalten:

25
9
70

Im Ausdruck (lambda x: x * 10)(7) wird die Lambda-Funktion lambda x: x * 10 in Klammern definiert und dann sofort mit dem Argument 7 aufgerufen. Dies kann nützlich sein, um temporäre, einmalig verwendbare Funktionen zu erstellen.

Obwohl diese Beispiele die Flexibilität von Lambda-Funktionen zeigen, denken Sie daran, dass ihr Hauptzweck für einfache, prägnante Operationen gedacht ist. Komplexe Logik sollte weiterhin durch reguläre benannte Funktionen für eine bessere Lesbarkeit gehandhabt werden.

Best Practices für die Verwendung von Lambda

In diesem letzten Schritt besprechen wir einige Best Practices und Überlegungen für die effektive Verwendung von Lambda-Funktionen in Ihrem Python-Code. Obwohl Lambda-Funktionen Prägnanz bieten, ist es wichtig, sie mit Bedacht einzusetzen, um die Lesbarkeit und Wartbarkeit des Codes zu gewährleisten.

Wann Lambda verwenden:

• Einfache, kurze Operationen: Lambda-Funktionen sind ideal für einfache Operationen, die in einer einzigen Zeile ausgedrückt werden können.
• Als Argumente für höherwertige Funktionen: Wie bei sorted() gesehen, ist Lambda sehr nützlich, wenn Sie eine kleine Funktion benötigen, die an eine andere Funktion wie map(), filter() oder reduce() übergeben wird.
• Für temporäre, einmalig verwendbare Funktionen: Wenn Sie eine Funktion nur einmal in einem bestimmten Kontext benötigen, kann ein Lambda prägnanter sein als die Definition einer vollständigen Funktion mit def.

Wann Lambda vermeiden:

• Komplexe Logik: Wenn die Funktion mehrere Anweisungen, Schleifen, bedingte Logik über einen einfachen Ausdruck hinaus erfordert oder schwer in einer einzigen Zeile zu verstehen ist, verwenden Sie eine reguläre def-Funktion.
• Lesbarkeit ist entscheidend: Obwohl Lambdas prägnant sein können, können übermäßig komplexe Lambda-Ausdrücke die Lesbarkeit beeinträchtigen. Wenn ein Lambda Ihren Code schwerer verständlich macht, verwenden Sie eine benannte Funktion.
• Wiederverwendbarkeit: Wenn Sie dieselbe Funktionslogik an mehreren Stellen in Ihrem Code benötigen, definieren Sie sie einmal mit def und verwenden Sie sie wieder.

Lassen Sie uns ein Szenario veranschaulichen, in dem ein Lambda weniger lesbar werden könnte.

Erstellen Sie eine neue Python-Datei namens lambda_bad_example.py im Verzeichnis ~/project. Öffnen Sie die Datei und fügen Sie den folgenden Code hinzu:

## A list of tuples (name, age)
people = [('Alice', 30), ('Bob', 25), ('Charlie', 35)]

## Sorting by age using lambda (good use case)
sorted_by_age = sorted(people, key=lambda person: person[1])
print("Sorted by age:", sorted_by_age)

## A less readable lambda example (avoid this complexity)
## This lambda checks if a number is even and greater than 10
## is_even_and_greater_than_10 = lambda num: True if num % 2 == 0 and num > 10 else False ## More readable with def

Speichern Sie die Datei. Führen Sie das Skript im Terminal aus:

python ~/project/lambda_bad_example.py

Sie sollten die Ausgabe sehen:

Sorted by age: [('Bob', 25), ('Alice', 30), ('Charlie', 35)]

Das erste Lambda, das mit sorted() verwendet wird, ist ein gutes Beispiel für seine Verwendung. Das auskommentierte Lambda ist zwar technisch möglich, aber weniger lesbar als die Definition einer Funktion mit def für dieselbe Logik.

Denken Sie daran, dass das Ziel darin besteht, klaren und wartbaren Code zu schreiben. Verwenden Sie Lambda-Funktionen als Werkzeug für Prägnanz, wenn es angebracht ist, aber priorisieren Sie Lesbarkeit und Klarheit, insbesondere bei komplexeren Operationen.

Zusammenfassung

In diesem Lab haben wir zunächst das Konzept anonymer Funktionen in Python verstanden, insbesondere mit dem Schlüsselwort lambda. Wir haben gelernt, dass Lambda-Funktionen eine prägnante Syntax für die Definition einfacher Funktionen mit einem einzigen Ausdruck ohne Namen bieten und sie mit traditionellen Funktionsdefinitionen mit def kontrastieren. Wir haben geübt, eine grundlegende Lambda-Funktion zum Verdoppeln einer Zahl zu erstellen und sie ausgeführt, um die Ausgabe zu sehen, wobei wir die implizite Rückgabe des Ausdrucksergebnisses beobachtet haben.

Nach dieser Einführung haben wir einfache Lambda-Funktionen mit unterschiedlichen Anzahlen von Parametern erstellt, einschließlich Beispielen mit null und mehreren Argumenten. Dieser Schritt festigte unser Verständnis der grundlegenden Syntax und Flexibilität von Lambda-Funktionen bei der Handhabung unterschiedlicher Eingabeanforderungen.