Python Lambda-Funktionen: Ein Leitfaden für Anfänger

Lambda-Funktionen in Python sind leistungsstarke, übersichtliche Werkzeuge, um kleine, anonyme Funktionen zu erstellen. Sie sind perfekt geeignet, um kurzfristige Aufgaben zu vereinfachen, den Code mit Funktionen höherer Ordnung wie map, filter oder sorted zu straffen und das Durcheinander bei der Definition von temporärer oder wegwerfbarer Logik zu reduzieren. Außerdem bieten sie eine elegante Lösung, um die Lesbarkeit des Codes in einfachen Szenarien zu verbessern. In diesem Artikel erfährst du, was Lambda-Funktionen sind, welche Eigenschaften sie haben und wie du sie effektiv nutzen kannst.

In diesem Handbuch stellen wir dir Lambda-Funktionen in Python vor und erläutern ihre Funktionsweise, ihre Syntax und ihren Vergleich mit Standardfunktionen anhand einfacher Beispiele. Praktische Beispiele und Best Practices helfen dir, Lambda-Funktionen effektiv in deine Programmierung zu integrieren. Python-Programmierung.

Was ist eine Lambda-Funktion in Python?

Lambda-Funktionen unterscheiden sich in einigen wichtigen Punkten von den Standard-Python-Funktionen. Sie sind anonyme Ausdrücke, d.h. sie haben keinen Namen, es sei denn, sie werden explizit einer Variablen zugewiesen. Sie sind außerdem prägnanter und werden in einer einzigen Zeile definiert, ohne dass eine return Anweisung erforderlich ist. Das macht sie ideal für einfache, einmalige Operationen und für die Verwendung als Inline-Argumente in Funktionen höherer Ordnung wie map, filter und sorted.

Hier ist ein Beispiel für eine Lambda-Funktion, die zwei Zahlen addiert:

lambda x, y: x + y

    (x, y)>

Wie Lambda-Funktionen funktionieren

Wie funktioniert diese Lambda-Funktion? Um sie zu verstehen, vergleichen wir sie mit einer Standard-Python-Funktion.

# Example: add two numbers using standard Python function
def add_numbers(x, y):
    return x + y

Diese Standardfunktion ist ganz einfach. Das Schlüsselwort def definiert die Funktion, die zwei Argumente benötigt, x und y. Sie berechnet die Summe von x und y und gibt das Ergebnis zurück.

Sehen wir uns nun an, wie unsere Lambda-Funktion die gleiche Aufgabe erfüllt.

# Example: add two numbers using a lambda function
lambda x, y: x + y

    (x, y)>

Das Schlüsselwort lambda bedeutet, dass wir eine Lambda-Funktion definieren, wodurch das Schlüsselwort def überflüssig wird. Nach dem Schlüsselwort lambda werden die Eingabeargumente x und y aufgeführt. Nach dem Doppelpunkt geben wir den Ausdruck an, dessen Ergebnis zurückgegeben werden soll, x + y.

Lambda-Funktionen in Python schreiben: Beispiele

Damit du dich mit den Konzepten, die wir bisher erforscht haben, vertraut machen kannst, schauen wir uns ein paar Beispiele an, wie Lambda-Funktionen in Python funktionieren. 

Schritt-für-Schritt-Anleitung zum Schreiben von Lambda-Funktionen

Lambda-Funktionen sind ideal, um kurze, unkomplizierte Funktionen ohne zusätzliche Komplexität zu erstellen. 

Nehmen wir zum Beispiel an, du willst prüfen, ob eine gegebene ganze Zahl ungerade ist. Du könntest eine Standard-Python-Funktion schreiben, aber die gleiche Funktionalität lässt sich auch mit einer prägnanten Einzeiler-Lambdafunktion erreichen, die einer Variablen zugewiesen wird: is_even = lambda x: x % 2 == 0. 

