Python Lambda-Funktionen mit BEISPIELEN

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

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

Eine Lambda-Funktion kann eine beliebige Anzahl von Parametern haben, der Funktionskörper kann jedoch nur Parameter enthalten dank One Ausdruck. Darüber hinaus wird ein Lambda in einer einzigen Codezeile geschrieben und kann auch sofort aufgerufen werden. All dies werden Sie in den kommenden Beispielen in Aktion sehen.

Syntax und Beispiele

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

lambda p1, p2: expression

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

Beachten Sie jedoch, dass wir die Parameter nicht in Klammern setzen, 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 bereitstellen.

Beispiel 1

Nachdem Sie nun über Lambdas Bescheid wissen, versuchen wir es anhand eines Beispiels. Also, öffnen Sie Ihr IDLE und geben Sie Folgendes ein:

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

Hier ist die Ausgabe:

3

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 zum Definieren einer anonymen Funktion verwendet wird.

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

3. Dies ist der Hauptteil der Funktion, der die beiden von uns ü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. Versuchen wir nun, 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.

Ausgang:

<function <lambda> at 0x00000185C3BF81E0>

Was passiert hier? Schauen wir uns den Code an, um ihn besser zu verstehen.

Code Erklärung

1. Hier definieren wir a Schnur dass Sie als Parameter an das Lambda übergeben.
2. Wir deklarieren ein Lambda, das eine print-Anweisung aufruft und das Ergebnis ausgibt.

Aber warum gibt das Programm die von uns übergebene Zeichenfolge nicht aus? Dies liegt daran, dass das Lambda selbst ein Funktionsobjekt zurückgibt. In diesem Beispiel ist das Lambda nicht vorhanden namens durch die Druckfunktion aber einfach Rückkehr das Funktionsobjekt und den Speicherort, an dem es gespeichert ist. Das wird an der Konsole gedruckt.

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 erhalten eine Ausgabe wie diese.

Ausgang:

some kind of a useless lambda

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

Code Erklärung

1. Hier ist die gleiche Zeichenfolge, die wir im vorherigen Beispiel definiert haben.
2. In diesem Teil definieren wir ein Lambda und rufen es sofort auf, indem wir die Zeichenfolge als Argument übergeben. Dabei handelt es sich um ein sogenanntes IIFE, über das Sie in den kommenden Abschnitten dieses Tutorials mehr erfahren werden.

Beispiel 4

Schauen wir uns ein letztes Beispiel an, um zu verstehen, wie Lambdas und reguläre Funktionen ausgeführt werden. Also, öffnen Sie 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 etwa so aussehen.

Ausgang:

printer 1 REGULAR CALL

printer 2 REGULAR CALL

printer 1 LAMBDA CALL

printer 2 LAMBDA CALL

Code Erklärung

1. Eine Funktion namens Guru, die eine andere Funktion als ersten Parameter und alle weiteren darauf folgenden Argumente übernimmt.
2. Printer_one ist eine einfache Funktion, die den ihr übergebenen Parameter ausdruckt und zurückgibt.
3. „printer_two“ ähnelt „printer_one“, jedoch ohne die Return-Anweisung.
4. In diesem Teil rufen wir die Guru-Funktion auf und übergeben die Druckerfunktionen und einen String als Parameter.
5. Dies ist die Syntax, um den vierten Schritt (dh das Aufrufen der Guru-Funktion) zu erreichen, jedoch unter Verwendung von Lambdas.

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

Die Verwendung von Lambdas mit Python eingebaute

Lambda-Funktionen bieten eine elegante und leistungsstarke Möglichkeit, Operationen mit integrierten Methoden in Python. Dies ist möglich, weil 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. Das bedeutet, dass eine Lambda-Funktion aufrufbar ist, sobald sie definiert ist. Lassen Sie uns dies anhand eines Beispiels verstehen. Zünde dein an IDLE und geben Sie Folgendes ein:

 (lambda x: x + x)(2)

Hier ist die Ausgabe und Code-Erklä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 noch einmal verwenden möchten.

Lambdas in 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 einer vordefinierten Einschränkung. Es benötigt 2 Parameter:

