Warum sind Python-Lambdas nützlich? [geschlossen]

Ich versuche Python Lambdas herauszufinden. Ist Lambda eines dieser "interessanten" Sprachelemente, die im wirklichen Leben vergessen werden sollten?

Ich bin mir sicher, dass es einige Randfälle gibt, in denen dies erforderlich sein könnte, aber angesichts der Unklarheit, des Potenzials einer Neudefinition in zukünftigen Versionen (meine Annahme basiert auf den verschiedenen Definitionen) und der verringerten Klarheit der Codierung - sollte dies der Fall sein Gemieden werden?

Dies erinnert mich an ein Überlaufen (Pufferüberlauf) von C-Typen - Zeigen auf die oberste Variable und Überladen, um die anderen Feldwerte festzulegen. Es fühlt sich an wie eine Art Technikfreak, aber ein Alptraum für Wartungscodierer.

Sprechen Sie über Lambda-Funktionen ? Mögen

lambda x: x**2 + 2*x - 5

Diese Dinge sind eigentlich sehr nützlich. Python unterstützt einen Programmierstil namens funktionale Programmierung, bei dem Sie Funktionen an andere Funktionen übergeben können, um Aufgaben zu erledigen. Beispiel:

mult3 = filter(lambda x: x % 3 == 0, [1, 2, 3, 4, 5, 6, 7, 8, 9])

setzt mult3auf [3, 6, 9]die Elemente der ursprünglichen Liste, die ein Vielfaches von 3 sind. Dies ist kürzer (und, wie man argumentieren könnte, klarer) als

def filterfunc(x):
    return x % 3 == 0
mult3 = filter(filterfunc, [1, 2, 3, 4, 5, 6, 7, 8, 9])

In diesem speziellen Fall können Sie natürlich dasselbe tun wie ein Listenverständnis:

mult3 = [x for x in [1, 2, 3, 4, 5, 6, 7, 8, 9] if x % 3 == 0]

(oder sogar als range(3,10,3)), aber es gibt viele andere, komplexere Anwendungsfälle, in denen Sie kein Listenverständnis verwenden können und eine Lambda-Funktion möglicherweise der kürzeste Weg ist, etwas aufzuschreiben.

• Rückgabe einer Funktion von einer anderen Funktion

  >>> def transform(n):
  ...     return lambda x: x + n
  ...
  >>> f = transform(3)
  >>> f(4)
  7

  Dies wird häufig verwendet, um Funktionsumbrüche wie Pythons Dekoratoren zu erstellen.

• Kombinieren von Elementen einer iterierbaren Sequenz mit reduce()

  >>> reduce(lambda a, b: '{}, {}'.format(a, b), [1, 2, 3, 4, 5, 6, 7, 8, 9])
  '1, 2, 3, 4, 5, 6, 7, 8, 9'

• Sortieren nach einem alternativen Schlüssel

  >>> sorted([1, 2, 3, 4, 5, 6, 7, 8, 9], key=lambda x: abs(5-x))
  [5, 4, 6, 3, 7, 2, 8, 1, 9]

Ich benutze regelmäßig Lambda-Funktionen. Es dauerte eine Weile, bis ich mich an sie gewöhnt hatte, aber irgendwann wurde mir klar, dass sie ein sehr wertvoller Teil der Sprache sind.

lambdaist nur eine ausgefallene Art zu sagen function. Abgesehen von seinem Namen ist nichts Unbekanntes, Einschüchterndes oder Kryptisches daran. Wenn Sie die folgende Zeile zu lesen, ersetzen lambdadurch functionim Kopf:

>>> f = lambda x: x + 1
>>> f(3)
4

Es definiert nur eine Funktion von x. Einige andere Sprachen Rsagen es ausdrücklich:

> f = function(x) { x + 1 }
> f(3)
4

Siehst du? Es ist eines der natürlichsten Dinge beim Programmieren.

Die zweizeilige Zusammenfassung:

