Python Lambda-Funktionen mit BEISPIELEN

Inhaltsverzeichnis:

Anonim

Was ist die Lambda-Funktion in Python?

Eine Lambda-Funktion in der 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-Formen) verwendet, um anonyme Funktionen zu erstellen. Dazu verwenden Sie das Schlüsselwort lambda (genau 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 eine beliebige Anzahl von Parametern haben, der Funktionskörper kann jedoch nur einen Ausdruck enthalten . Darüber hinaus ist ein Lambda in einer einzigen Codezeile geschrieben und kann auch sofort aufgerufen werden. All dies werden Sie in den kommenden Beispielen in Aktion sehen.

In diesem Lambda in Python-Tutorial lernen Sie:

  • Syntax und Beispiele
  • Verwenden von Lambdas mit Python-integrierten 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 dies bei regulären Funktionen der Fall ist. Der letzte Teil (Ausdruck) ist ein gültiger Python-Ausdruck, der mit den Parametern arbeitet, die Sie der Funktion zur Verfügung stellen.

Beispiel 1

Nachdem Sie nun über Lambdas Bescheid wissen, versuchen wir es mit einem Beispiel. Öffnen Sie also Ihren IDLE und geben Sie Folgendes ein:

adder = lambda x, y: x + yprint (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, mit dem eine anonyme Funktion definiert wird.

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

3. Dies ist der Hauptteil der Funktion, der die 2 Parameter hinzufügt, die wir übergeben haben. 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 drucken den zurückgegebenen Wert.

Beispiel 2

Das war ein grundlegendes 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 Ihren IDLE und geben Sie Folgendes ein:

#What a lambda returnsstring='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:

 at 0x00000185C3BF81E0>

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

Code Erklärung

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

Aber warum druckt das Programm nicht die Zeichenfolge, die wir übergeben? Dies liegt daran, dass das Lambda selbst ein Funktionsobjekt zurückgibt. In diesem Beispiel wird das Lambda nicht wird aufgerufen durch die Druckfunktion , sondern einfach Rückkehr die Funktion Objekts und den Speicherplatz , wo sie gespeichert werden. Das wird an der Konsole gedruckt.

Beispiel 3

Wenn Sie jedoch ein Programm wie dieses schreiben:

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

Wenn Sie F5 drücken, wird eine Ausgabe wie diese angezeigt.

Ausgabe:

some kind of a useless lambda

Jetzt wird das Lambda aufgerufen und die Zeichenfolge, die wir übergeben, wird an der Konsole gedruckt. Aber was ist diese seltsame Syntax und warum wird die Lambda-Definition in Klammern angegeben? Lassen Sie uns das jetzt verstehen.

Code Erklärung

  1. Hier ist dieselbe Zeichenfolge, die wir im vorherigen Beispiel definiert haben.
  2. In diesem Teil definieren wir ein Lambda und rufen es sofort auf, indem wir den String als Argument übergeben. Dies wird als IIFE bezeichnet. Weitere Informationen hierzu finden Sie in den nächsten Abschnitten dieses Lernprogramms.

Beispiel 4

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

#A REGULAR FUNCTIONdef guru( funct, *args ):funct( *args )def printer_one( arg ):return print (arg)def printer_two( arg ):print(arg)#CALL A REGULAR FUNCTIONguru( printer_one, 'printer 1 REGULAR CALL' )guru( printer_two, 'printer 2 REGULAR CALL \n' )#CALL A REGULAR FUNCTION THRU A LAMBDAguru(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 ungefähr so ​​sein.

Ausgabe:

Drucker 1 REGELMÄSSIGER ANRUF

Drucker 2 REGELMÄSSIGER ANRUF

Drucker 1 LAMBDA CALL

Drucker 2 LAMBDA CALL

Code Erklärung

  1. Eine Funktion namens Guru, die eine andere Funktion als ersten Parameter und alle darauf folgenden Argumente verwendet.
  2. Drucker_one ist eine einfache Funktion, die den an sie übergebenen Parameter druckt und zurückgibt.
  3. Drucker_Zwei ähnelt Drucker_one, jedoch ohne die return-Anweisung.
  4. In diesem Teil rufen wir die Guru-Funktion auf und übergeben die Druckerfunktionen und eine Zeichenfolge als Parameter.
  5. Dies ist die Syntax, um den vierten Schritt zu erreichen (dh die Guru-Funktion aufzurufen), jedoch Lambdas zu verwenden.

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

Verwenden von Lambdas mit Python-integrierten Funktionen

Lambda-Funktionen bieten eine elegante und leistungsstarke Möglichkeit, Operationen mit in Python integrierten Methoden 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 Erklärung zu Ausgabe und Code:

Diese Fähigkeit, Lambdas sofort aufzurufen, ermöglicht es Ihnen, sie in Funktionen wie map () und redu () 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 einer vordefinierten Einschränkung. Es werden 2 Parameter benötigt:

  • Eine Funktion, die die Filterbedingung definiert
  • Eine Sequenz (jeder 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 Erläuterung:

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 sie größer als 4 ist.

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

Lambdas in Karte ()

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

  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 von Zahlen in einer bestimmten 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))

Ausgabe:

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

[KR1]

Code Erläuterung:

  1. Hier definieren wir eine Liste namens Sequenzen, die einige Zahlen enthält.
  2. Wir deklarieren eine Variable namens filtered_result, in der die zugeordneten Werte gespeichert werden
  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 reduzieren ()

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

Schritt 1) Führen Sie die definierte Operation an den ersten beiden Elementen 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 werden auch zwei Parameter benötigt:

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

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

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

