python3x: Lambda-Funktion
Als ich Lab machte, sah ich eine "Lambda-Funktion", also gab ich die Bedeutung einer Überprüfung an.
Lambda Function
Kurz gesagt, Lambda macht es einfach, einer geeigneten Variablen eine Funktion zuzuweisen.
Definition
bind a function to a name using the same syntax and assignment statement.
Betrachten Sie zunächst den folgenden Ausdruck.
>>> x = 10
>>> square = x*x
>>> square
100
>>> square = lamnda x: x*x
>>> square
<function...>
>>> square(4)
16
>> square(10)
100
Ich habe versucht, es in einem einfachen Diagramm unter Bezugnahme auf die Vorlesungsfolien zusammenzufassen.
Unterschied zwischen "def" und "Lambda"
Um die Unterschiede anhand des obigen Beispiels zusammenzufassen:
- Both create a function with the same domain, range and behavior.
- Both functions have as their parent the frame in which they were defined.
- Both bind that function to the name square. (but in a different way: Lambda first creates the function with no name and it's the assignment statement that binds that function value to the name "square" whereas in the def statement, both of those things happen automatically, all as a byproduct of executing the def statement
- Only the def statement gives the function an intrinsic name.
Es gibt keinen großen Unterschied in der Grundbedienung. Was ist also der Unterschied? Schreiben Sie Umweltdiagramm Sie können es sehen, indem Sie es versuchen. Das Folgende ist eine Skizze der Vorlesungsfolien.
Wenn Sie eine Funktion mit "def" erstellen, wird der Name sofort angegeben. Wenn Sie jedoch eine Funktion mit "lambda" erstellen, haben Sie auch dann keinen Namen, wenn Sie den Namen durch "Zuweisungsanweisung" zugewiesen haben. Das ist. Mit anderen Worten, in Python können Sie eine Funktion sofort erstellen, wenn Sie sie benötigen, ohne die def-Anweisung verwenden zu müssen, um sie zu benennen.
A lambda expression evaluates to a function that has a single return expression as its body.
Infolge der Ausführung von "Lambda-Ausdruck" wird es zu "Lambda-Funktion" und spielt eine Rolle als Funktion. Da diese Funktion keinen angeborenen Namen hat, schreibt Python ihn einfach als "
>>> s = lambda x: x * x
>>> s
<function<lambda> at xxxxxxx>
>>> s(12)
144
Davon abgesehen gibt es keinen grundsätzlichen Unterschied.
Translating between named and anonymous functions
Ich habe mich gefragt (und ich hätte es vielleicht irgendwo geschrieben), aber wenn ich die beiden Ausdrücke "Lambda x, y" und "Lambda x: Lambda y" vergleiche, gibt es einen anderen Unterschied als die Anzahl der Parameter und das Argument. Es gab keine.
>>> adder = lambda x: lambda y: x + y
>>> adder2 = lambda x, y: x + y
>>> adder(1)(3)
4
>>> adder2(1,3)
4
Der Unterschied wurde jedoch durch den Vergleich von "def" und "lambda" deutlicher, als ich an der Überprüfung teilnahm.
Wenn Sie darüber nachdenken, ist dies leicht zu verstehen, wenn Sie sich das zweite "Lambda" als "def helper (y) vorstellen: return" in "def".
Funktionen höherer Ordnung können problemlos ausgeführt werden.
def compose1(f,g):
return lambdax : f(g(x))
f = compose1(lamnda x: x * x,
lambda y: y + 1)
result = f(12) # 169
<a href = "http://www.pythontutor.com/visualize.html#code=def+compose1(f,g%29%3A%0A++++return+lambda+x%3A+f(g(g(g) x% 29% 29% 0A% 0Af +% 3D + compose1 (Lambda + x% 3A + x + * + x,% 0A ++++++++++++++ Lambda + y% 3A + y +% 2B + 1% 29% 0A% 0Ergebnis +% 3D + f (12% 29 & mode = display & origin = opt-frontend.js & cumulative = false & heapPrimitives = false & textReferences = false & py = 3 & rawInputLstJSON =% 5B% 5D & curInstr = 0 "target =" _ blank "> PythonTutor.com / strongTutor.com / Sie können die genauere Funktionsbewegung mit einem> sehen.
Beachten Sie, dass die Funktion lambda x: f (g (x)) innerhalb der Funktion compose1 mit dem Rahmen f1 anstelle des globalen Rahmens erstellt wird. Der Grund ist, dass nur wenn "compose1" von "f" aufgerufen wird, es in "compose1" eingeht. Zu dem Zeitpunkt, an dem Sie "compose1" aufrufen, haben Sie bereits einen f1-Frame erstellt, also [p = g]. Eine andere Sache, die mir aufgefallen ist, betrifft die beiden Lambdas, die ich als Argumente an die Funktion compose1 übergebe. Persönlich dachte ich, dass es definiert werden würde, wenn ich die Funktion "compose1" aufrufe, also schrieb ich [p = f1], aber anscheinend, als ich es oben als "compose1 (f, g)" definierte ( Da ich der Variablen einen Namen zugewiesen habe (unabhängig davon, was ich erhalte), denke ich, dass das Ergebnis [p = g] ist, unabhängig davon, ob ich es als "Lambda" oder was auch immer werfe. Wenn Sie bei der Verwendung eines solchen Lambda einen Fehler machen, wird es schwieriger zu verstehen.
lambda expressions are notoriously illegible, despite their brevity.
Dies bedeutet, dass Sie die obige Funktion als "compose1 = Lambda f, g: Lambda x: f (g (x))" schreiben können, aber es dauert oft einige Zeit, bis Sie sie vollständig verstanden haben.
Herkunft von "Lambda"
Anscheinend wurde "Lambda" geboren, weil die damaligen Autoren die Formel $ ŷ. Y * y $ in Mathematik nicht mit einer Schreibmaschine schreiben konnten. Sie haben den Ausdruck als $ Λ y. Y x y $ umgeschrieben, so dass er zu $ λ y. Y x y $ wurde, und sie sehen immer noch das Symbol $ λ $. Weitere Informationen finden Sie unter Peter Norvig.
Aufzählungszeichen, was Ihnen bei der Verwendung von Lambda aufgefallen ist
Ich werde schreiben, was mir bei dem Problem von [lab02] aufgefallen ist (http://cs61a.org/lab/lab02/).
Question 1: WWPP: Lambda the Free
Q1
>>> c = lambda: 3
>>> c()
3
Als eine Option
- Geben Sie "None" als Wert ein (mit einem fehlenden Teil?)
- Zeigen Sie "3" an, aber "Keine" ist Wert (= Drucken)
- Geben Sie "3" als Wert aus (= Rückgabe) Geht es um Wie Sie jedoch aus der obigen Erklärung ersehen können, wird angenommen, dass "return" angeboren an Lambda gebunden ist, daher ist es natürlich dasselbe wie "def c (): return 3". Das heißt, es wird "3" zurückgegeben.
Q2
>>> c = lambda x: lambda: print('123')
>>> c(88)
<function <lambda>.<locals>.<lambda> at 0x1013740d0>
Ich bin nicht sicher, ob ich zu 100% getroffen bin, aber <a href = "http://www.pythontutor.com/visualize.html#code=c+%3D+lambda+x%3A+lambda%3A+print(%22123%) 22% 29% 0Ac (88% 29% 0Ac (% 29 (88% 29% 0Ac) (88% 29 (% 29 & mode = display & origin = opt-frontend.js & cumulative = false & heapPrimitives = false & textReferences = false & py = 3 & rawInputLst JSON =% 5B% 5D & curInstr = 4) Unter "target =" _ balnk "> pythontutor.com können Sie lesen, dass c eine Struktur von lambda x: hat, die lambda: print ('123) zurückgibt. ~~ Wahrscheinlich Da das zweite Lambda überhaupt nicht als Funktion aufgerufen wird, scheint das erste Lambda __ zu sein, das das zweite Lambda als Funktion genommen und die Funktion so zurückgegeben hat, wie sie ist. Wie ich bereits bemerkt habe, dachte ich, wenn Sie Lambda in Lambda setzen, übernimmt die erste Lambda-Funktion die zweite Lambda-Funktion und gibt sie als
>>> d = lambda f: f(4) # They can have functions as arguments as well.
>>> def square(x):
... return x * x
>>> d(square)
16
Mit anderen Worten, rufen Sie einfach den zweiten an.
>>> c = lambda x: lambda: print('123')
>>> c(88)()
123
Sie müssen jedoch vorsichtig sein, wie Sie es nennen. Weil das zweite Lambda nicht in der Lage ist, Argumente anzunehmen. Gleich wie def foo (): print (" 123 "). Also, wenn Sie versuchen:
>>> c(88)(3333)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: <lambda>() takes 0 positional arguments but 1 was given
Ich werfe einen Fehler. Die Verbesserungsmethode besteht einfach darin, ein Argument zu liefern.
>>> c = lambda x: lambda y: print("123")
>>> c(88)(333)
123
>>> c(88)()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: <lambda>() missing 1 required positional argument: 'y'
Wenn Sie dies jedoch tun, wird im Gegenteil ein Fehler ausgegeben, wenn nichts als Argument zu empfangen ist. Seien Sie also vorsichtig.
Q3
>>> t = lambda f: lambda x: f(f(f(x)))
>>> s = lambda x: x + 1
>>> t(s)(0)
3
Weitere Informationen finden Sie unter <a href = "http://www.pythontutor.com/visualize.html#code=t+%3D+lambda+f%3A+lambda+y%3A+f(f(f(y%29%29) % 29% 0As +% 3D + Lambda + x% 3A + x% 2B1% 0At (s% 29 (0% 29% 0A & mode = display & origin = opt-frontend.js & cumulative = false & heapPrimitives = false & textReferences = false & py = 3 & rawInputLstJSON =% 5Bstr Bitte beziehen Sie sich auf 0 "target =" _ blank "> pythontutor.com , aber" t (s) (0) "ist" (s) "und" (0) "eins nach dem anderen" bis " Es ist möglicherweise einfacher zu verstehen, ob Sie darauf achten, in der Reihenfolge 0 aufzurufen und worauf jede Variable von Lambda zeigt.
Die Variable in Lambda muss übrigens nicht "x" sein. Der Grund dafür ist, dass Sie es beim Empfang als Variable erhalten, die Sie nach Belieben angeben. Nichts ist auf Lambda beschränkt.
>>> t = lambda f: lambda y: f(f(f(y)))
>>> s = lambda x: x+1
>>> t(s)(0)
3
Q4
>>> bar = lambda y: lambda x: pow(x, y)
>>> bar()(15)
TypeError: <lambda>() missing 1 required positional argument: 'y'
Dies liegt daran, dass es kein Argument gibt, das "Lambda y" entspricht. Es funktioniert mit bar (some #) (15).
Q5
>>> foo = lambda: 32
>>> foobar = lambda x, y: x // y
>>> a = lambda x: foobar(foo(), bar(4)(x))
>>> a(2)
2
Ich denke, dies ist eher für Funktionen höherer Ordnung als für "Lambda" gedacht, daher besteht nicht die Notwendigkeit, so viel zu erklären.
Q6
>>> b = lambda x, y: print('summer') # When is the body of this function run?
# Nothing gets printed by the interpreter
>>> c = b(4, 'dog')
summer
>>> print(c)
None
Dies sollte offensichtlich sein, wenn Sie [reine nicht reine Funktionen] verstehen (http://qiita.com/weedslayer/items/9ac165613bc896a1aaa1).
Question 2: Question 2: Lambda the Environment Diagram
>>> a = lambda x: x * 2 + 1
>>> def b(b, x):
... return b(x + a(x))
>>> x = 3
>>> b(a, x)
Die Frage, ob der obige Code in einem Umgebungsdiagramm angewendet werden soll.
Denken Sie beim Schreiben eines Umgebungsdiagramms daran, den Eigennamen der Funktion anstelle des Variablennamens der Funktion für den Rahmennamen zu verwenden.
Question 3: Lambdas and Currying
Write a function lambda_curry2 that will curry any two argument function using lambdas. See the doctest if you're not sure what this means.
"""Returns a Curried version of a two argument function func.
>>> from operator import add
>>> x = lambda_curry2(add)
>>> y = x(3)
>>> y(5)
8
"""
"*** YOUR CODE HERE ***"
return
Ein Problem, das leicht gelöst werden kann, indem darauf geachtet wird, welche Funktion welchen Wert erhält. Zum Beispiel können Sie aus x = lambda_curry2 (add) sehen, dass die Funktion lambda_curry2 die Funktion als Argument empfängt. Geben Sie als nächstes die Zahlen nacheinander in die Variable "y" ein und "8" wird zurückgegeben. Dies bedeutet, dass Lambda die Nummer 2 erhält und der Rest des Prozesses zu dem Schluss kommt, dass die von lambda_curry2 abgerufene Funktion verwendet werden sollte. Die Antwort lautet also "Lambda x: Lambda y: func (x, y) zurückgeben". Die Frage war, warum return lambda x, z: func (x, z) nicht funktioniert, aber es ist y = x (3) (5) beim Aufruf von λ. Ich denke, es ist nur der Unterschied zwischen = (3,5) `.
>>> def lambda_curry(func):
... return lambda x, y: func(x,y)
>>> from operator import add
>>> x = lambda_curry(add)
>>> y = x(3)(5)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: <lambda>() missing 1 required positional argument: 'y'
>>> l = x(3,5)
>>> l
8
Der Rest der Probleme wurde gelöst, aber Funktionen höherer Ordnung werden beteiligt sein, sodass ich es etwas genauer studieren und anderen erklären kann. Ich werde es aktualisieren, wenn ich das Level erreicht habe.
Lambda w/ List Comprehension
Ich fand heraus, dass ich mit Lambda und Listenverständnis etwas Praktisches machen konnte, also habe ich ein Memorandum.
Es ist keine sehr effiziente Art zu suchen, aber wenn Sie nach einer Primzahl suchen, können Sie mit "Lambda" schreiben:
nums = range(2,30)
for i in range(2,8):
nums = list(filter(lambda x: x == i or x % i, nums))
print(nums)
Die andere besteht darin, einen geeigneten Satz zu finden, ihn als Satz einzufügen und dann das folgende Skript auszuführen, um die Anzahl der Zeichen für jedes Wort in die Liste aufzunehmen und zurückzugeben. Zum Beispiel:
sentence = "I was a joke, and my life was a joke."
print(list(map(lambda x: len(x), sentence.split(" ")))) # [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
print(len(list(map(lambda x: len(x), sentence.split(" "))))) # 10 (=# of words)
Referenzierter Link
Recommended Posts