Hier nimmt die Lambda-Funktion auf der rechten Seite der Zuweisung eine Eingabe x und gibt True zurück, wenn x gerade ist (d.h. wenn der Rest bei der Division durch 2 0 ist). 

Diese Lambda-Funktion wird dann der Variablen is_even zugewiesen, damit sie wie eine normale Funktion aufgerufen werden kann. Zum Beispiel: is_even(5) (gibt False zurück) und is_even(678432) (gibt True zurück).

Lambda-Funktionen eignen sich auch hervorragend, um einfache Formeln zu definieren. Um zum Beispiel Celsius in Fahrenheit umzurechnen, könntest du eine Lambda-Funktion verwenden: c_to_f = lambda c: (c * 9/5) + 32. Du rufst die Funktion dann wie jede andere Funktion auf: c_to_f(0).

Häufige Anwendungsfälle für Lambda-Funktionen

Lambda-Funktionen werden oft in der funktionalen Programmierungverwendet, insbesondere bei Funktionen wie map() und filter(), die andere Funktionen als Argumente nehmen, um Elemente in einer Sammlung zu verarbeiten. Schauen wir uns an, wie man eine Lambda-Funktion mit filter() verwendet. Hier ist ein Codeschnipsel:

# Use filter with lambda function
numbers = [1, 2, 3, 4, 5, 6, 7, 8]
evens = filter(lambda x: x % 2 == 0, numbers)
print(list(evens))  # print the list of the filter object to see the result

    [2, 4, 6, 8]

In diesem Code beginnen wir mit der Definition einer Reihe von numbers. Als Nächstes erstellen wir eine Lambda-Funktion, die prüft, ob eine Zahl gerade ist. Die Funktion filter wendet diese Lambda-Funktion auf die Menge numbers an. Anschließend drucken wir die Liste der geraden Zahlen, die durch die Funktion filter identifiziert wurden.

Genauso können wir die Funktion map verwenden, um ein Lambda auf eine Sammlung von Elementen anzuwenden. Im folgenden Beispiel berechnen wir die Längen der Zeichenketten in einer Liste, indem wir die Funktion len() auf jedes Element zuordnen.

# Use map with lambda function
fruits = ['apple', 'banana', 'cherry']
lengths = list(map(lambda x: len(x), fruits))
print(lengths)

    [5, 6, 6]

Lambda-Funktionen werden auch mit der Funktion sorted() verwendet, die die Elemente einer Sammlung sortiert und eine neue Sammlung zurückgibt. Im folgenden Beispiel (ohne Lambda) verwenden wir die Funktion sorted(), um eine Liste von Zahlen zu sortieren.

numbers = [1, 10, -1, 3, -10, 5]
sorted_stuff = sorted(numbers)
print(sorted_stuff)

    [-10, -1, 1, 3, 5, 10]

Angenommen, wir wollen die Liste der Zahlen nach dem absoluten Wert sortieren. Wie würden wir das erreichen? Die Funktion sorted() enthält ein key Argument, mit dem wir die Sortierreihenfolge anpassen können, indem wir eine Lambda-Funktion angeben.

# Sort according to absolute value
sorted_numbers_absolute = sorted(numbers, key=lambda x: abs(x))
print(sorted_numbers_absolute)

    [1, -1, 3, 5, 10, -10]

Ein anderer Anwendungsfall für sort() mit einer lambda Funktion ist das Sortieren einer Liste von Tupeln nach einem bestimmten Element, z.B. dem zweiten.

# Sort a list of tuples by the second element
data = [(1, 3), (2, 1), (4, 2)]
sorted_data = sorted(data, key=lambda x: x[1])
print(sorted_data)

    [(2, 1), (4, 2), (1, 3)]

In diesem Codeschnipsel definieren wir data als eine Liste von Tupeln. Dann verwenden wir die Funktion sorted() mit dem Parameter key, wobei eine Lambda-Funktion das zweite Element jedes Tupels für die Sortierung extrahiert.

Sind Lambda-Funktionen in Python schneller?

