Lambda-Funktionen in Python

Was sind Lambda-Funktionen?

​
In Python sind Funktionen Objekte: Sie können Variablen zugewiesen werden, von anderen Funktionen zurückgegeben, in Listen oder Diktaten gespeichert und als Parameter für andere Funktionen übergeben werden. Betrachten Sie zum Beispiel die map() eingebaute Funktion. Seine Syntax ist map(function, iterable) und es lässt sich leicht anwenden function zu jedem Element von iterable.

map() kehrt tatsächlich zurück iterator Objekt. In der Praxis geben wir das Ergebnis als ein list, tuple, set, dictusw., je nachdem, was bequemer ist.
​
Angenommen, Sie möchten jeden Begriff einer Liste mit quadrieren map() Funktion. Dazu definieren wir a square() Funktion und verwenden Sie sie als Parameter für map():

my_list = [1,2,3,4,5]
def square(x):
    return x**2

my_modified_list = list(map(square, my_list))
print(my_modified_list)

[1, 4, 9, 16, 25]

​
Wenn jedoch die einzige Verwendung unserer square() Da die Funktion darin besteht, diese Liste zu erstellen, ist es sauberer, a zu verwenden lambda Funktion:

my_list = [1,2,3,4,5]
my_modified_list = list(map(lambda x: x**2, my_list))
print(my_modified_list)

[1, 4, 9, 16, 25]

In Python lambda Funktionen sind anonyme Funktionen, deren Name und Syntax von Alonzo Church stammen Lambda-Kalkül. Ihre Syntax ist:

lambda x_1,..., x_n : expression(x_1, ..., x_n)

Dadurch wird eine anonyme Funktion erstellt, die die Variablen als Eingabe erhält x_1, ..., x_n und gibt die ausgewertete zurück expression(x_1, ..., x_n).
​
Der Zweck der lambda „functions“ soll als Parameter für Funktionen verwendet werden, die Funktionen als Parameter akzeptieren, wie wir es mit getan haben map() über. Mit Python können Sie a zuweisen lambda Funktion zu einer Variablen, aber die PEP 8-Styleguide rät davon ab. Wenn Sie einer Variablen eine einfache Funktion zuweisen möchten, ist es besser, dies als einzeilige Definition zu tun. Dadurch wird sichergestellt, dass das resultierende Objekt den richtigen Namen hat, was die Lesbarkeit des Tracebacks verbessert:

anonymous_square = lambda x : x**2
​
def named_square(x): return x**2
​
print(anonymous_square.__name__)
print(named_square.__name__)


a = anonymous_square
b = named_square
print(a.__name__)
print(b.__name__)

Warum Lambda-Funktionen verwenden?

Nach dem letzten Absatz fragen Sie sich vielleicht, warum Sie a verwenden sollten lambda Funktion. Schließlich ist alles, was mit einem gemacht werden kann lambda Funktion könnte mit einer benannten Funktion ausgeführt werden.
​
Die Antwort darauf ist das lambda Funktion Zweck besteht darin, in größeren Ausdrücken zu leben, die eine Berechnung darstellen. Eine Möglichkeit, darüber nachzudenken, ist die Analogie zu Variablen und Werten. Betrachten Sie den folgenden Code:

x = 2

Die Variable x ist ein Platzhalter (oder ein Name) für die Ganzzahl 2. Zum Beispiel anrufen print(x) und print(2) gibt genau die gleiche Ausgabe. Bei Funktionen:

def square(x): return x**2

Die Funktion square() ist ein Platzhalter für die Berechnung der Quadrierung einer Zahl. Diese Berechnung kann auf namenlose Weise geschrieben werden als lambda x: x**2.
​
Im Anschluss an diesen philosophischen Exkurs sehen wir uns einige Anwendungsbeispiele für an lambda Funktionen.
​

Verwenden von Lambda mit der Funktion sorted()

Das sorted() Funktion sortiert eine Iterable. Es akzeptiert eine Funktion als seine key Argument, und das Ergebnis der auf jedes Element der Iterable angewendeten Funktion wird zum Ordnen der Elemente verwendet.
​
Dies ist perfekt geeignet für a lambda Funktion: durch Einstellen der key Parameter mit a lambda Mit der Funktion können wir die Elemente nach jeder Art von Attribut sortieren. Beispielsweise können wir eine Liste mit Namen nach Nachnamen sortieren:

