Python-Lambda-Funktionen mit BEISPIELE

Was ist die Lambda-Funktion in Python?

Eine Lambda-Funktion in Python Programmierung ist eine anonyme Funktion oder eine Funktion ohne Namen. Es ist eine kleine und eingeschränkte Funktion mit nicht mehr als einer Zeile. Genau wie eine normale Funktion kann eine Lambda-Funktion mehrere Argumente mit einem Ausdruck haben.

In Python werden Lambda-Ausdrücke (oder Lambda-Formulare) verwendet, um anonyme Funktionen zu erstellen. Dazu verwenden Sie das Lambda Schlüsselwort (so wie Sie def verwenden um normale Funktionen zu definieren). Jede anonyme Funktion, die Sie in Python definieren, besteht aus drei wesentlichen Teilen:

Das Lambda-Schlüsselwort.
Die Parameter (oder gebundenen Variablen) und
Der Funktionskörper.

Eine Lambda-Funktion kann beliebig viele Parameter haben, aber der Funktionskörper darf nur einen enthalten Ausdruck. Darüber hinaus ist ein Lambda in einer einzigen Codezeile geschrieben und kann auch sofort aufgerufen werden. Sie werden all dies in den nächsten Beispielen in Aktion sehen.

In diesem Lambda in Python-Tutorial lernen Sie:

Syntax und Beispiele
Verwenden von Lambdas mit integrierten Python-Funktionen
Lambdas im Filter()
Lambdas in Karte()
Lambdas in Reduzieren()
Warum (und warum nicht) Lambda-Funktionen verwenden?
Lambdas vs. reguläre Funktionen

Syntax und Beispiele

Die formale Syntax zum Schreiben einer Lambda-Funktion lautet wie folgt:

lambda p1, p2: expression

Hier sind p1 und p2 die Parameter, die an die Lambda-Funktion übergeben werden. Sie können beliebig viele oder wenige Parameter hinzufügen.

Beachten Sie jedoch, dass wir keine Klammern um die Parameter verwenden, wie wir es bei regulären Funktionen tun. Der letzte Teil (Ausdruck) ist ein beliebiger gültiger Python-Ausdruck, der mit den Parametern arbeitet, die Sie der Funktion zur Verfügung stellen.

Beispiel 1

Nun, da Sie über Lambdas Bescheid wissen, versuchen wir es mit einem Beispiel. Öffnen Sie also Ihr IDLE und geben Sie Folgendes ein:

adder = lambda x, y: x + y
print (adder (1, 2))

Hier ist die Ausgabe:

Code-Erklärung

Hier definieren wir eine Variable, die das von der Lambda-Funktion zurückgegebene Ergebnis enthält.

1. Das Lambda-Schlüsselwort, das verwendet wird, um eine anonyme Funktion zu definieren.

2. x und y sind die Parameter, die wir an die Lambda-Funktion übergeben.

3. Dies ist der Hauptteil der Funktion, der die beiden übergebenen Parameter hinzufügt. Beachten Sie, dass es sich um einen einzelnen Ausdruck handelt. Sie können nicht mehrere Anweisungen in den Hauptteil einer Lambda-Funktion schreiben.

4. Wir rufen die Funktion auf und geben den zurückgegebenen Wert aus.

Beispiel 2

Das war ein einfaches Beispiel, um die Grundlagen und die Syntax von Lambda zu verstehen. Lassen Sie uns nun versuchen, ein Lambda auszudrucken und das Ergebnis zu sehen. Öffnen Sie erneut Ihr IDLE und geben Sie Folgendes ein:

#What a lambda returns
string='some kind of a useless lambda'
print(lambda string : print(string))

Speichern Sie nun Ihre Datei und drücken Sie F5, um das Programm auszuführen. Dies ist die Ausgabe, die Sie erhalten sollten.

Ausgabe:

<function <lambda> at 0x00000185C3BF81E0>