In Python sind Lambda-Funktionen nicht per se schneller als Standardfunktionen, da beide in ähnlichen Bytecode kompiliert werden. Sie können jedoch den Overhead in Fällen verringern, in denen die Definition einer vollständigen Funktion unnötigen Ballast mit sich bringen würde.

Hier sind ein paar Testfälle, in denen Lambda-Funktionen mit Standard-Python-Funktionen verglichen werden. Der Code wurde auf meinem Laptop ausgeführt, einem MacBook Pro mit einem Apple M1 Pro Chip, 16 GB Speicher und macOS Sequoia 15.2.

Lambda-Funktionen können inline als anonyme Funktionen verwendet werden, wenn sie direkt an Funktionen höherer Ordnung wie map(), filter() oder sorted() übergeben werden. Dadurch muss keine separate benannte Funktion definiert und referenziert werden, was sowohl den Boilerplate-Code als auch den Nachschlage-Overhead reduziert.

import time

numbers = list(range(1, 1000000))

# Standard function
def double_standard(x):
    return x * 2

start = time.time()
map(double_standard, numbers)
print(time.time() - start)

# Lambda function
double_lambda = map(lambda x: x * 2, numbers)

start = time.time()
list(map(lambda x: x * 2, numbers))
print(time.time() - start)

    3.504753112792969e-05

    2.384185791015625e-05

Lambda-Funktionen sind ideal für die einmalige oder vorübergehende Verwendung, da sie die Notwendigkeit eines formalen def Blocks überflüssig machen und somit Zeit und Platz sparen. Im folgenden Codeblock vergleichen wir die Leistung einer Standardfunktion mit der einer Lambda-Funktion. Wir sortieren ein Wörterbuch mit einer Million Elementen, wobei die Schlüssel zufällige Codes aus zwei Buchstaben und die Werte zufällige ganze Zahlen sind.

import random
import string

# Generate a dictionary with elements of the form 'XX': number.
NUMBER_ITEMS = 1000000
items = {
    ''.join(random.choices(string.ascii_uppercase, k=2)): random.randint(1, 100)
    for _ in range(NUMBER_ITEMS)
}

# Standard function (extra definition step)
def sort_standard(item):
    return item[1]

print('Standard')
start = time.time()
sorted_items_standard = sorted(items, key=sort_standard)
print(time.time() - start)
print(sorted_items_standard[:5])
print()

# Lambda function
print('Lambda')
start = time.time()
sorted_items_lambda = sorted(items, key=lambda x: x[1])
print(time.time() - start)
print(sorted_items_lambda[:5])
print()

    Standard

    0.00011610984802246094

    ['OA', 'VA', 'XA', 'IA', 'BA']

    Lambda

    0.00011014938354492188

    ['OA', 'VA', 'XA', 'IA', 'BA']

Python Lambda-Funktionen: Beispiele und Praxis

Gehen wir noch ein paar praktische Beispiele durch, um zu zeigen, wie Lambda-Funktionen in Python funktionieren. 

Praktische Beispiele

Lambda-Funktionen werden oft mit eingebauten Python-Methoden verwendet. Betrachten wir zum Beispiel die Verwendung von reduce(), um eine benutzerdefinierte Binärfunktion kumulativ auf die Elemente einer Folge anzuwenden.

# Example: Use lambda function with built-in Python method reduce.
from functools import reduce

numbers = [5, -6, 2, 7]
total = reduce(lambda x, y: x + y, numbers)
print(f'The sum of the numbers is {total}.')

    The sum of the numbers is 8.

Ähnlich wie bei filter() oder map() wendet reduce() eine Funktion, hier ein Lambda, auf eine Menge von Elementen an.

Jetzt wollen wir uns eine weitere eingebaute Python-Funktion ansehen: zip(). Die Funktion zip paart entsprechende Elemente aus mehreren Listen zu Tupeln. Das Ergebnis von zip(['a', 'b', 'c'], [1, 2, 3]) ist zum Beispiel [('a', 1), ('b', 2), ('c', 3)].

