Lambda-Funktionen in Python

Einführung

In diesem Lab lernen Sie die Verwendung von Lambda-Funktionen in Python kennen. 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 eingebauten Python-Funktionen wie sorted verwendet werden können. Abschließend diskutieren wir Best Practices für die Verwendung von Lambda-Funktionen, 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, wobei der Schwerpunkt auf dem Schlüsselwort lambda liegt. Anonyme Funktionen sind Funktionen ohne Namen und bieten eine prägnante Möglichkeit, einfache Funktionen mit einem einzigen Ausdruck zu definieren.

In Python definieren wir Funktionen typischerweise mit dem Schlüsselwort def. Zum Beispiel sieht eine Funktion, die eine Zahl verdoppelt, wie folgt aus:

def double(x):
    return x * 2

print(double(10))

Für kleine Funktionen wie diese bietet lambda eine kompaktere Syntax. Erstellen wir dieselbe Funktion mit lambda.

Suchen Sie im WebIDE-Dateiexplorer auf der linken Seite die Datei ~/project/lambda_example1.py und öffnen Sie sie. 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))

Die Syntax lautet lambda Argumente: Ausdruck (lambda arguments: expression). Die Argumente sind die Eingaben, und der Ausdruck (expression) ist eine einzelne Operation, die ausgewertet und zurückgegeben wird. Beachten Sie, dass es kein return-Schlüsselwort gibt; die Rückgabe erfolgt implizit.

Speichern Sie die Datei. Um das Skript auszuführen, öffnen Sie das Terminal in der WebIDE und führen Sie den folgenden Befehl aus:

python3 ~/project/lambda_example1.py

Sie sollten die Ausgabe im Terminal sehen.

20

Dies demonstriert, wie eine Lambda-Funktion einer Variablen zugewiesen und wie eine reguläre Funktion aufgerufen werden kann.

Lambda-Funktionen mit unterschiedlichen Parametern erstellen

Lambda-Funktionen sind flexibel und können mit null, einem oder mehreren Parametern definiert werden. Sie sind jedoch immer auf einen einzigen Ausdruck beschränkt. In diesem Schritt werden wir die Erstellung von Lambdas mit unterschiedlichen Anzahlen von Parametern untersuchen.

Zuerst erstellen wir eine Lambda-Funktion, die keine Argumente entgegennimmt. Dies kann nützlich sein, um eine Konstante oder eine einfache, wiederholbare Aktion zu definieren.

Öffnen Sie die Datei ~/project/lambda_example2.py im Dateiexplorer. Fügen Sie den folgenden Code hinzu:

## Define a lambda function with no arguments
get_greeting = lambda: "Hello, World!"

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

Als Nächstes erstellen wir eine Lambda-Funktion, die mehrere Argumente akzeptiert. Wir definieren ein Lambda, das zwei Zahlen addiert. Fügen Sie diesen Code zur selben 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 nun das Skript im Terminal aus, um beide Ausgaben anzuzeigen:

python3 ~/project/lambda_example2.py

Das Terminal zeigt die Ergebnisse beider Lambda-Funktionen an.

Hello, World!
8

Dies zeigt, dass Lambda-Funktionen unterschiedliche Parameterkonfigurationen verarbeiten können, was sie vielseitig für verschiedene einfache Aufgaben macht.

Lambda mit der sorted() Funktion verwenden

Einer der häufigsten Anwendungsfälle für Lambda-Funktionen ist die Bereitstellung einer schnellen Inline-Funktion für Funktionen höherer Ordnung (Funktionen, die andere Funktionen als Argumente entgegennehmen). Ein Paradebeispiel ist die eingebaute Funktion sorted() von Python, die ein key-Argument akzeptieren kann. Der key gibt eine Funktion an, die für jedes Element aufgerufen wird, bevor Vergleichssortierungen vorgenommen werden.

Stellen Sie sich vor, Sie haben eine Liste von Tupeln, wobei jedes Tupel ein Produkt und seinen Preis darstellt. Sie möchten diese Liste nach dem Preis sortieren.

Öffnen Sie die Datei ~/project/lambda_sorted.py im Editor. Fügen Sie den folgenden Code hinzu:

## A list of tuples (product, price)
products = [('Laptop', 1200), ('Mouse', 25), ('Keyboard', 75)]

## Sort the list by price (the second element of each tuple) using a lambda function
sorted_products = sorted(products, key=lambda item: item[1])

## Print the sorted list
print(sorted_products)

In diesem Code weist key=lambda item: item[1] die Funktion sorted() an, das zweite Element (item[1], also den Preis) jedes Tupels als Wert für die Sortierung zu verwenden. Dies ist wesentlich prägnanter, als eine separate Funktion mit def zu definieren.

Speichern Sie die Datei und führen Sie sie im Terminal aus:

python3 ~/project/lambda_sorted.py

Sie werden die Liste der Produkte aufsteigend nach Preis sortiert sehen.

[('Mouse', 25), ('Keyboard', 75), ('Laptop', 1200)]

Dieses Muster ist äußerst verbreitet und nützlich, um komplexe Datenstrukturen auf einfache und lesbare Weise zu sortieren.

Fortgeschrittene Lambda-Techniken

In diesem Schritt untersuchen wir einige etwas fortgeschrittenere Möglichkeiten zur Verwendung von Lambda-Funktionen, einschließlich der Festlegung von Standardwerten für Parameter und der sofortigen Ausführung (Immediate Invocation) einer Lambda-Funktion.

Wie reguläre Funktionen können auch Lambda-Funktionen Parameter mit Standardwerten haben. Dies bietet einen Rückfallwert, falls während des Funktionsaufrufs kein Argument übergeben wird.