Was passiert hier? Sehen wir uns zum besseren Verständnis den Code an.

Code-Erklärung

Hier definieren wir eine Zeichenfolge, die Sie als Parameter an das Lambda übergeben.
Wir deklarieren ein Lambda, das eine print-Anweisung aufruft und das Ergebnis ausgibt.

Aber warum gibt das Programm den übergebenen String nicht aus? Dies liegt daran, dass das Lambda selbst ein Funktionsobjekt zurückgibt. In diesem Beispiel wird das Lambda nicht aufgerufen über die Druckfunktion, sondern einfach zurück das Funktionsobjekt und den Speicherort, an dem es gespeichert ist. Das wird auf der Konsole ausgegeben.

Beispiel 3

Wenn Sie jedoch ein Programm wie dieses schreiben:

#What a lambda returns #2
x="some kind of a useless lambda"
(lambda x : print(x))(x)

Und führen Sie es aus, indem Sie F5 drücken, Sie werden eine Ausgabe wie diese sehen.

Ausgabe:

some kind of a useless lambda

Jetzt wird das Lambda aufgerufen und die übergebene Zeichenfolge wird auf der Konsole ausgegeben. Aber was ist diese seltsame Syntax und warum ist die Lambda-Definition in Klammern eingeschlossen? Lassen Sie uns das jetzt verstehen.

Code-Erklärung

Hier ist die gleiche Zeichenfolge, die wir im vorherigen Beispiel definiert haben.
In diesem Teil definieren wir ein Lambda und rufen es sofort auf, indem wir den String als Argument übergeben. Dies wird als IIFE bezeichnet, und Sie werden in den nächsten Abschnitten dieses Tutorials mehr darüber erfahren.

Beispiel 4

Schauen wir uns ein letztes Beispiel an, um zu verstehen, wie Lambdas und reguläre Funktionen ausgeführt werden. Öffnen Sie also Ihr IDLE und geben Sie in einer neuen Datei Folgendes ein:

#A REGULAR FUNCTION
def guru( funct, *args ):
funct( *args )
def printer_one( arg ):
return print (arg)
def printer_two( arg ):
print(arg)
#CALL A REGULAR FUNCTION 
guru( printer_one, 'printer 1 REGULAR CALL' )
guru( printer_two, 'printer 2 REGULAR CALL \n' )
#CALL A REGULAR FUNCTION THRU A LAMBDA
guru(lambda: printer_one('printer 1 LAMBDA CALL'))
guru(lambda: printer_two('printer 2 LAMBDA CALL'))

Speichern Sie nun die Datei und drücken Sie F5, um das Programm auszuführen. Wenn Sie keine Fehler gemacht haben, sollte die Ausgabe in etwa so aussehen.

Ausgabe:

Drucker 1 REGELMÄSSIGER ANRUF

Drucker 2 REGELMÄSSIGER ANRUF

Drucker 1 LAMBDA CALL

Drucker 2 LAMBDA CALL

Code-Erklärung

Eine Funktion namens guru, die eine andere Funktion als ersten Parameter und alle anderen darauf folgenden Argumente verwendet.
printer_one ist eine einfache Funktion, die den übergebenen Parameter druckt und zurückgibt.
drucker_zwei ist ähnlich wie drucker_eins, aber ohne die return-Anweisung.
In diesem Teil rufen wir die Guru-Funktion auf und übergeben die Druckerfunktionen und einen String als Parameter.
Dies ist die Syntax, um den vierten Schritt (d. h. das Aufrufen der Guru-Funktion) zu erreichen, aber Lambdas zu verwenden.

Im nächsten Abschnitt erfahren Sie, wie Sie Lambda-Funktionen mit map(), verwenden reduzieren(), und filter() in Python.

Lambdas mit integrierten Python-Funktionen verwenden