1. Verschlüsse : Sehr nützlich. Lerne sie, benutze sie, liebe sie.
2. Pythons lambdaSchlüsselwort: unnötig, gelegentlich nützlich. Wenn Sie feststellen, dass Sie etwas entfernt Komplexes damit tun, legen Sie es weg und definieren Sie eine echte Funktion.

Ein Lambda ist Teil eines sehr wichtigen Abstraktionsmechanismus, der sich mit Funktionen höherer Ordnung befasst. Um den Wert richtig zu verstehen, schauen Sie sich bitte hochwertige Lektionen von Abelson und Sussman an und lesen Sie das Buch SICP

Dies sind relevante Themen im modernen Softwaregeschäft, die immer beliebter werden.

Lambdas sind äußerst nützlich bei der GUI-Programmierung. Angenommen, Sie erstellen eine Gruppe von Schaltflächen und möchten einen einzelnen parametrisierten Rückruf anstelle eines eindeutigen Rückrufs pro Schaltfläche verwenden. Mit Lambda können Sie dies mühelos erreichen:

for value in ["one","two","three"]:
    b = tk.Button(label=value, command=lambda arg=value: my_callback(arg))
    b.pack()

(Hinweis: Obwohl diese Frage speziell gestellt wird lambda, können Sie auch functools.partial verwenden , um den gleichen Ergebnistyp zu erhalten.)

Die Alternative besteht darin, für jede Schaltfläche einen separaten Rückruf zu erstellen, der zu doppeltem Code führen kann.

Ich bezweifle, dass Lambda verschwinden wird. Siehe Guidos Beitrag über das endgültige Aufgeben des Versuchs, ihn zu entfernen. Sehen Sie sich auch einen Überblick über den Konflikt an .

In diesem Beitrag erfahren Sie mehr über die Funktionsweise von Python: http://python-history.blogspot.com/2009/04/origins-of-pythons-functional-features.html

Seltsamerweise wurden die Funktionen zum Zuordnen, Filtern und Reduzieren, die ursprünglich zur Einführung von Lambda und anderen Funktionsmerkmalen geführt haben, weitgehend durch Listenverständnisse und Generatorausdrücke ersetzt. Tatsächlich wurde die Reduzierungsfunktion aus der Liste der in Python 3.0 integrierten Funktionen entfernt. (Es ist jedoch nicht erforderlich, Beschwerden über die Entfernung von Lambda, Karte oder Filter einzureichen: Sie bleiben. :-)

Meine eigenen zwei Cent: Selten ist Lambda es wert, was die Klarheit betrifft. Im Allgemeinen gibt es eine klarere Lösung, die kein Lambda enthält.

In Python lambdaist dies nur eine Möglichkeit, Funktionen inline zu definieren.

a = lambda x: x + 1
print a(1)

und..

def a(x): return x + 1
print a(1)

..sind das genaue gleiche.

Mit Lambda können Sie nichts tun, was Sie mit einer regulären Funktion nicht tun können. In Python sind Funktionen ein Objekt wie alles andere, und Lambdas definieren einfach eine Funktion:

>>> a = lambda x: x + 1
>>> type(a)
<type 'function'>

Ich denke ehrlich das lambda Schlüsselwort in Python überflüssig ist - ich hatte nie die Notwendigkeit, sie zu verwenden (oder habe eine gesehen, bei der eine reguläre Funktion, ein Listenverständnis oder eine der vielen integrierten Funktionen besser hätte verwendet werden können).

Für ein völlig zufälliges Beispiel aus dem Artikel "Pythons Lambda ist kaputt!" ::

Um zu sehen, wie Lambda kaputt ist, erstellen Sie eine Liste mit Funktionen, bei fs=[f0,...,f9]denen fi(n)=i+n. Erster Versuch:

>>> fs = [(lambda n: i + n) for i in range(10)]
>>> fs[3](4)
13