Hier ist die Ausgabe:

120

Code Erläuterung:

  1. Importreduzierung aus dem functools-Modul
  2. Hier definieren wir eine Liste namens Sequenzen, die einige Zahlen enthält.
  3. Wir deklarieren eine Variable namens product, die den reduzierten Wert speichert
  4. Eine Lambda-Funktion, die für jedes Element der Liste ausgeführt wird. Das Produkt dieser Nummer wird gemäß dem vorherigen Ergebnis zurückgegeben.
  5. Drucken Sie das von der Reduzierungsfunktion zurückgegebene Ergebnis.

Warum (und warum nicht) Lambda-Funktionen verwenden?

Wie Sie im nächsten Abschnitt sehen werden, werden Lambdas auf Dolmetscherebene 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 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.

Sie können eine Funktion als Parameter für eine andere Funktion bereitstellen (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 Codierer, die Ihren Code pflegen, sehr schwierig sein, ihn zu entschlüsseln. Wenn Sie komplexe einzeilige Ausdrücke erstellen, ist es eine viel bessere Praxis, eine geeignete Funktion zu definieren. Als bewährte Methode müssen Sie sich daran erinnern, 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 keine Kennung gebunden ist. In einfacheren Worten sind sie Funktionen ohne Namen (daher anonym). Hier ist eine Tabelle, um den Unterschied zwischen Lambdas und regulären Funktionen in Python zu veranschaulichen.

Lambdas

Regelmäßige 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 haben keinen Namen 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 einem Lambda und einer regulären Funktion besteht darin, dass die Lambda-Funktion nur einen einzelnen Ausdruck auswertet und ein Funktionsobjekt ergibt. 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 folgendermaßen aussehen:

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

Hier müssen wir einen Namen für die Funktion definieren, die das Ergebnis zurückgibt, wenn wir es aufrufen . Eine Lambda-Funktion enthält keine return-Anweisung, da sie nur einen einzigen Ausdruck enthält, der standardmäßig immer zurückgegeben wird. Sie müssen auch kein 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 in Python integrierten Funktionen verwenden.

Möglicherweise fragen Sie sich jedoch immer noch, inwiefern sich Lambdas von einer Funktion unterscheiden, die einen einzelnen Ausdruck zurückgibt (wie oben). Auf der Ebene der Dolmetscher 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 dieselbe Weise behandelt. Jetzt können Sie eine Funktion Lambda nicht benennen, da sie von Python reserviert wird. Jeder andere Funktionsname liefert jedoch denselben Bytecode [KR6].

Zusammenfassung

  • Lambdas, auch als anonyme Funktionen bekannt, sind kleine, eingeschränkte Funktionen, die keinen Namen (dh eine 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 eine beliebige Anzahl von Parametern haben, sie sind jedoch nicht in geschweiften 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 Behandlung von Lambdas und regulären Funktionen durch den Interpreter.
  • Lambdas unterstützen IIFE durch diese Syntax: (Lambda-Parameter: Ausdruck) (Argument)
  • Lambdas werden üblicherweise mit den folgenden Python-Integrationen 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 Code-Betreuer schwierig sein wird.

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