Lambda-Funktionen bieten eine elegante und leistungsstarke Möglichkeit, Operationen mit integrierten Methoden in Python auszuführen. Dies ist möglich, da Lambdas sofort aufgerufen und als Argument an diese Funktionen übergeben werden können.

IIFE in Python Lambda

IIFE steht für sofort aufgerufene Funktionsausführung. Dies bedeutet, dass eine Lambda-Funktion aufgerufen werden kann, sobald sie definiert ist. Lassen Sie uns dies anhand eines Beispiels verstehen; Starten Sie Ihren IDLE und geben Sie Folgendes ein:

 (lambda x: x + x)(2)

Hier ist die Ausgabe und Codeerklärung:

Diese Fähigkeit von Lambdas, sofort aufgerufen zu werden, ermöglicht es Ihnen, sie innerhalb von Funktionen wie map() und Reduce() zu verwenden. Dies ist nützlich, da Sie diese Funktionen möglicherweise nicht mehr verwenden möchten.

Lambdas im Filter()

Die Filterfunktion wird verwendet, um bestimmte Elemente aus einer Folge von Elementen auszuwählen. Die Sequenz kann ein beliebiger Iterator wie Listen, Mengen, Tupel usw. sein.

Die Elemente, die ausgewählt werden, basieren auf einigen vordefinierten Beschränkungen. Es braucht 2 Parameter:

Eine Funktion, die die Filterbeschränkung definiert
Eine Sequenz (ein beliebiger Iterator wie Listen, Tupel usw.)

Zum Beispiel

sequences = [10,2,8,7,5,4,3,11,0, 1]
filtered_result = filter (lambda x: x > 4, sequences) 
print(list(filtered_result))

Hier ist die Ausgabe:

[10, 8, 7, 5, 11]

Code-Erklärung:

1. In der ersten Anweisung definieren wir eine Liste namens sequences, die einige Zahlen enthält.

2. Hier deklarieren wir eine Variable namens „filtered_result“, die die gefilterten Werte speichert, die von der filter()-Funktion zurückgegeben werden.

3. Eine Lambda-Funktion, die auf jedem Element der Liste ausgeführt wird und wahr zurückgibt, wenn sie größer als 4 ist.

4. Drucken Sie das von der Filterfunktion zurückgegebene Ergebnis.

Lambdas in Karte()

Die Map-Funktion wird verwendet, um eine bestimmte Operation auf jedes Element in einer Sequenz anzuwenden. Wie filter() benötigt es auch 2 Parameter:

Eine Funktion, die die an den Elementen auszuführende Operation definiert
Eine oder mehrere Sequenzen

Hier ist zum Beispiel ein Programm, das die Quadrate von Zahlen in einer gegebenen Liste ausgibt:

sequences = [10,2,8,7,5,4,3,11,0, 1]
filtered_result = map (lambda x: x*x, sequences) 
print(list(filtered_result))

Ausgabe:

 [100, 4, 64, 49, 25, 16, 9, 121, 0, 1]

[KR1]

Code-Erklärung:

Hier definieren wir eine Liste namens Sequenzen, die einige Zahlen enthält.
Wir deklarieren eine Variable namens „filtered_result“, die die zugeordneten Werte speichert
Eine Lambda-Funktion, die auf jedem Element der Liste ausgeführt wird und das Quadrat dieser Zahl zurückgibt.
Drucken Sie das von der Kartenfunktion zurückgegebene Ergebnis.

Lambdas in Reduzieren()

Die Reduce-Funktion wird wie map() verwendet, um eine Operation auf jedes Element in einer Sequenz anzuwenden. Es unterscheidet sich jedoch von der Karte in seiner Funktionsweise. Dies sind die Schritte, die von der Reduce()-Funktion ausgeführt werden, um eine Ausgabe zu berechnen:

Schritt 1)  Führen Sie die definierte Operation an den ersten 2 Elementen der Sequenz aus.

Schritt 2) Dieses Ergebnis speichern