Ich würde argumentieren, auch wenn das funktioniert hat, es ist schrecklich und "unpythonisch", die gleiche Funktionalität könnte auf unzählige andere Arten geschrieben werden, zum Beispiel:

>>> n = 4
>>> [i + n for i in range(10)]
[4, 5, 6, 7, 8, 9, 10, 11, 12, 13]

Ja, es ist nicht dasselbe, aber ich habe noch nie eine Ursache gesehen, bei der das Generieren einer Gruppe von Lambda-Funktionen in einer Liste erforderlich war. In anderen Sprachen mag es sinnvoll sein, aber Python ist nicht Haskell (oder Lisp oder ...)

Bitte beachten Sie, dass wir Lambda verwenden und dennoch die gewünschten Ergebnisse auf folgende Weise erzielen können:

>>> fs = [(lambda n,i=i: i + n) for i in range(10)]
>>> fs[3](4)
7

Bearbeiten:

Es gibt einige Fälle, in denen Lambda nützlich ist. Beispielsweise ist es häufig praktisch, wenn Signale in PyQt-Anwendungen wie folgt angeschlossen werden:

w = PyQt4.QtGui.QLineEdit()
w.textChanged.connect(lambda event: dothing())

Nur dies w.textChanged.connect(dothing)würde die dothingMethode mit einem zusätzlichen eventArgument aufrufen und einen Fehler verursachen. Die Verwendung des Lambda bedeutet, dass wir das Argument ordentlich löschen können, ohne eine Umhüllungsfunktion definieren zu müssen.

Ich finde Lambda nützlich für eine Liste von Funktionen, die dasselbe tun, aber für unterschiedliche Umstände.

Wie die Mozilla-Pluralregeln :

plural_rules = [
    lambda n: 'all',
    lambda n: 'singular' if n == 1 else 'plural',
    lambda n: 'singular' if 0 <= n <= 1 else 'plural',
    ...
]
# Call plural rule #1 with argument 4 to find out which sentence form to use.
plural_rule[1](4) # returns 'plural'

Wenn Sie eine Funktion für alle definieren müssten, würden Sie am Ende verrückt werden.
Auch wäre es nicht schön , mit Funktionsnamen wie sein plural_rule_1, plural_rule_2etc. Und Sie würden brauchen eval()es , wenn Sie auf eine Variable Funktion id sind abhängig.

So ziemlich alles, was Sie damit machen können lambda, können Sie entweder mit benannten Funktionen oder mit Listen- und Generatorausdrücken besser machen.

Folglich sollten Sie zum größten Teil nur eine davon in praktisch jeder Situation verwenden (außer vielleicht für den im interaktiven Interpreter geschriebenen Scratch-Code).

Ich benutze Python seit ein paar Jahren und bin noch nie auf einen Fall gestoßen, in dem ich Lambda brauchte . Wirklich, wie das Tutorial sagt, ist es nur für syntaktischen Zucker.

Ich kann nicht mit Pythons spezieller Implementierung von Lambda sprechen, aber im Allgemeinen sind Lambda-Funktionen sehr praktisch. Sie sind eine Kerntechnik (vielleicht sogar DIE Technik) der funktionalen Programmierung und sie sind auch in objektorientierten Programmen sehr nützlich. Für bestimmte Arten von Problemen sind sie die beste Lösung, sollten Sie also auf keinen Fall vergessen!

Ich schlage vor, Sie informieren sich über Abschlüsse und die Map-Funktion (die auf Python-Dokumente verweist, aber in fast jeder Sprache vorhanden ist, die funktionale Konstrukte unterstützt), um herauszufinden, warum sie nützlich ist.

Die Lambda-Funktion ist eine unbürokratische Methode zum Erstellen einer Funktion.

Das ist es. Nehmen wir zum Beispiel an, Sie haben Ihre Hauptfunktion und müssen Werte quadrieren. Sehen wir uns den traditionellen Weg und den Lambda-Weg an, um dies zu tun:

Traditioneller Weg:

def main():
...
...
y = square(some_number)
...
return something