name_list = ['Grace Hopper', 'Ada Lovelace', 'Emmy Noether', 'Marie Curie']
​
sorted_by_surname = sorted(name_list, key = lambda x: x.split()[1])
​
print(sorted_by_surname)

['Marie Curie', 'Grace Hopper', 'Ada Lovelace', 'Emmy Noether']

Verwenden von Lambda mit der Funktion „filter()“.

Das filter() Die Funktion hat die folgende Syntax: filter(function, iterable) und es gibt die Elemente von aus iterable die bewerten function(element) als wahr (es ähnelt einem WHERE Klausel in SQL). Wir können benutzen lambda fungiert als Parameter für filter() um Elemente aus einem iterierbaren Element auszuwählen.

Betrachten Sie das folgende Beispiel:

num_list = list(range(0,100))
​
multiples_of_15= filter(lambda x: (x % 3 == 0) and (x % 5 == 0), num_list)
​
print(list(multiples_of_15))

[0, 15, 30, 45, 60, 75, 90]

filter() gilt die lambda Funktion lambda x: (x % 3 == 0) and (x % 5 == 0) zu jedem Element von range(0,100), und gibt a zurück filter Objekt. Wir greifen auf die Elemente zu, indem wir sie umwandeln als list.
​

Verwenden von Lambda mit der Funktion „map()“.

​
Unser letztes Beispiel ist etwas, das wir in der Einleitung gesehen haben – das map() Funktion. Das map() Funktionssyntax ist: map(function, iterable) und map() gilt function zu jedem Element von iterable, Rückkehr a map Objekt, auf das durch Umwandlung in a zugegriffen werden kann list.

Wir haben gesehen, wie dies auf Listen angewendet werden kann, aber es könnte auch auf Diktate angewendet werden, die das verwenden dict.items() Verfahren:

my_data = {'Mary':1, 'Alice':2, 'Bob':0}
map_obj = map(lambda x: f'{x[0]} had {x[1]} little lamb', my_data.items())
print(', '.join((map_obj)))

Mary had 1 little lamb, Alice had 2 little lamb, Bob had 0 little lamb

oder zu einer Zeichenfolge:

my_string = 'abcdefg'
''.join(map(lambda x: chr(ord(x)+2),my_string))

'cdefghi'

Wir verwenden map() Funktion auf geniale Weise – ein Beispiel ist die Anwendung vieler Funktionen auf dieselbe Eingabe.

Angenommen, Sie erstellen eine API, die eine Textzeichenfolge empfängt, und möchten eine Liste von Funktionen darauf anwenden.

Jede Funktion extrahiert eine Funktion aus dem Text. Die Merkmale, die wir extrahieren möchten, sind die Anzahl der Wörter, das zweite Wort und der vierte Buchstabe des vierten Wortes:

def number_of_words(text):
  return len(text.split())
​
def second_word(text):
  return text.split()[1]
​
def fourth_letter_of_fourth_word(text):
  return text.split()[3][3]
​
function_list = [number_of_words, second_word, fourth_letter_of_fourth_word]
​
my_text = 'Mary had a little lamb'
map_obj = map(lambda f: f(my_text), function_list)
​
feature_list = list(map_obj)
​
print(feature_list)

[5, 'had', 't']

​

Zusammenfassung

​
In diesem Leitfaden haben wir die Funktionalität von untersucht lambda Funktionen in Python. Das haben wir gesehen lambda Funktionen sind anonyme Funktionen, die als Inline-Funktionsparameter für andere Funktionen verwendet werden können. Wir haben einige Anwendungsfälle gesehen und erfahren, wann man sie nicht verwenden sollte.
​
Beim Programmieren ist es wichtig, das Zitat von Donald Knuth im Hinterkopf zu behalten: „Programme sind dazu gedacht, von Menschen gelesen zu werden und nur nebenbei von Computern ausgeführt zu werden.“ Mit dieser Einstellung, lambda Funktionen sind ein nützliches Werkzeug zur Vereinfachung unseres Codes, sollten aber mit Bedacht eingesetzt werden.