Schritt 3) Führen Sie die Operation mit dem gespeicherten Ergebnis und dem nächsten Element in der Sequenz aus.

Schritt 4) Wiederholen, bis keine Elemente mehr übrig sind.

Es braucht auch zwei Parameter:

Eine Funktion, die die auszuführende Operation definiert
Eine Sequenz (ein beliebiger Iterator wie Listen, Tupel usw.)

Hier ist zum Beispiel ein Programm, das das Produkt aller Elemente in einer Liste zurückgibt:

from functools import reduce
sequences = [1,2,3,4,5]
product = reduce (lambda x, y: x*y, sequences)
print(product)

Hier ist die Ausgabe:

Code-Erklärung:

Reduzieren aus dem functools-Modul importieren
Hier definieren wir eine Liste namens Sequenzen, die einige Zahlen enthält.
Wir deklarieren eine Variable namens Produkt, die den reduzierten Wert speichert
Eine Lambda-Funktion, die für jedes Element der Liste ausgeführt wird. Es wird das Produkt dieser Zahl gemäß dem vorherigen Ergebnis zurückgegeben.
Drucken Sie das von der Reduce-Funktion zurückgegebene Ergebnis.

Warum (und warum nicht) Lambda-Funktionen verwenden?

Wie Sie im nächsten Abschnitt sehen werden, werden Lambdas auf Interpreterebene genauso behandelt wie reguläre Funktionen. In gewisser Weise könnte man sagen, dass Lambdas eine kompakte Syntax zum Schreiben von Funktionen bieten, die einen einzelnen Ausdruck zurückgeben.

Sie sollten jedoch wissen, wann es eine gute Idee ist, Lambdas zu verwenden und wann Sie sie vermeiden sollten. In diesem Abschnitt lernen Sie einige der Designprinzipien kennen, die von Python-Entwicklern beim Schreiben von Lambdas verwendet werden.

Einer der häufigsten Anwendungsfälle für Lambdas ist die funktionale Programmierung, da Python ein Paradigma (oder einen Stil) der Programmierung unterstützt, das als funktionale Programmierung bekannt ist.

Es ermöglicht Ihnen, eine Funktion als Parameter für eine andere Funktion bereitzustellen (z. B. in Map, Filter usw.). In solchen Fällen bietet die Verwendung von Lambdas eine elegante Möglichkeit, eine einmalige Funktion zu erstellen und als Parameter zu übergeben.

Wann sollten Sie Lambda nicht verwenden?

Sie sollten niemals komplizierte Lambda-Funktionen in einer Produktionsumgebung schreiben. Es wird für Programmierer, die Ihren Code pflegen, sehr schwierig sein, ihn zu entschlüsseln. Wenn Sie feststellen, dass Sie komplexe einzeilige Ausdrücke machen, wäre es eine viel bessere Praxis, eine richtige Funktion zu definieren. Als Best Practice sollten Sie daran denken, dass einfacher Code immer besser ist als komplexer Code.

Lambdas vs. reguläre Funktionen

Wie bereits erwähnt, sind Lambdas [vV4][J5] nur Funktionen, an die kein Bezeichner gebunden ist. Einfacher ausgedrückt handelt es sich um Funktionen ohne Namen (daher anonym). Hier ist eine Tabelle, um den Unterschied zwischen Lambdas und regulären Funktionen in Python zu veranschaulichen.

Lambdas

Reguläre Funktionen

Syntax:

lambda x : x + x

Syntax:

def (x) :
return x + x

Lambda-Funktionen können nur einen Ausdruck in ihrem Körper haben.

Reguläre Funktionen können mehrere Ausdrücke und Anweisungen in ihrem Körper haben.

Lambdas ist kein Name zugeordnet. Deshalb werden sie auch als anonyme Funktionen bezeichnet.

Reguläre Funktionen müssen einen Namen und eine Signatur haben.

Lambdas enthalten keine return-Anweisung, da der Body automatisch zurückgegeben wird.