def square(x):
    return x**2

Der Lambda-Weg:

def main():
...
square = lambda x: x**2
y = square(some_number)
return something

Sieh den Unterschied?

Lambda-Funktionen passen sehr gut zu Listen wie Listenverständnis oder Karte. Listenverständnis ist in der Tat eine "pythonische" Art, sich mit Lambda auszudrücken. Ex:

>>>a = [1,2,3,4]
>>>[x**2 for x in a]
[1,4,9,16]

Mal sehen, was jedes Element der Syntax bedeutet:

[]: "Gib mir eine Liste"

x ** 2: "Verwenden dieser neugeborenen Funktion"

für x in a: "in jedes Element in a"

Das ist praktisch, oder? Funktionen wie diese erstellen. Schreiben wir es mit Lambda um:

>>> square = lambda x: x**2
>>> [square(s) for x in a]
[1,4,9,16]

Verwenden wir jetzt die Karte, die dasselbe ist, aber sprachneutraler. Maps benötigt zwei Argumente:

(i) eine Funktion

(ii) eine iterable

Und gibt Ihnen eine Liste, in der jedes Element die Funktion ist, die auf jedes Element der Iterable angewendet wird.

Mit der Karte hätten wir also:

>>> a = [1,2,3,4]
>>> squared_list = map(lambda x: x**2, a)

Wenn Sie Lambdas und Mapping beherrschen, haben Sie eine große Macht, Daten auf präzise Weise zu manipulieren. Lambda-Funktionen sind weder unklar noch beeinträchtigen sie die Klarheit des Codes. Verwechseln Sie etwas Hartes nicht mit etwas Neuem. Sobald Sie anfangen, sie zu verwenden, werden Sie es sehr klar finden.

Eines der schönen Dinge lambda, die meiner Meinung nach unterschätzt werden, ist, dass es eine Möglichkeit ist, eine Bewertung für einfache Formulare aufzuschieben, bis der Wert benötigt wird. Lassen Sie mich erklären.

Viele Bibliotheksroutinen sind so implementiert, dass bestimmte Parameter aufrufbar sind (von denen Lambda einer ist). Die Idee ist, dass der tatsächliche Wert nur zu dem Zeitpunkt berechnet wird, zu dem er verwendet wird (und nicht zu dem Zeitpunkt, zu dem er aufgerufen wird). Ein (erfundenes) Beispiel könnte helfen, den Punkt zu veranschaulichen. Angenommen, Sie haben eine Routine, die einen bestimmten Zeitstempel protokolliert. Sie möchten, dass die Routine die aktuelle Zeit minus 30 Minuten verwendet. Du würdest es so nennen

log_timestamp(datetime.datetime.now() - datetime.timedelta(minutes = 30))

Angenommen, die eigentliche Funktion wird nur aufgerufen, wenn ein bestimmtes Ereignis eintritt und der Zeitstempel erst zu diesem Zeitpunkt berechnet werden soll. Sie können dies so tun

log_timestamp(lambda : datetime.datetime.now() - datetime.timedelta(minutes = 30))

Angenommen, die log_timestampDose kann solche Callables verarbeiten, wird dies bei Bedarf ausgewertet und Sie erhalten zu diesem Zeitpunkt den Zeitstempel.

Es gibt natürlich alternative Möglichkeiten, dies zu tun ( operatorzum Beispiel mit dem Modul), aber ich hoffe, ich habe den Punkt vermittelt.

Update : Hier ist ein etwas konkreteres Beispiel aus der Praxis.

Update 2 : Ich denke, dies ist ein Beispiel für einen sogenannten Thunk .

Wie oben erwähnt, definiert der Lambda-Operator in Python eine anonyme Funktion, und in Python sind Funktionen Schließungen. Es ist wichtig, das Konzept der Verschlüsse nicht mit dem Operator Lambda zu verwechseln, der für sie lediglich syntaktisches Methadon ist.

