Lambda-Funktionen in Python (mit Beispielen)

Lambda-Funktionen gehören zu den Python-Funktionen, die auf den ersten Blick verwirrend aussehen, sich aber als überraschend einfach herausstellen. Dabei handelt es sich um kleine, anonyme Funktionen, die Sie in einer einzigen Zeile schreiben und sofort verwenden können.

In diesem Tutorial erfahren Sie, was Lambda-Funktionen sind, wie sie funktionieren und wann sie tatsächlich nützlich sind. Wir werden die häufigsten Anwendungsfälle abdecken (einschließlich filter(), map(), sorted()und Pandas), damit Sie Lambda-Funktionen in echtem Code erkennen und sie bedenkenlos verwenden können.

Was ist eine Lambda-Funktion in Python?

Eine Lambda-Funktion ist eine anonyme Funktion, das heißt, sie hat keinen Namen. Es kann eine beliebige Anzahl von Argumenten annehmen, wertet jedoch nur einen einzelnen Ausdruck aus und gibt das Ergebnis dieses Ausdrucks automatisch zurück.

Die allgemeine Syntax für eine Lambda-Funktion lautet: lambda parameters: expression. Hier ist ein einfaches Beispiel, das es aufschlüsselt:

Sie werden sehen, dass die Begriffe „Lambda-Ausdruck“ und „Lambda-Funktion“ synonym verwendet werden. Der Ausdruck ist die Syntax, die Sie schreiben. Die Funktion ist das Objekt, das Python daraus erstellt. Aus praktischer Sicht bedeuten sie dasselbe.

Jeder Lambda-Ausdruck besteht aus drei Teilen:

• Der lambda Stichwortwas Python mitteilt, dass Sie eine anonyme Funktion definieren (ähnlich wie def für reguläre Funktionen)
• Der Parameterdie genau wie Funktionsparameter funktionieren, durch Kommas getrennt
• Der Ausdruckdie automatisch ausgewertet und zurückgegeben wird

Im Gegensatz zu einer regulären Funktion verwenden Sie die nicht return Stichwort. Was auch immer der Lambda-Ausdruck ergibt, es kommt zurück.

Lambda-Funktionen vs. reguläre Funktionen

Bevor wir fortfahren, vergleichen wir eine Lambda-Funktion mit einer regulären Funktion, die mit definiert ist def. In dieser Tabelle werden die Unterschiede aufgeführt, auf die Sie am häufigsten stoßen:

Eine Sache, die es wert ist, hervorgehoben zu werden: Sie dürfen Weisen Sie einer Variablen ein Lambda zu, etwa so:

increment = lambda x: x + 1
increment(2)
# Output:
# 3

Aber PEP 8der offizielle Styleguide von Python, rät davon ab. Wenn Sie einer Variablen ein Lambda zuweisen, geben Sie einer anonymen Funktion lediglich einen Namen, was ihren Zweck zunichte macht. Wenn Sie eine benannte, wiederverwendbare Funktion benötigen, verwenden Sie def stattdessen.

Wie Lambda-Funktionen funktionieren

Sie können ein Lambda sofort aufrufen, indem Sie es in Klammern setzen:

(lambda x: x + 1)(2)
# Output:
# 3

Dieses Muster wird manchmal als ein bezeichnet sofort aufgerufener Funktionsausdruck (IIFE). Sie definieren die Funktion und rufen sie in derselben Zeile auf. Dies ist nützlich, wenn Sie eine schnelle Berechnung benötigen, ohne etwas zu speichern.

Lambda-Funktionen unterstützen auch mehrere Parameter. Trennen Sie sie durch Kommas, genau wie bei einer regulären Funktion:

(lambda x, y, z: x + y + z)(3, 8, 1)
# Output:
# 12

Ein Lambda kann auch mehrere Werte zurückgeben, indem es sie in ein Tupel einschließt:

(lambda x, y: (x + y, x * y))(3, 4)
# Output:
# (7, 12)

Sie können bedingte Logik auch innerhalb eines Lambda verwenden. Eine Single if/else ist perfekt lesbar und in der Praxis üblich:

(lambda x: x if x > 10 else 10)(5)
# Output:
# 10

Vermeiden Sie jedoch die Verschachtelung mehrerer Bedingungen in einem Lambda. Vergleichen Sie diese beiden Ansätze:

# Lambda with nested circumstances (onerous to learn)
(lambda x: x * 10 if x > 10 else (x * 5 if x < 5 else x))(11)
# Output:
# 110