Funktionen, die einen Wert zurückgeben müssen, sollten eine return-Anweisung enthalten.

Erklärung der Unterschiede?

Der Hauptunterschied zwischen einer Lambda- und einer regulären Funktion besteht darin, dass die Lambda-Funktion nur einen einzigen Ausdruck auswertet und ein Funktionsobjekt zurückgibt. Folglich können wir das Ergebnis der Lambda-Funktion benennen und in unserem Programm verwenden, wie wir es im vorherigen Beispiel getan haben.

Eine reguläre Funktion für das obige Beispiel würde so aussehen:

def adder (x, y):
return x + y 
print (adder (1, 2))

Hier müssen wir einen Namen definieren für die Funktion, die zurückgibt das Ergebnis, wenn wir anrufen es. Eine Lambda-Funktion enthält keine return-Anweisung, da sie nur einen einzigen Ausdruck hat, der standardmäßig immer zurückgegeben wird. Sie müssen nicht einmal ein Lambda zuweisen, da es sofort aufgerufen werden kann (siehe nächster Abschnitt). Wie Sie im folgenden Beispiel sehen werden, werden Lambdas besonders leistungsfähig, wenn wir sie mit den integrierten Funktionen von Python verwenden.

Möglicherweise fragen Sie sich jedoch immer noch, wie sich Lambdas von einer Funktion unterscheiden, die einen einzelnen Ausdruck zurückgibt (wie der obige). Auf Dolmetscherebene gibt es keinen großen Unterschied. Es mag überraschend klingen, aber jede Lambda-Funktion, die Sie in Python definieren, wird vom Interpreter als normale Funktion behandelt.

Wie Sie im Diagramm sehen können, werden die beiden Definitionen vom Python-Interpreter auf die gleiche Weise behandelt, wenn sie in Bytecode konvertiert werden. Jetzt können Sie eine Funktion nicht Lambda nennen weil es von Python reserviert ist, aber jeder andere Funktionsname ergibt denselben Bytecode[KR6].

Zusammenfassung

Lambdas, auch bekannt als anonyme Funktionen, sind kleine, eingeschränkte Funktionen, die keinen Namen (d. h. eine Kennung) benötigen.
Jede Lambda-Funktion in Python besteht aus drei wesentlichen Teilen:
Das Lambda-Schlüsselwort.
Die Parameter (oder gebundenen Variablen) und
Der Funktionskörper.
Die Syntax zum Schreiben eines Lambda lautet:Lambda-Parameter:Ausdruck
Lambdas können beliebig viele Parameter haben, aber sie sind nicht in geschweiften Klammern eingeschlossen
Ein Lambda kann nur 1 Ausdruck in seinem Funktionskörper haben, der standardmäßig zurückgegeben wird.
Auf Bytecode-Ebene gibt es keinen großen Unterschied zwischen der Handhabung von Lambdas und regulären Funktionen durch den Interpreter.
Lambdas unterstützen IIFE über diese Syntax:(Lambda-Parameter:Ausdruck)(Argument)
Lambdas werden häufig mit den folgenden Python-Einbauten verwendet:
Filter:Filter (Lambda-Parameter:Ausdruck, iterierbare Sequenz)
Map:map (Lambda-Parameter:Ausdruck, iterierbare Sequenzen)
Reduzieren:reduzieren (Lambda-Parameter1, Parameter2:Ausdruck, iterierbare Sequenz)
Schreiben Sie keine komplizierten Lambda-Funktionen in einer Produktionsumgebung, da dies für Codeverwalter schwierig sein wird.

[J5]Ich habe eine Tabelle hinzugefügt, aber die Erklärung ist notwendig, um die Unterschiede zu verstehen.

Beispiele für Python-Funktionen:Aufruf, Einrückung, Argumente und Rückgabewerte Python abs() Funktion:Beispiele für absolute Werte

Python