Als ich vor ein paar Jahren in Python anfing, benutzte ich viel Lambdas, weil ich dachte, sie seien cool, zusammen mit Listenverständnissen. Ich habe jedoch eine große, in Python geschriebene Website mit mehreren tausend Funktionspunkten geschrieben und muss diese pflegen. Ich habe aus Erfahrung gelernt, dass Lambdas möglicherweise in Ordnung sind, um Prototypen zu erstellen, aber nichts über Inline-Funktionen (benannte Verschlüsse) bieten, außer ein paar Tastenanschläge zu speichern oder manchmal auch nicht.

Grundsätzlich läuft dies auf mehrere Punkte hinaus:

• Es ist einfacher, Software zu lesen, die explizit mit aussagekräftigen Namen geschrieben wurde. Anonyme Schließungen können per Definition keinen aussagekräftigen Namen haben, da sie keinen Namen haben. Diese Kürze scheint aus irgendeinem Grund auch Lambda-Parameter zu infizieren, daher sehen wir häufig Beispiele wie Lambda x: x + 1
• Es ist einfacher, benannte Verschlüsse wiederzuverwenden, da sie mehrmals mit Namen bezeichnet werden können, wenn es einen Namen gibt, mit dem auf sie verwiesen werden kann.
• Es ist einfacher, Code zu debuggen, der benannte Closures anstelle von Lambdas verwendet, da der Name in Tracebacks und um den Fehler herum angezeigt wird.

Grund genug, sie aufzurunden und in benannte Verschlüsse umzuwandeln. Ich habe jedoch zwei weitere Groll gegen anonyme Schließungen.

Der erste Groll ist einfach, dass sie nur ein weiteres unnötiges Schlüsselwort sind, das die Sprache durcheinander bringt.

Der zweite Groll ist tiefer und auf der Paradigmenebene, dh ich mag es nicht, dass sie einen funktionalen Programmierstil fördern, weil dieser Stil weniger flexibel ist als der Nachrichtenübermittlungs-, objektorientierte oder prozedurale Stil, weil der Lambda-Kalkül nicht Turing- ist. vollständig (zum Glück können wir in Python auch innerhalb eines Lambdas aus dieser Einschränkung ausbrechen). Die Gründe, warum Lambdas diesen Stil fördern, sind:

• Es gibt eine implizite Rückkehr, dh sie scheinen Funktionen zu sein.

• Sie sind ein alternativer Mechanismus zum Verbergen von Zuständen zu einem anderen, expliziteren, lesbareren, wiederverwendbareren und allgemeineren Mechanismus: Methoden.

Ich bemühe mich sehr, lambda-freies Python zu schreiben und Lambdas sofort zu entfernen. Ich denke, Python wäre eine etwas bessere Sprache ohne Lambdas, aber das ist nur meine Meinung.

Lambdas sind tatsächlich sehr mächtige Konstrukte, die aus Ideen in der funktionalen Programmierung stammen, und es ist etwas, das in naher Zukunft von Python keineswegs leicht überarbeitet, neu definiert oder entfernt werden kann. Sie helfen Ihnen beim Schreiben von Code, der leistungsfähiger ist, da Sie Funktionen als Parameter übergeben können, also die Idee von Funktionen als erstklassige Bürger.

Lambdas neigen dazu, verwirrend zu werden, aber sobald ein solides Verständnis erreicht ist, können Sie sauberen, eleganten Code wie folgt schreiben:

squared = map(lambda x: x*x, [1, 2, 3, 4, 5])

Die obige Codezeile gibt eine Liste der Quadrate der Zahlen in der Liste zurück. Natürlich können Sie es auch so machen:

def square(x):
    return x*x

squared = map(square, [1, 2, 3, 4, 5])

Es ist offensichtlich, dass der frühere Code kürzer ist, und dies gilt insbesondere dann, wenn Sie die Kartenfunktion (oder eine ähnliche Funktion, die eine Funktion als Parameter verwendet) nur an einer Stelle verwenden möchten. Dies macht den Code auch intuitiver und eleganter.