Öffnen Sie die Datei ~/project/lambda_advanced.py im Editor. Fügen Sie den folgenden Code hinzu:

## Define a lambda function with a default parameter value
power = lambda base, exponent=2: base ** exponent

## Call the lambda function without the optional argument (uses default)
print(power(3))

## Call the lambda function with both arguments
print(power(3, 3))

Eine weitere interessante Technik besteht darin, eine Lambda-Funktion zu definieren und sie sofort aufzurufen. Dies wird als Immediately Invoked Function Expression (IIFE) bezeichnet. Es kann nützlich sein, um eine temporäre Einwegfunktion zur Berechnung eines Wertes zu erstellen, ohne den Namespace zu überladen.

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

## Define and immediately invoke a lambda function to calculate a discounted price
price = 100
discount_percentage = 20
final_price = (lambda p, d: p * (1 - d / 100))(price, discount_percentage)

print(final_price)

Speichern Sie die Datei und führen Sie sie im Terminal aus:

python3 ~/project/lambda_advanced.py

Die Ausgabe zeigt die Ergebnisse beider Beispiele.

9
27
80.0

Obwohl diese Techniken die Flexibilität von Lambdas demonstrieren, denken Sie daran, dass Lesbarkeit der Schlüssel ist. Wenn die Logik komplex wird, ist eine Standardfunktion mit def oft die bessere Wahl.

Best Practices und Lesbarkeit

In diesem letzten Schritt besprechen wir Best Practices für die Verwendung von Lambda-Funktionen. Obwohl Lambdas ein mächtiges Werkzeug für das Schreiben von prägnantem Code sind, sollten sie überlegt eingesetzt werden, um die Lesbarkeit und Wartbarkeit zu gewährleisten.

Wann Lambda verwendet werden sollte:

• Als Argumente für Funktionen höherer Ordnung: Dies ist der primäre Anwendungsfall. Funktionen wie sorted(), map() und filter() sind perfekte Kandidaten für Lambdas.
• Einfache, kurze Operationen: Wenn die Logik bequem und klar in eine Zeile passt, ist ein Lambda eine gute Wahl.

Wann Lambda vermieden werden sollte:

• Komplexe Logik: Wenn Sie mehrere Anweisungen, komplexe bedingte Logik oder Schleifen benötigen, verwenden Sie immer eine def-Funktion.
• Lesbarkeitsbedenken: Wenn ein Lambda-Ausdruck auf den ersten Blick schwer zu verstehen ist, verfehlt er seinen Zweck. Eine benannte Funktion mit einem beschreibenden Namen ist besser.
• Wiederverwendbarkeit: Wenn Sie dieselbe Logik an mehreren Stellen benötigen, definieren Sie sie einmal mit def, um das Don't Repeat Yourself (DRY)-Prinzip zu befolgen.

Sehen wir uns ein gutes, lesbares Beispiel an, das den Best-Practice-Anwendungsfall verdeutlicht. Öffnen Sie die Datei ~/project/lambda_best_practice.py und fügen Sie den folgenden Code hinzu:

## A list of dictionaries
students = [
    {'name': 'Alice', 'grade': 88},
    {'name': 'Bob', 'grade': 95},
    {'name': 'Charlie', 'grade': 72}
]

## A good use of lambda: sorting a list of dictionaries by a value
sorted_by_grade = sorted(students, key=lambda student: student['grade'])

print("Sorted by grade:", sorted_by_grade)

## For comparison, a more complex task is better with a named function.
## For example, if you needed to apply a curve and check for a minimum score,
## a 'def' function would be much clearer than a complex lambda.
def process_grade(student):
    curved_grade = student['grade'] * 1.05
    return max(curved_grade, 75) ## Ensure a minimum score

processed_grades = [process_grade(s) for s in students]
print("Processed grades:", processed_grades)

Speichern Sie die Datei und führen Sie sie aus:

python3 ~/project/lambda_best_practice.py

Sie sehen die folgende Ausgabe:

Sorted by grade: [{'name': 'Charlie', 'grade': 72}, {'name': 'Alice', 'grade': 88}, {'name': 'Bob', 'grade': 95}]
Processed grades: [92.4, 99.75, 75.60000000000001]

Der erste Teil zeigt eine klare und angemessene Verwendung von Lambda. Der zweite Teil veranschaulicht ein Szenario, in dem eine benannte Funktion besser geeignet ist. Priorisieren Sie immer das Schreiben von Code, der für Sie und andere leicht zu lesen und zu verstehen ist.

Zusammenfassung

In diesem Lab haben Sie die Grundlagen der Python-Lambda-Funktionen kennengelernt. Sie begannen damit, ihre Syntax zu verstehen und wie sie sich von Standardfunktionen unterscheiden, die mit def definiert werden. Sie übten die Erstellung von Lambdas mit null, einem und mehreren Parametern und sahen, wie sie Variablen zugewiesen und aufgerufen werden können.

Eine wichtige Erkenntnis war die praktische Anwendung von Lambda-Funktionen als Argumente für Funktionen höherer Ordnung, insbesondere bei sorted(), um Sortierlogik prägnant zu definieren. Wir haben auch fortgeschrittene Techniken wie Standardparameter und sofort aufgerufene Funktionsausdrücke (IIFE) untersucht. Abschließend haben Sie die Best Practices für die Verwendung von Lambdas überprüft und dabei betont, dass, obwohl sie für einfache Einwegfälle leistungsstark sind, Lesbarkeit und Wartbarkeit immer Vorrang haben sollten, wobei für komplexere Logik benannte Funktionen bevorzugt werden.