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

Lambda-Funktionen in Python sind echt starke, knackige Tools, um schnell kleine, anonyme Funktionen zu erstellen. Sie sind super, um kurzfristige Aufgaben zu vereinfachen, Code mit höheren Funktionen wie map, filter oder sorted zu optimieren und Unordnung bei der Definition von temporärer oder wegwerfbarer Logik zu reduzieren. Sie bieten auch eine coole Lösung, um die Lesbarkeit von Code in einfachen Fällen zu verbessern. In diesem Artikel geht's darum, was Lambda-Funktionen sind, was sie ausmacht und wie man sie am besten nutzt.

In diesem Leitfaden zeigen wir dir alles über Lambda-Funktionen in Python, wie sie funktionieren, ihre Syntax und wie sie im Vergleich zu Standardfunktionen sind, mit einfachen Beispielen, um die wichtigsten Konzepte zu erklären. Wir schauen uns gängige Anwendungsfälle an, wie zum Beispiel die Verwendung von Lambda-Funktionen in funktionalen Programmierparadigmen und ihre Effizienz im Vergleich zu Standardfunktionen. Es gibt praktische Beispiele und bewährte Vorgehensweisen, die dir helfen, Lambda-Funktionen effektiv in deine Python-Programme einzubauen. Python-Programmierungintegrieren können.

Was ist eine Lambda-Funktion in Python?

Lambda-Funktionen unterscheiden sich in ein paar wichtigen Punkten von normalen Python-Funktionen. Das sind anonyme Ausdrücke, was heißt, dass sie keinen Namen haben, es sei denn, man gibt ihnen explizit einen Namen für eine Variable. Außerdem sind sie prägnanter und werden in einer einzigen Zeile definiert, ohne dass eine Anweisung return nötig ist. Das macht sie super für einfache, einmalige Operationen und als Inline-Argumente in höheren Funktionen wie map, filter und sorted.

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

fn = lambda x, y: x + y
print(fn)

# <function <lambda> at 0xe508b8>

Wie Lambda-Funktionen funktionieren

Wie läuft diese Lambda-Funktion ab? Um das zu verstehen, schauen wir uns mal eine normale Python-Funktion an.

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

Diese Standardfunktion ist echt einfach. Das Schlüsselwort def definiert die Funktion, die zwei Argumente nimmt: x und y. Es rechnet die Summe von x und y aus und gibt das Ergebnis zurück.

Schauen wir uns jetzt mal an, wie unsere Lambda-Funktion dieselbe Aufgabe erledigt.

# Example: add two numbers using a lambda function
fn = lambda x, y: x + y
print(fn)

# <function <lambda> at 0xbfb968>

Das Schlüsselwort lambda zeigt an, dass wir eine Lambda-Funktion definieren, sodass wir das Schlüsselwort def nicht mehr brauchen. Nach dem Schlüsselwort lambda kommen die Eingabeargumente x und y. Nach dem Doppelpunkt geben wir den Ausdruck an, dessen Ergebnis zurückgegeben wird: x + y.

Lambda-Funktionen in Python schreiben: Beispiele

Damit du die bisher behandelten Konzepte besser verstehst, 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 super, um kurze, einfache Funktionen ohne viel Schnickschnack zu erstellen. 

Angenommen, du willst prüfen, ob eine bestimmte ganze Zahl ungleich Null gerade ist. Du könntest eine normale Python-Funktion schreiben, aber das Gleiche geht auch mit einer kurzen Einzeiler-Lambda-Funktion, die du einer Variablen zuweist: 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 (also wenn der Rest bei Division durch 2 gleich 0 ist). 

Diese Lambda-Funktion wird dann der Variablen is_even zugewiesen, sodass 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 sind auch super, um einfache Formeln zu definieren. Um zum Beispiel Celsius in Fahrenheit umzurechnen, kannst du eine Lambda-Funktion verwenden: c_to_f = lambda c: (c * 9/5) + 32. Dann rufst du die Funktion wie jede andere Funktion auf: c_to_f(0).

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

Lambda-Funktionen werden oft in der funktionalen Programmierung benutzt. funktionaler Programmierung, vor allem mit Funktionen wie map() und filter(), die andere Funktionen als Argumente nehmen, um Elemente in einer Sammlung zu bearbeiten. Schauen wir mal, wie man eine Lambda-Funktion mit filter() benutzt. Hier ist ein Code-Schnipsel:

# 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 fangen wir damit an, eine Reihe von numbers zu definieren. Als Nächstes machen wir eine Lambda-Funktion, um zu checken, ob eine Zahl gerade ist. Die Funktion filter wendet diese Lambda-Funktion auf den Satz numbers an. Dann drucken wir die Liste der geraden Zahlen, die die Funktion filter gefunden hat.

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