Wie @David Zaslavsky in seiner Antwort erwähnte, sind Listenverständnisse nicht immer der richtige Weg, insbesondere wenn Ihre Liste Werte von einem obskuren mathematischen Weg erhalten muss.

Aus praktischer Sicht war einer der größten Vorteile von Lambdas für mich in letzter Zeit die grafische Benutzeroberfläche und die ereignisgesteuerte Programmierung. Wenn Sie sich Rückrufe in Tkinter ansehen, werden sie nur als Argumente für das Ereignis verwendet, das sie ausgelöst hat. Z.B

def define_bindings(widget):
    widget.bind("<Button-1>", do-something-cool)

def do-something-cool(event):
    #Your code to execute on the event trigger

Was wäre, wenn Sie einige Argumente vorbringen müssten? Etwas so Einfaches wie das Übergeben von 2 Argumenten zum Speichern der Koordinaten eines Mausklicks. Sie können es einfach so machen:

def main():
    # define widgets and other imp stuff
    x, y = None, None
    widget.bind("<Button-1>", lambda event: do-something-cool(x, y))

def do-something-cool(event, x, y):
    x = event.x
    y = event.y
    #Do other cool stuff

Jetzt können Sie argumentieren, dass dies mithilfe globaler Variablen möglich ist. Möchten Sie sich jedoch wirklich Gedanken über Speicherverwaltung und Datenverlust machen, insbesondere wenn die globale Variable nur an einem bestimmten Ort verwendet wird? Das wäre nur ein schlechter Programmierstil.

Kurz gesagt, Lambdas sind fantastisch und sollten niemals unterschätzt werden. Python-Lambdas sind zwar nicht dasselbe wie LISP-Lambdas (die mächtiger sind), aber Sie können wirklich eine Menge magischer Dinge damit machen.

Lambdas sind im Allgemeinen eng mit dem funktionalen Programmierstil verbunden. Die Idee, dass Sie Probleme lösen können, indem Sie eine Funktion auf einige Daten anwenden und die Ergebnisse zusammenführen, verwendet Google, um die meisten seiner Algorithmen zu implementieren.

Programme, die im funktionalen Programmierstil geschrieben wurden, lassen sich leicht parallelisieren und werden daher mit modernen Mehrkernmaschinen immer wichtiger. Kurz gesagt, NEIN, du solltest sie nicht vergessen.

Erste Glückwünsche, die es geschafft haben, Lambda herauszufinden. Meiner Meinung nach ist dies ein wirklich mächtiges Konstrukt, mit dem man handeln kann. Der heutige Trend zu funktionalen Programmiersprachen ist sicherlich ein Indikator dafür, dass er weder vermieden werden sollte noch in naher Zukunft neu definiert wird.

Man muss nur ein bisschen anders denken. Ich bin sicher, bald wirst du es lieben. Aber seien Sie vorsichtig, wenn Sie sich nur mit Python beschäftigen. Da das Lambda kein wirklicher Verschluss ist, ist es irgendwie "kaputt": Pythons Lambda ist kaputt

Ich fange gerade mit Python an und renne mit dem Kopf voran nach Lambda - was eine Weile gedauert hat, bis ich es herausgefunden habe.

Beachten Sie, dass dies keine Verurteilung von irgendetwas ist. Jeder hat eine andere Reihe von Dingen, die nicht einfach kommen.

Ist Lambda eines dieser „interessanten“ Sprachelemente, die im wirklichen Leben vergessen werden sollten?

Nein.

Ich bin mir sicher, dass es einige Randfälle gibt, in denen dies erforderlich sein könnte, aber angesichts der Dunkelheit.

Es ist nicht dunkel. In den letzten 2 Teams, an denen ich gearbeitet habe, haben alle diese Funktion die ganze Zeit genutzt.