• Eine Funktion, die die Filtereinschränkung definiert
• Eine Sequenz (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 „Sequenzen“, die einige Zahlen enthält.

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

3. Eine Lambda-Funktion, die für jedes Element der Liste ausgeführt wird und „true“ zurückgibt, wenn es größer als 4 ist.

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

Lambdas in map()

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

1. Eine Funktion, die die Operation definiert, die für die Elemente ausgeführt werden soll
2. Eine oder mehrere Sequenzen

Hier ist beispielsweise ein Programm, das die Quadrate der Zahlen in einer gegebenen Liste druckt:

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

Ausgang:

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

[KR1]

Code-Erklärung:

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

Lambdas in Reduce()

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

Schritt 1) Führen Sie die definierte Operation für die ersten beiden Elemente der Sequenz aus.

Schritt 2) Speichern Sie dieses Ergebnis

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 benötigt außerdem zwei Parameter:

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

Hier ist beispielsweise 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:

120

Code-Erklärung:

1. Importieren Sie Reduce aus dem Functools-Modul
2. Hier definieren wir eine Liste namens „Sequenzen“, die einige Zahlen enthält.
3. Wir deklarieren eine Variable namens Produkt, die den reduzierten Wert speichert
4. 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.
5. Drucken Sie das von der Reduce-Funktion zurückgegebene Ergebnis aus.

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 bereitstellen, die einen einzelnen Ausdruck zurückgeben.

Sie sollten jedoch wissen, wann die Verwendung von Lambdas sinnvoll ist und wann Sie sie vermeiden sollten. In diesem Abschnitt lernen Sie einige der Designprinzipien kennen, die Python-Entwickler beim Schreiben von Lambdas verwenden.

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

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

Wann sollten Sie Lambda nicht verwenden?

Sie sollten in einer Produktionsumgebung niemals komplizierte Lambda-Funktionen schreiben. Für Programmierer, die Ihren Code pflegen, wird es sehr schwierig sein, ihn zu entschlüsseln. Wenn Sie komplexe Einzeiler-Ausdrücke erstellen, ist es viel besser, eine richtige Funktion zu definieren. Als bewährte Methode sollten Sie bedenken, dass einfacher Code immer besser ist als komplexer Code.

Lambdas vs. reguläre Funktionen

Wie bereits erwähnt, sind Lambdas[vV4][J5] lediglich 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.

Mit Lambdas ist kein Name verknüpft. Aus diesem Grund 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 Text 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-Funktion und einer regulären Funktion besteht darin, dass die Lambda-Funktion nur einen einzelnen Ausdruck auswertet und ein Funktionsobjekt zurückgibt. Folglich können wir das Ergebnis der Lambda-Funktion benennen und es 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 a definieren Name für die Funktion which Rückgabe das Ergebnis, wenn wir rufen Sie uns an! 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 verwenden Python's integrierte Funktionen.

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

Wie Sie im Diagramm sehen können, werden die beiden Definitionen vom Python-Interpreter bei der Konvertierung in Bytecode auf die gleiche Weise behandelt. Jetzt können Sie einer Funktion keinen Namen geben Lambda weil es reserviert ist von Python, aber jeder andere Funktionsname ergibt den gleichen Bytecode[KR6].

Zusammenfassung

• Lambdas, auch anonyme Funktionen genannt, sind kleine, eingeschränkte Funktionen, die keinen Namen (also keine Kennung) benötigen.
• Jede Lambda-Funktion in Python besteht aus 3 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, sie sind jedoch nicht in geschweifte Klammern eingeschlossen
• Ein Lambda kann nur einen Ausdruck in seinem Funktionskörper haben, der standardmäßig zurückgegeben wird.
• Auf Bytecode-Ebene gibt es keinen großen Unterschied zwischen der Art und Weise, wie Lambdas und reguläre Funktionen vom Interpreter behandelt werden.
• Lambdas unterstützen IIFE durch diese Syntax: (Lambda-Parameter: Ausdruck)(Argument)
• Lambdas werden häufig mit den folgenden integrierten Python-Elementen verwendet:
• Filter: Filter (Lambda-Parameter: Ausdruck, iterierbare Sequenz)
• Karte: Karte (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 Code-Betreuer schwierig sein wird.

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

Dieser Code kann bearbeitet werden. Klicken Sie zum Ausführen auf „Ausführen“.