# 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() benutzt, die die Elemente einer Sammlung sortiert, um eine neue Sammlung zurückzugeben. Im folgenden Beispiel (ohne Lambda) sortieren wir eine Liste von Zahlen mit der Funktion sorted().

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 ihrem absoluten Wert sortieren. Wie könnten wir das schaffen? Die Funktion sorted() hat ein Argument namens key, 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 weiterer Anwendungsfall für sort() mit einer lambda Funktion ist das Sortieren einer Liste von Tupeln nach einem bestimmten Element, zum Beispiel 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 Codeausschnitt definieren wir data als eine Liste von Tupeln. Dann nehmen wir die Funktion sorted() mit dem Parameter key, wo eine Lambda-Funktion das zweite Element jedes Tupels für die Sortierung herausnimmt.

Sind Lambda-Funktionen in Python schneller?

In Python sind Lambda-Funktionen nicht automatisch schneller als normale Funktionen, weil beide zu ähnlichem Bytecode kompiliert werden. Allerdings können sie den Aufwand ein bisschen reduzieren, wenn das Definieren einer vollständigen Funktion unnötigen Boilerplate-Code mit sich bringen würde.

Hier sind ein paar Testfälle, die Lambda-Funktionen mit normalen Python-Funktionen vergleichen. Der Code wurde auf meinem Laptop ausgeführt, einem MacBook Pro mit einem Apple M1 Pro-Chip, 16 GB Arbeitsspeicher 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 man keine separate benannte Funktion definieren und referenzieren, was sowohl den Boilerplate-Code als auch den Lookup-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 super für einmalige oder vorübergehende Sachen, weil man keinen richtigen def-Block braucht, was Zeit und Speicherplatz spart. Im folgenden Code-Block schauen wir uns an, wie eine Standardfunktion im Vergleich zu einer Lambda-Funktion abschneidet. Wir sortieren ein Wörterbuch mit einer Million Einträgen, wobei die Schlüssel zufällige zweistellige Codes 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 Übungen

Schauen wir uns ein paar praktische Beispiele an, um zu zeigen, wie Lambda-Funktionen in Python funktionieren. 

Praktische Beispiele

Lambda-Funktionen werden oft mit den eingebauten Python-Methoden benutzt. Schauen wir uns zum Beispiel mal an, wie man mit reduce() eine benutzerdefinierte Binärfunktion kumulativ auf die Elemente einer Sequenz anwendet.

# 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() oben wendet reduce() eine Funktion, hier durch ein Lambda gegeben, auf eine Menge von Elementen an.

Jetzt schauen wir uns eine andere eingebaute Python-Funktion an: zip(). Die Funktion zip macht aus den passenden Elementen mehrerer Listen Tupel. Zum Beispiel ist das Ergebnis von zip(['a', 'b', 'c'], [1, 2, 3]) [('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}.')

# The result of multiplying corresponding elements is [4, 10, 18].

Dieser Code rechnet das Produkt der entsprechenden Elemente aus zwei Listen aus: list1 und list2. Es nutzt zip(), um Elemente aus den Listen zu Tupeln zu kombinieren, 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

Stell dir vor, du hast einen Obststand und willst den Gesamtumsatz für jede Obstsorte berechnen.

Zuerst erstellen wir ein paar Verkaufsdatensätze. Dann nehmen 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 Syntax **record packt das ursprüngliche Wörterbuch aus und sorgt dafür, dass alle Schlüssel und Werte im neuen Wörterbuch erhalten bleiben. Zum Schluss drucken wir jeden Datensatz der umgewandelten Daten aus.

# 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},
]

# 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
	)
)

# 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, die Nutzer mit Lambda-Funktionen lösen können

Wenn du die Verwendung von Lambda-Funktionen üben möchtest, findest du hier einige Aufgaben zum Ausprobieren.

• Rechne aus, wie viel das Quadrat einer Zahl ist.
• Such von zwei Zahlen die größere raus.
• Schau mal, ob die Zahl ungerade ist.
• Nimm eine Liste mit positiven ganzen Zahlen und filter alle ungeraden Zahlen raus.
• Sortiere eine Liste von 3-Element-Tupeln nach ihrem dritten Element.
• Hol die Domain aus einer E-Mail-Adresse raus. Nimm zum Beispiel user@example.com und zieh daraus example.com raus.

Häufige Fehler mit Lambda

Schauen wir uns mal ein paar typische Fehler an, die Programmierer mit Lambdas machen, und wie man sie beheben kann.

1. Der erste Fehler ist, eine Lambda-Funktion zu benutzen, wenn sie nicht passt. Man sollte nicht vergessen, dass Lambda-Funktionen für kurze, einfache Aufgaben gedacht sind und nicht für komplexe Logik. Der folgende Codeausschnitt 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 Standard-Python-Funktion zu benutzen.

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 ist, die Syntax durcheinanderzubringen. Wenn du zum Beispiel das Schlüsselwort lambda vergisst, kommt es zu einem Fehler. Ein weiterer häufiger Syntaxfehler ist, die Eingabeargumente wegzulassen:

# 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 Eingabeargument einzubauen:

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

Ein guter Weg, solche Fehler zu finden, ist, bei der Entwicklung einfache Testfälle einzubauen.

print(list(squared))

3. Ein weiterer Fehler, auf den man achten sollte, ist, keine Logik für Randfälle einzubauen. Zum Beispiel geht dieser Code kaputt, wenn y gleich 0 ist. Die Lösung ist, einfach eine Anweisung if einzubauen, um den fehlerhaften Fall abzufangen, oder den Code in einen Ausnahmeblock zu packen.

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

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