das Potenzial einer Neudefinition in zukünftigen Versionen (meine Annahme basiert auf den verschiedenen Definitionen davon)

Ich habe keine ernsthaften Vorschläge zur Neudefinition in Python gesehen, außer die Korrektur der Abschlusssemantik vor einigen Jahren.

und die reduzierte Codierungsklarheit - sollte dies vermieden werden?

Es ist nicht weniger klar, ob Sie es richtig verwenden. Im Gegenteil, mehr Sprachkonstrukte zur Verfügung zu haben, erhöht die Klarheit.

Dies erinnert mich an ein Überlaufen (Pufferüberlauf) von C-Typen - Zeigen auf die oberste Variable und Überladen, um die anderen Feldwerte festzulegen ... eine Art Technikfreak, aber ein Alptraum für Wartungscodierer.

Lambda ist wie Pufferüberlauf? Beeindruckend. Ich kann mir nicht vorstellen, wie Sie Lambda verwenden, wenn Sie denken, dass es ein "Wartungsalptraum" ist.

Ich benutze Lambdas, um Codeduplikationen zu vermeiden. Dies würde die Funktion leicht verständlich machen. ZB:

def a_func()
  ...
  if some_conditon:
     ...
     call_some_big_func(arg1, arg2, arg3, arg4...)
  else
     ...
     call_some_big_func(arg1, arg2, arg3, arg4...)

Ich ersetze das durch ein temporäres Lambda

def a_func()
  ...
  call_big_f = lambda args_that_change: call_some_big_func(arg1, arg2, arg3, args_that_change)
  if some_conditon:
     ...
     call_big_f(argX)
  else
     ...
     call_big_f(argY)

Ich habe heute angefangen, David Mertz 'Buch "Textverarbeitung in Python" zu lesen. Obwohl er eine ziemlich knappe Beschreibung von Lambda hat, ließen die Beispiele im ersten Kapitel in Kombination mit der Erklärung in Anhang A sie (endlich) für mich von der Seite springen und plötzlich verstand ich ihren Wert. Das heißt nicht, dass seine Erklärung für Sie funktionieren wird und ich mich noch in der Entdeckungsphase befinde. Daher werde ich nicht versuchen, diese Antworten zu ergänzen, außer den folgenden: Ich bin neu in Python Ich bin neu in OOP Lambdas waren ein Kampf für mich Jetzt, wo ich Mertz lese, denke ich, dass ich sie bekomme und ich sehe sie als sehr nützlich an, da ich denke, dass sie einen saubereren Ansatz für die Programmierung ermöglichen.

Er reproduziert das Zen von Python, von dem eine Zeile Einfach ist besser als komplex. Als Nicht-OOP-Programmierer, der Code mit Lambdas liest (und bis letzte Woche Listenverständnisse hat), habe ich gedacht: Das ist einfach? . Heute wurde mir endlich klar, dass diese Funktionen den Code tatsächlich viel lesbarer und verständlicher machen als die Alternative - die ausnahmslos eine Art Schleife ist. Ich habe auch festgestellt, dass Python wie ein Jahresabschluss nicht für Anfänger gedacht ist, sondern für Benutzer, die sich weiterbilden möchten. Ich kann nicht glauben, wie mächtig diese Sprache ist. Als mir (endlich) der Zweck und der Wert von Lambdas klar wurde, wollte ich ungefähr 30 Programme zerreißen und gegebenenfalls wieder Lambdas einbauen.

Ein nützlicher Fall für die Verwendung von Lambdas ist die Verbesserung der Lesbarkeit des Verständnisses langer Listen . In diesem Beispiel loop_dicist die Klarheit kurz, aber stellen Sie sich vor, Sie loop_dicwären sehr lang. Wenn Sie nur einen einfachen Wert verwenden würden, der ianstelle der Lambda-Version dieses Werts enthält, erhalten Sie einen NameError.

>>> lis = [{"name": "Peter"}, {"name": "Josef"}]