# Common operate (a lot clearer)
def check_conditions(x):
    if x > 10:
        return x * 10
    elif x < 5:
        return x * 5
    else:
        return x

print(check_conditions(11))
# Output:
# 110

Beide kehren zurück 110aber die reguläre Funktion ist viel einfacher zu lesen und zu warten. Wenn Ihre Logik mehr als eine Bedingung benötigt, greifen Sie nach def.

Lambda mit integrierten Funktionen

Lambda-Funktionen sind am nützlichsten, wenn sie direkt an integrierte Funktionen übergeben werden. Hier sind die vier häufigsten Paarungen.

1. filter()

filter() Nimmt eine Funktion und eine Iterable und gibt nur die Elemente zurück, zu denen die Funktion ausgewertet wird True:

numbers = (33, 3, 22, 2, 11, 1)
outcome = record(filter(lambda x: x > 10, numbers))
print(outcome)
# Output:
# (33, 22, 11)

2. map()

map() wendet eine Funktion auf jedes Factor in einer Iterable an und gibt die transformierten Ergebnisse zurück:

numbers = (1, 2, 3, 4, 5)
outcome = record(map(lambda x: x * 10, numbers))
print(outcome)
# Output:
# (10, 20, 30, 40, 50)

Ein wesentlicher Unterschied zu filter(): map() Gibt immer eine Iterable mit der gleichen Anzahl von Elementen wie das Authentic zurück.

3. cut back()

cut back() Wendet eine Funktion kumulativ auf die Elemente einer Iterable an und reduziert sie auf einen einzigen Wert. Sie müssen es aus importieren functools Modul:

from functools import cut back

numbers = (1, 2, 3, 4, 5)
complete = cut back(lambda x, y: x + y, numbers)
print(complete)
# Output:
# 15

Das Lambda akzeptiert zwei Argumente gleichzeitig: das akkumulierte Ergebnis und das nächste Factor. Für gängige Aggregationen wie Summen oder Minima ist Pythons integriert sum(), min()Und max() sind einfacher. cut back() glänzt, wenn Sie eine benutzerdefinierte Akkumulationslogik benötigen.

4. sorted()

sorted() gibt eine neue sortierte Liste zurück. Durch die Übergabe eines Lambda an ihn key Parameter, den Sie steuern können Was wird sortiert nach:

college students = (("Alice", 88), ("Bob", 72), ("Clara", 95))
outcome = sorted(college students, key=lambda pupil: pupil(1))
print(outcome)
# Output:
# (('Bob', 72), ('Alice', 88), ('Clara', 95))

Dadurch wird die Liste der Tupel nach dem zweiten Factor (der Punktzahl) und nicht nach dem ersten sortiert. Auf diese Weise können Sie nach jedem berechneten Wert sortieren sorted() mit einem Lambda äußerst praktisch.

Lambda mit Listenverständnis

Möglicherweise stoßen Sie auf Lambda-Funktionen innerhalb von Listenverständnissen:

operations = ((lambda x: x ** 2)(n) for n in (1, 2, 3, 4))
print(operations)
# Output:
# (1, 4, 9, 16)

Das funktioniert, aber es gibt eine einfachere Möglichkeit, es zu schreiben:

operations = (n ** 2 for n in (1, 2, 3, 4))
print(operations)
# Output:
# (1, 4, 9, 16)

Gleiches Ergebnis, weniger Komplexität. In den meisten Fällen ist ein einfaches Listenverständnis sauberer, als ein Lambda darin einzuschließen. Es ist wahrscheinlicher, dass Sie darauf in vorhandenem Code stoßen, als dass Sie es selbst benötigen. Erkennen Sie es additionally, verwenden Sie es aber nicht standardmäßig.

Ein Fall, in dem Lambdas im Listenverständnis enthalten sind Tun sinnvoll ist, wenn Sie eine Liste von Funktionen erstellen:

multipliers = (lambda x, n=n: x * n for n in vary(1, 4))
print(multipliers(0)(5))  # 5
print(multipliers(1)(5))  # 10
print(multipliers(2)(5))  # 15

Jedes Lambda erfasst einen anderen Wert von nwodurch ein wiederverwendbarer Satz von Funktionen erstellt wird. Dies führt uns zu einem verwandten Konzept.

Lambda als Funktionsfabrik (Abschlüsse)

Sie können ein Lambda von einer regulären Funktion zurückgeben, um im laufenden Betrieb spezialisierte Funktionen zu erstellen:

Hier, make_multiplier() gibt ein Lambda zurück, das sich den Wert von „merkt“. n aus der umschließenden Funktion. Dies nennt man a Schließung. Jeder Anruf an make_multiplier() erzeugt eine neue Funktion mit ihrem eigenen erfassten Wert.