# Example: Use lambda function with built-in Python method zip.
list1 = [1, 2, 3]
list2 = [4, 5, 6]

# Using zip and a lambda function to multiply corresponding elements
result = list(map(lambda x: x[0] * x[1], zip(list1, list2)))

print(f'The result of multiplying corresponding elements is {result}.')

Das Ergebnis der Multiplikation der entsprechenden Elemente ist [4, 10, 18].

Dieser Code berechnet das Produkt der entsprechenden Elemente aus zwei Listen, list1 und list2. Es verwendet zip(), um Elemente aus den Listen zu Tupeln zu paaren, wendet dann eine Lambda-Funktion mit map() an, um die gepaarten Elemente zu multiplizieren, und wandelt das Ergebnis schließlich in eine Liste um.

Beispiel aus der Praxis: Datenumwandlung

Nehmen wir an, du betreibst einen Obststand und möchtest den Gesamtumsatz für jede Obstsorte berechnen.

Lass uns zunächst einige Verkaufsdatensätze erstellen.

# Sample data: list of dictionaries representing sales records
sales_data = [
    {'fruit': 'peaches', 'price': 1.41, 'quantity': 3},
    {'fruit': 'pears', 'price': 1.21, 'quantity': 2},
    {'fruit': 'mangoes', 'price': 0.56, 'quantity': 3},
]

Jetzt verwenden wir map() mit einer Lambda-Funktion, um total_sales zu berechnen, indem wir den Preis und die Menge für jeden Artikel im Wörterbuch sales_data multiplizieren. Die **record Syntax packt das ursprüngliche Wörterbuch aus und stellt sicher, dass alle Schlüssel und Werte im neuen Wörterbuch erhalten bleiben.

# Using a lambda function to calculate total sales for each record
transformed_data = list(
                        map(
                            lambda entry: {**entry, 'total_sales': round(entry['price'] * entry['quantity'], 2)},
                            sales_data
                        )
                    )

Zum Schluss drucken wir jeden Datensatz der umgewandelten Daten aus.

# Print the transformed data
for record in transformed_data:
    print(record)

    {'fruit': 'peaches', 'price': 1.41, 'quantity': 3, 'total_sales': 4.23}

    {'fruit': 'pears', 'price': 1.21, 'quantity': 2, 'total_sales': 2.42}

    {'fruit': 'mangoes', 'price': 0.56, 'quantity': 3, 'total_sales': 1.68}

Einfache Probleme für Benutzer, die mit Lambda-Funktionen gelöst werden können

Wenn du den Umgang mit Lambda-Funktionen üben möchtest, findest du hier einige Aufgaben zum Ausprobieren.

• Bestimme das Quadrat einer Zahl.
• Finde bei zwei Zahlen die größere.
• Prüfe bei einer Zahl, ob sie ungerade ist.
• Filtere aus einer Liste von positiven ganzen Zahlen alle ungeraden Zahlen heraus.
• Sortiere eine Liste von 3-Element-Tupeln nach ihrem dritten Element.
• Extrahiere die Domäne aus einer E-Mail Adresse. Zum Beispiel: user@example.com, extrahiere example.com.

Häufige Fehler im Zusammenhang mit Lambda

Schauen wir uns einige häufige Fehler an, die Programmierer mit Lambdas machen und wie man sie beheben kann.

1. Der erste Fehler ist, eine Lambda-Funktion zu verwenden, wenn sie unpassend ist. Es ist wichtig, daran zu denken, dass Lambda-Funktionen für kurze, einfache Aufgaben gedacht sind, nicht für die Verarbeitung komplexer Logik. Der folgende Codeschnipsel ist zum Beispiel kein idealer Anwendungsfall für eine Lambda-Funktion.

# Complex logic in a lambda
result = lambda x: (x ** 2 + x - 1) / (x + 1 if x != -1 else 1)
print(result(5))  # Hard to understand

    4.833333333333333

