Python-Lambda-Funktionen mit BEISPIELEN

Was ist die Lambda-Funktion in Python?

A Lambda-Funktion in Python Beim Programmieren handelt es sich um eine anonyme Funktion oder eine Funktion ohne Namen. Es handelt sich um 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-Formen) verwendet, um anonyme Funktionen zu erstellen. Dazu verwenden Sie die Lambda Schlüsselwort (genau wie Sie verwenden def 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 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 es nicht verwenden brackets um die Parameter, wie wir es mit 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 einwing:

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 einwing:

#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 der von uns übergebene String wird an der Konsole ausgegeben. Aber was ist diese seltsame Syntax und warum wird die Lambda-Definition darin behandelt? brackets? 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 einwing:

#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 Argumente annimmtwing es.
  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() bei Python.

Verwenden von Lambdas mit integrierten Python-Instanzen

Lambda-Funktionen bieten eine elegante und leistungsstarke Möglichkeit, Vorgänge mithilfe integrierter 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. 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 einwing:

 (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 es 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 zum Beispiel ein Programm, das den Sq ausgibtares von Zahlen in einer gegebenen Liste:

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 Funktion „Reduzieren“ wird wie „map()“ verwendet, um eine Operation auf jedes Element in einer Sequenz anzuwenden. Sie unterscheidet sich jedoch in ihrer Funktionsweise von der Karte. Dies sind die Schritte, die die Funktion Reduce() 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 den Vorgang 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 den auszuführenden Vorgang 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, 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 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 niemals komplizierte Lambda-Funktionen in einer Produktionsumgebung schreiben. Für Programmierer, die Ihren Code verwalten, wird es sehr schwierig sein, ihn zu entschlüsseln. Wenn Sie feststellen, dass Sie com erstellenplex Bei einzeiligen Ausdrücken wäre es eine viel bessere Vorgehensweise, eine richtige Funktion zu definieren. Als bewährte Vorgehensweise müssen Sie bedenken, dass einfacher Code immer besser ist als complex 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 auch nicht einmal ein Lambda zuweisen, da es sofort aufgerufen werden kann (siehe nächster Abschnitt). Wie Sie im Folgenden sehen werdenwing Beispielsweise werden Lambdas besonders leistungsfähig, wenn wir sie mit den integrierten Funktionen von Python verwenden.

Möglicherweise fragen Sie sich jedoch immer noch, inwiefern sich Lambdas von einer Funktion unterscheiden, die einen einzelnen Ausdruck zurückgibt (wie die 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 bei der Konvertierung in Bytecode auf die gleiche Weise behandelt. Jetzt können Sie einer Funktion keinen Namen geben Lambda weil es von Python reserviert ist, aber jeder andere Funktionsname den gleichen Bytecode[KR6] ergibt.

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 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, 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 üblicherweise mit folgendem verwendet:wing Python-Integrationen:
  • 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.