# undefined

4. Ein etwas kniffligeres Problem ist, wenn man vergisst, den Iterator in eine Liste umzuwandeln, wenn man die Ergebnisse ausgibt. Die Funktion map() gibt zum Beispiel ein map-Objekt zurück, keine Liste. Um die Ergebnisse zu sehen, machst du aus dem map-Objekt ein list-Objekt.

# 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

# <map object at 0x106d2b0>

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

# [1, 4, 9]

Strategien zum Debuggen von Python-Lambda-Ausdrücken

Also, wie debuggen wir Lambdas? Hier sind ein paar Möglichkeiten.

• Schmeiß mal die Lambda-, raus. Mach es vorübergehend zu einer benannten Funktion, damit du es besser debuggen kannst.
• Verwende print-Anweisungen , um Zwischenwerte in höheren Funktionen 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 Drucken von Zwischenschritten ist, eine Anweisung print zusammen mit dem Ergebnis in ein Tupel einzufügen. Die gewünschte Ausgabe kann dann an die übergeordnete Funktion weitergeleitet 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 Zahlenliste auszugeben. Die Lambda-Funktion in filter hat ein Tupel: Das erste Element ist eine print-Anweisung, die die aktuelle Zahl und ob sie die Bedingung erfüllt (x >= 3) protokolliert, und das zweite Element ist die Bedingung selbst. 

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

Wenn du das Objekt filter in eine Liste umwandelst, werden alle Elemente ausgewertet, und für jede Zahl wird die Anweisung print ausgelöst. Dieser Ansatz hilft beim Debuggen der Logik, während die Funktionalität des Filtervorgangs erhalten bleibt.

Tipps für die Verwendung von Lambda-Funktionen

Die besten Vorgehensweisen für die Verwendung von Lambda-Funktionen bestehen darin, zu verstehen, wann sie sinnvoll sind und wann man sie lieber vermeiden sollte.

Wann man Lambda-Funktionen benutzt

• Kurze, einfache Logik. Perfekt für kurze Operationen, bei denen man keine komplette Funktionsdefinition braucht.
• Funktionen höherer Ordnung. Funktionieren super als Argumente für Funktionen höherer Ordnung wie map(), filter() oder sorted().
• Temporäre (Einmal-)Funktionen. Das ist praktisch, wenn eine Funktion nur einmal gebraucht wird und sie mit def zu definieren den Code unnötig unübersichtlich machen würde.
• Verbesserte Lesbarkeit. Gut für einfache Aufgaben, bei denen eine Lambda-Funktion den Code kompakt und übersichtlich hält.

Wann man Lambda-Funktionen meiden sollte

• Komplexe oder mehrzeilige Logik. Lambdas sind auf einen einzigen Ausdruck beschränkt und können bei komplizierteren Operationen schnell unlesbar werden.
• Wiederverwendbare oder benannte Funktionen. Wenn die Funktion wiederverwendet werden soll oder ein beschreibender Name sinnvoll ist, passt eine Standard- def -Funktion besser.
• Debugging oder Dokumentation. Lambda-Funktionen können keine Docstrings haben und sind im Vergleich zu benannten Funktionen manchmal schwieriger zu debuggen.

Um die Lesbarkeit und Wartbarkeit bei der Verwendung von Lambdas zu verbessern, solltest du diese bewährten Verfahren befolgen:

• Benutz beschreibende Namen , damit alles klar ist.
• Halte es einfach: Lambdas sollten am besten in eine Zeile passen und eine einfache Logik haben.
• Begrenze die Verschachtelung von: Vermeide es, Lambda-Funktionen in anderen Lambda-Funktionen oder komplexen Datenstrukturen zu verwenden, wenn es nicht unbedingt nötig ist.
• Leg mehr Wert auf Verständlichkeit als auf Prägnanz: Wenn die Verwendung eines Lambda die Lesbarkeit beeinträchtigt, ist es besser, eine benannte Funktion zu definieren.

Fazit

Python-Lambda-Funktionen sind echt praktisch, um kurze, anonyme Funktionen zu schreiben. Sie sind super in Situationen, wo man kurze, temporäre oder Inline-Operationen braucht, vor allem mit höheren Funktionen wie map, filter oder sorted.

Man sollte sie aber mit Bedacht einsetzen, weil komplexere Logik besser für Standardfunktionen passt, die mit def definiert sind. Wenn du ihre Stärken, Grenzen und Best Practices verstehst, kannst du Lambda-Funktionen effektiv nutzen, um sauberen, effizienten und wartungsfreundlichen Python-Code zu schreiben.

Wenn du mehr über Python-Funktionen wissen willst, schau dir die Ressourcen von DataCamp an.

• Python-Funktionen: Wie man Funktionen aufruft und schreibt
• Kurs zum Schreiben von Funktionen in Python
• Python-Daten-Grundlagen
• Grundlagen der Python-Programmierung
• Python für Entwickler – Kurs für Fortgeschrittene