In diesem Fall ist es besser, einfach eine Standardfunktion von Python zu verwenden.

def complex_logic(x):
    if x == -1:
        return x ** 2 + x - 1
    return (x ** 2 + x - 1) / (x + 1)
print(complex_logic(5))

    4.833333333333333

2. Ein weiterer einfacher Fehler, den man machen kann, ist, die Syntax durcheinander zu bringen. Wenn du zum Beispiel das Schlüsselwort lambda vergisst, führt das zu einem Fehler. Ein weiterer häufiger Syntaxfehler ist das Weglassen des/der Eingabearguments/e:

# Forgetting the required arguments
numbers = [1, 2, 3, 4]
squared = map(lambda: x ** 2, numbers)  # <-- Where is the input argument? Error: lambda missing argument

Die Lösung ist, das Eingangsargument mit einzubeziehen:

squared = map(lambda x: x ** 2, numbers)

Ein guter Weg, um solche Fehler zu erkennen, ist die Einbeziehung informeller, einfacher Testfälle bei der Entwicklung.

print(list(squared))

    [1, 4, 9, 16]

3. Ein weiterer Fehler, auf den du achten solltest, ist, dass du keine Logik für Grenzfälle einbaust. Dieser Code schlägt zum Beispiel fehl, wenn y 0 ist.

# Dividing without handling zero
divide = lambda x, y: x / y

Die Lösung besteht darin, eine einfache if Anweisung einzufügen, um den fraglichen Fall abzufangen oder den Code in einen Ausnahmeblock zu verpacken.

safe_divide = lambda x, y: x / y if y != 0 else "undefined"
print(safe_divide(5, 0))

    undefined

4. Ein subtileres Problem ist, dass bei der Ausgabe der Ergebnisse vergessen wird, den Iterator in eine Liste umzuwandeln. Zum Beispiel gibt die Funktion map() ein map Objekt zurück, keine Liste.

# Forgetting to convert to a list
numbers = [1, 2, 3]
squared = map(lambda x: x ** 2, numbers)
print(squared)  # <-- squared is the map, not the result

Um auf die Ergebnisse zuzugreifen, wandle das map Objekt in ein list um.

print(list(squared))  # list(squared) gives the result

    [1, 4, 9]

Python Lambda Debugging-Strategien

Wie können wir also Lambdas debuggen? Hier sind einige Möglichkeiten.

• Zerlege das Lambda. Konvertiere sie zu Debugging-Zwecken vorübergehend in eine benannte Funktion.
• Verwenden Sie print-Anweisungen um Zwischenwerte in Funktionen höherer Ordnung wie map() oder filter() anzuzeigen.
• Teste Randfälle. Teste mit extremen, ungültigen oder Grenzwerten, um mögliche Fehler zu erkennen.

Ein nützlicher Trick zum Ausdrucken von Zwischenschritten ist es, neben dem Ergebnis eine print -Anweisung innerhalb eines Tupels einzufügen. Die gewünschte Ausgabe kann dann an die Funktion höherer Ordnung übergeben werden, indem das Tupel an Position 1 indiziert wird. 

Hier ist ein Beispiel:

numbers = [1, 2, 3, 4, 5]

# Lambda function with print to debug intermediate values
filtered_numbers = filter(lambda x: (print(f'Checking: {x} -> {x >= 3}'), x >= 3)[1], numbers)

# Converting filter object to list to force evaluation
print(list(filtered_numbers))

    Checking: 1 -> False

    Checking: 2 -> False

    Checking: 3 -> True

    Checking: 4 -> True

    Checking: 5 -> True

    [3, 4, 5]

In diesem Code wird ein Trick verwendet, um Zwischenschritte beim Filtern einer Liste von Zahlen zu drucken. Die Lambda-Funktion in filter enthält ein Tupel: Das erste Element ist eine print Anweisung, die die aktuelle Zahl protokolliert und angibt, ob sie die Bedingung erfüllt (x >= 3), und das zweite Element ist die Bedingung selbst. 

