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ückiterator
Objekt. In der Praxis geben wir das Ergebnis als einlist
,tuple
,set
,dict
usw., je nachdem, was bequemer ist.
Angenommen, Sie möchten jeden Begriff einer Liste mit quadrierenmap()
Funktion. Dazu definieren wir asquare()
Funktion und verwenden Sie sie als Parameter fürmap()
:
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'
Sehen Sie sich unseren praxisnahen, praktischen Leitfaden zum Erlernen von Git an, mit Best Practices, branchenweit akzeptierten Standards und einem mitgelieferten Spickzettel. Hören Sie auf, Git-Befehle zu googeln und tatsächlich in Verbindung, um es!
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.