>>> loop_dic = lambda i: {"name": i["name"] + " Wallace" }
>>> new_lis = [loop_dic(i) for i in lis]

>>> new_lis
[{'name': 'Peter Wallace'}, {'name': 'Josef Wallace'}]

Anstatt

>>> lis = [{"name": "Peter"}, {"name": "Josef"}]

>>> new_lis = [{"name": i["name"] + " Wallace"} for i in lis]

>>> new_lis
[{'name': 'Peter Wallace'}, {'name': 'Josef Wallace'}]

Ich kann Ihnen ein Beispiel geben, wo ich Lambda wirklich ernst brauchte. Ich mache ein grafisches Programm, bei dem die Verwendung mit der rechten Maustaste auf eine Datei klickt und ihr eine von drei Optionen zuweist. Es stellt sich heraus, dass in Tkinter (dem GUI-Schnittstellenprogramm, in das ich dies schreibe), wenn jemand eine Taste drückt, es keinem Befehl zugewiesen werden kann, der Argumente aufnimmt. Wenn ich also eine der Optionen gewählt habe und das Ergebnis meiner Wahl sein möchte:

print 'hi there'

Dann keine große Sache. Aber was ist, wenn ich meine Wahl brauche, um ein bestimmtes Detail zu haben? Wenn ich beispielsweise Auswahl A wähle, wird eine Funktion aufgerufen, die ein Argument aufnimmt, das von der Auswahl A, B oder C abhängt. TKinter konnte dies nicht unterstützen. Lamda war die einzige Möglichkeit, dies zu umgehen ...

Ich benutze es ziemlich oft, hauptsächlich als Nullobjekt oder um Parameter teilweise an eine Funktion zu binden.

Hier einige Beispiele:

So implementieren Sie ein Nullobjektmuster:

{
    DATA_PACKET: self.handle_data_packets
    NET_PACKET: self.handle_hardware_packets
}.get(packet_type, lambda x : None)(payload)

zur Parameterbindung:

Angenommen, ich habe die folgende API

def dump_hex(file, var)
    # some code
    pass

class X(object):
    #...
    def packet_received(data):
        # some kind of preprocessing
        self.callback(data)
    #...

Wenn ich dann die empfangenen Daten nicht schnell in eine Datei kopieren möchte, mache ich das:

dump_file = file('hex_dump.txt','w')
X.callback = lambda (x): dump_hex(dump_file, x)
...
dump_file.close()

ich benutze lambda , um Rückrufe zu erstellen, die Parameter enthalten. Es ist sauberer, ein Lambda in eine Zeile zu schreiben, als eine Methode zu schreiben, um dieselbe Funktionalität auszuführen.

Zum Beispiel:

import imported.module

def func():
    return lambda: imported.module.method("foo", "bar")

im Gegensatz zu:

import imported.module

def func():
    def cb():
        return imported.module.method("foo", "bar")
    return cb

Ich bin ein Python-Anfänger. Um eine klare Vorstellung von Lambda zu bekommen, habe ich es mit einer 'for'-Schleife verglichen. in Bezug auf die Effizienz. Hier ist der Code (Python 2.7) -

import time
start = time.time() # Measure the time taken for execution

def first():
    squares = map(lambda x: x**2, range(10))
    # ^ Lambda
    end = time.time()
    elapsed = end - start
    print elapsed + ' seconds'
    return elapsed # gives 0.0 seconds

def second():
    lst = []
    for i in range(10):
        lst.append(i**2)
    # ^ a 'for' loop
    end = time.time()
    elapsed = end - start
    print elapsed + ' seconds'
    return elapsed # gives 0.0019998550415 seconds.

print abs(second() - first()) # Gives 0.0019998550415 seconds!(duh)

Lambda ist ein Prozedurkonstruktor. Sie können Programme zur Laufzeit synthetisieren, obwohl Pythons Lambda nicht sehr leistungsfähig ist. Beachten Sie, dass nur wenige Menschen diese Art der Programmierung verstehen.