Dies ist praktisch, wenn Sie ähnliche Funktionen benötigen, die sich durch einen Parameter unterscheiden.

Lambda mit Pandas

Lambda-Funktionen lassen sich für schnelle Datentransformationen intestine mit Pandas kombinieren. Sie werden sie oft mit dem sehen .apply() Und .map() Methoden für DataFrames und Serien.

Hier ist ein Beispiel, das eine neue Spalte basierend auf Werten in einer vorhandenen Spalte erstellt:

import pandas as pd

df = pd.DataFrame({"rating": (45, 82, 67, 91, 38)})
df("pass_fail") = df("rating").map(lambda x: "Go" if x >= 60 else "Fail")
print(df)

   rating pass_fail
0     45      Fail
1     82      Go
2     67      Go
3     91      Go
4     38      Fail

Für zeilenweise Operationen über mehrere Spalten hinweg verwenden Sie .apply() mit axis=1:

df = pd.DataFrame({"first": (10, 20, 30), "second": (5, 15, 25)})
df("complete") = df.apply(lambda row: row("first") + row("second"), axis=1)
print(df)

   first  second  complete
0     10       5     15
1     20      15     35
2     30      25     55

Beachten Sie, dass für einfache Arithmetik oder Vergleiche die integrierten vektorisierten Operationen von Pandas (z df("rating") >= 60) sind schneller und besser lesbar. Lambdas mit .apply() Und .map() sind am nützlichsten, wenn die Transformation Logik beinhaltet, die nicht als einzelne vektorisierte Operation ausgedrückt werden kann.

Wenn Sie mit Daten in Python arbeiten, werden Sie häufig auf Lambdas mit Pandas stoßen. Unser Erweiterte Datenbereinigung in Python Der Kurs behandelt weitere dieser Muster als Teil des Datenanalyst Und Datenwissenschaftler Karrierewege.

Vor- und Nachteile von Lambda-Funktionen

Vorteile:

• Kompakte Syntax für einfache, einmalige Vorgänge
• Kann direkt an Funktionen höherer Ordnung übergeben werden, z filter(), map()Und sorted()
• Kann sofort aufgerufen werden (IIFE), ohne eine benannte Funktion zu definieren
• Nützlich, wenn eine API ein kurzes Funktionsargument erwartet

Nachteile:

• Beschränkt auf einen einzelnen Ausdruck (keine Schleifen, keine Mehrfachanweisungen)
• Verschachtelte Bedingungen werden schnell unleserlich
• Dokumentzeichenfolgen oder Variablenzuweisungen können nicht eingeschlossen werden
• Schwieriger zu debuggen, da sie so aussehen <lambda> in Tracebacks anstelle eines beschreibenden Funktionsnamens

Finest Practices

• Halten Sie sie einfach. Wenn Ihr Lambda mehr als eine Logikzeile benötigt, verwenden Sie a def Funktion stattdessen.
• Weisen Sie Variablen keine Lambdas zu. PEP 8 rät davon ab. Definieren Sie eine reguläre Funktion, wenn Sie sie wiederverwenden müssen.
• Bevorzugen Sie Listenverständnisse für einfache Transformationen. (x ** 2 for x in numbers) ist sauberer als record(map(lambda x: x ** 2, numbers)) in den meisten Situationen.
• Verwenden Sie Lambdas inline. Sie sind am besten, wenn sie direkt als Argumente an Funktionen wie übergeben werden sorted(), filter()und Pandas .apply().

Zusammenfassung

Lambda-Funktionen sind ein kleines, aber praktisches Werkzeug in Python. Mit ihnen können Sie kurze Wegwerffunktionen genau dort schreiben, wo Sie sie benötigen, und sie lassen sich natürlich mit integrierten Funktionen und Bibliotheken wie Pandas kombinieren. Halten Sie sie einfach, verwenden Sie sie inline und greifen Sie zu def wenn Ihre Logik über einen einzigen Ausdruck hinauswächst.

Wenn Sie Ihre Python-Kenntnisse weiter verbessern möchten, sind unsere Fortgeschrittener Python für KI-Engineering Kurs ist ein toller nächster Schritt auf dem KI-Engineering in Python Karriereweg. Und wenn Sie sich auf Datenwissenschaft konzentrieren, sind unsere Erweiterte Datenbereinigung in Python Der Kurs setzt Lambda-Funktionen als Teil des ein Datenwissenschaftler Karriereweg.

FAQs