Das [1] am Ende des Lambdas stellt sicher, dass die Bedingung (x >= 3) an die Funktion filter zurückgegeben wird, während die Anweisung print zum Debuggen ausgeführt werden kann. 

Die Umwandlung des filter Objekts in eine Liste erzwingt die Auswertung aller Elemente und löst die print Anweisungen für jede Zahl aus. Dieser Ansatz hilft dabei, die Logik zu debuggen und gleichzeitig die Funktionalität des Filtervorgangs zu erhalten.

Best Practices für die Verwendung von Lambda-Funktionen

Zu den besten Praktiken für die Verwendung von Lambda-Funktionen gehört es, zu verstehen, wann sie angemessen sind und wann sie vermieden werden sollten.

Wann du Lambda-Funktionen verwenden solltest

• Kurze, einfache Logik. Ideal für prägnante Operationen, die keine vollständige Funktionsdefinition erfordern.
• Funktionen höherer Ordnung. Funktionieren effektiv als Argumente für Funktionen höherer Ordnung wie map(), filter() oder sorted().
• Temporäre (Wegwerf-)Funktionen. Nützlich, wenn eine Funktion nur einmal benötigt wird und die Definition mit def den Code unnötig unübersichtlich machen würde.
• Verbesserte Lesbarkeit. Geeignet für einfache Aufgaben, bei denen die Verwendung einer Lambda-Funktion den Code kompakt und übersichtlich hält.

Wann man Lambda-Funktionen vermeiden sollte

• Komplexe oder mehrzeilige Logik. Lambdas sind auf einen einzigen Ausdruck beschränkt und können für kompliziertere Operationen schnell unlesbar werden.
• Wiederverwendbare oder benannte Funktionen. Wenn die Funktion wiederverwendet werden soll oder von einem beschreibenden Namen profitiert, ist eine Standardfunktion def besser geeignet.
• Debugging oder Dokumentation. Lambda-Funktionen haben nicht die Möglichkeit, Docstrings einzubinden und können im Vergleich zu benannten Funktionen schwieriger zu debuggen sein.

Um die Lesbarkeit und Wartbarkeit bei der Verwendung von Lambdas zu verbessern, solltest du diese Best Practices befolgen:

• Verwende beschreibende Namen für Klarheit.
• Halte es einfach: Lambdas sollten idealerweise in eine Zeile passen und eine einfache Logik darstellen.
• Verschachtelung einschränken: Vermeide die Verwendung von Lambda-Funktionen innerhalb anderer Lambda-Funktionen oder komplexer Datenstrukturen, es sei denn, es ist notwendig.
• Ziehe die Lesbarkeit der Prägnanz vor: Wenn die Verwendung eines Lambdas die Lesbarkeit beeinträchtigt, ist es besser, eine benannte Funktion zu definieren.

Fazit

Python Lambda-Funktionen sind ein mächtiges Werkzeug, um prägnante, anonyme Funktionen zu schreiben. Sie glänzen in Szenarien, die kurze, temporäre oder Inline-Operationen erfordern, insbesondere wenn sie mit Funktionen höherer Ordnung wie map, filter oder sorted verwendet werden. 

Sie sollten jedoch mit Bedacht eingesetzt werden, da komplexere Logik besser für Standardfunktionen geeignet ist, die mit def definiert werden. Wenn du ihre Stärken, Grenzen und Best Practices kennst, kannst du Lambda-Funktionen effektiv nutzen, um sauberen, effizienten und wartbaren Python-Code zu schreiben.

Wenn du mehr über Python-Funktionen erfahren möchtest, schau dir die Ressourcen von DataCamp an.

• Python-Funktionen: Wie man Funktionen aufruft und schreibt
• Funktionen in Python schreiben Kurs
• Python Daten Grundlagen
• Grundlagen der Python-Programmierung
• Mittelstufen-Kurs Python für Entwickler