python3x: fonction lambda
Quand je faisais Lab, j'ai vu une fonction lambda, donc j'ai inclus la signification d'une critique.
Lambda Function
En un mot, lambda facilite l'attribution d'une fonction à une variable appropriée.
Définition
bind a function to a name using the same syntax and assignment statement.
Tout d'abord, considérons l'expression suivante.
>>> x = 10
>>> square = x*x
>>> square
100
>>> square = lamnda x: x*x
>>> square
<function...>
>>> square(4)
16
>> square(10)
100
J'ai essayé de le résumer en une figure simple en me référant aux diapositives de la conférence.
Différence entre «def» et «lambda»
Pour résumer les différences en référence à l'exemple ci-dessus:
- 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.
Il n'y a pas beaucoup de différence dans le fonctionnement de base. Alors, quelle est la différence après tout? Vous pouvez le voir en essayant. Ce qui suit est un croquis des diapositives de la conférence.
Si vous créez une fonction avec def, le nom sera donné sur-le-champ, mais si vous créez une fonction avec lambda, même si la fonction est terminée, vous n'aurez pas de nom tant que vous n'aurez pas assigné le nom par ʻinstruction d'assignation. C'est. En d'autres termes, en python, vous pouvez créer une fonction sur place lorsque vous en avez besoin sans avoir à utiliser def statement` pour la nommer.
A lambda expression evaluates to a function that has a single return expression as its body.
À la suite de l'exécution de «expression lambda», elle devient «fonction lambda» et joue un rôle en tant que fonction. Puisque cette fonction n'a pas de nom inné, python l'écrit simplement comme «
>>> s = lambda x: x * x
>>> s
<function<lambda> at xxxxxxx>
>>> s(12)
144
À part cela, il n'y a pas de différence fondamentale.
Translating between named and anonymous functions
Je me suis demandé (et je l'ai peut-être écrit quelque part), mais quand je compare les deux expressions «lambda x, y» et «lambda x: lambda y», il y a une différence autre que le nombre de paramètres et l'argument. Il n'y en avait pas.
>>> adder = lambda x: lambda y: x + y
>>> adder2 = lambda x, y: x + y
>>> adder(1)(3)
4
>>> adder2(1,3)
4
Cependant, la différence est devenue plus claire en comparant «def» et «lambda» lorsque j'ai participé à la session de révision.
Si vous y réfléchissez, cela est facile à comprendre si vous pensez au second lambda comme def helper (y): return dans def.
Fonctions d'ordre supérieur peut être fait facilement.
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% 0Aresult +% 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 </ strong> Vous pouvez voir le mouvement de fonction plus précis avec un>.
Notez que la fonction lambda x: f (g (x)) à l'intérieur de la fonction compose1 est faite avec un cadre f1 au lieu d'un cadre global. La raison est que ce n'est que lorsque compose1 est appelé parf qu'il entre dans compose1. Au moment où vous appelez compose1, vous avez déjà créé une image f1, donc [p = g]. Une autre chose que j'ai remarquée concerne les deux lambdas que je passe comme arguments à la fonction compose1. Personnellement, je pensais que cela serait défini lorsque j'appelais la fonction compose1, alors j'ai écrit [p = f1], mais apparemment quand je l'ai défini comme` compose1 (f, g) ʻabove ( Depuis que j'ai assigné un nom à la variable (indépendamment de ce que je reçois), je pense que le résultat est [p = g] que je le lance comme «lambda» ou autre. Si vous faites une erreur en utilisant un tel lambda, cela deviendra plus difficile à comprendre.
lambda expressions are notoriously illegible, despite their brevity.
Cela signifie que vous pouvez écrire la fonction ci-dessus comme compose1 = lambda f, g: lambda x: f (g (x)), mais cela prend souvent un certain temps pour bien comprendre.
Origine de «lambda»
Apparemment, lambda est né parce que les écrivains de l'époque ne pouvaient pas écrire la formule $ ŷ. Y * y $ en mathématiques avec une machine à écrire. Ils ont réécrit l'expression comme $ Λ y. Y x y $, donc c'est devenu $ λ y. Y x y $, et ils voient toujours le symbole $ λ $. Pour plus d'informations, consultez Peter Norvig.
Bulleting ce que vous avez remarqué en utilisant lambda
J'écrirai ce que j'ai remarqué en faisant le problème de lab02.
Question 1: WWPP: Lambda the Free
Q1
>>> c = lambda: 3
>>> c()
3
Comme une option
- Mettez "Aucun" comme valeur (avec une partie manquante?)
- Afficher «3», mais «Aucun» est la valeur (= imprimer)
- Sortez «3» comme valeur (= retour) Est-ce à propos? Cependant, comme vous pouvez le voir à partir de l'explication ci-dessus, on pense que «return» est attaché congénitalement à lambda, donc c'est naturellement la même chose que «def c (): return 3». Autrement dit, il renvoie «3».
Q2
>>> c = lambda x: lambda: print('123')
>>> c(88)
<function <lambda>.<locals>.<lambda> at 0x1013740d0>
Je ne suis pas sûr d'être touché à 100%, mais <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 & rawInputLstJSON =% 5B% 5D & curInstr = 4)) Depuis "target =" _ balnk "> pythontutor.com , vous pouvez lire que c a la structurelambda x:qui renvoie lambda: print ('123). ~~ Probablement Puisque le second lambda n'est pas appelé en tant que fonction en premier lieu, il semble que le premier lambda soit __ qui a pris le second lambda comme fonction et a renvoyé la fonction telle quelle. Comme je l'ai remarqué, j'ai pensé que si vous mettez lambda dans lambda, la première fonction lambda prendra la deuxième fonction lambda et la renverra comme
>>> d = lambda f: f(4) # They can have functions as arguments as well.
>>> def square(x):
... return x * x
>>> d(square)
16
En d'autres termes, appelez simplement le second.
>>> c = lambda x: lambda: print('123')
>>> c(88)()
123
Cependant, vous devez faire attention à la façon dont vous l'appelez. Parce que le deuxième lambda n'a pas la capacité de prendre des arguments. Identique à def foo (): print (" 123 "). Donc, si vous essayez:
>>> c(88)(3333)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: <lambda>() takes 0 positional arguments but 1 was given
Je lance une erreur. La méthode d'amélioration consiste simplement à donner un argument.
>>> 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'
Cependant, si vous faites cela, au contraire, s'il n'y a rien à recevoir comme argument, une erreur sera renvoyée, alors soyez prudent.
Q3
>>> t = lambda f: lambda x: f(f(f(x)))
>>> s = lambda x: x + 1
>>> t(s)(0)
3
Pour plus d'informations, <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 =% 5B% 5D & curInstr =% 5B% 5D & curInstr = Veuillez vous référer à 0 "target =" _ blank "> pythontutor.com , mais t (s) (0) ʻest (s) ʻet (0) ʻun par un s à Cela peut être plus facile à comprendre si vous faites attention à appeler dans l'ordre de 0et à quoi pointe chaque variable delambda`.
À propos, la variable dans lambda ne doit pas nécessairement être «x». La raison en est que lorsque vous le recevez, vous le recevez en tant que variable que vous spécifiez comme vous le souhaitez. Rien n'est limité à lambda.
>>> 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'
C'est parce qu'il n'y a pas d'argument correspondant à «lambda y». Cela fonctionne avec bar (some #) (15).
Q5
>>> foo = lambda: 32
>>> foobar = lambda x, y: x // y
>>> a = lambda x: foobar(foo(), bar(4)(x))
>>> a(2)
2
Je pense que cela est fait pour les fonctions d'ordre supérieur plutôt que pour «lambda», il n'est donc pas nécessaire d'expliquer cela.
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
Cela devrait être évident si vous comprenez les fonctions non pures pures.
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)
La question de savoir s'il faut appliquer le code ci-dessus dans un diagramme environnemental.
Lors de l'écriture d'un diagramme d'environnement, n'oubliez pas de nommer le cadre en utilisant le nom intrinsèque de la fonction au lieu du nom de la variable de la fonction.
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
Un problème qui peut être facilement résolu en faisant attention à quelle fonction reçoit quelle valeur. Par exemple, vous pouvez voir à partir de x = lambda_curry2 (add) que la fonction lambda_curry2 reçoit la fonction comme argument. Ensuite, entrez les nombres un par un dans la variable «y» et «8» est renvoyé. Cela signifie que lambda reçoit le numéro 2 et le reste du processus arrive à la conclusion que la fonction prise par lambda_curry2 doit être utilisée. La réponse est donc «return lambda x: lambda y: func (x, y)». La question était de savoir pourquoi return lambda x, z: func (x, z) ne fonctionne pas, mais c'est y = x (3) (5) lors de l'appel de λ. Je pense que c'est juste la différence entre = (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
Le reste des problèmes a déjà été résolu, mais comme les fonctions d'ordre supérieur sont impliqués, je peux l'étudier un peu plus en profondeur et l'expliquer aux autres. Je le mettrai à jour quand j'aurai atteint le niveau.
Lambda w/ List Comprehension
J'ai trouvé que je pouvais faire des choses pratiques avec lambda et la compréhension de liste, donc j'ai un mémorandum.
Ce n'est pas un moyen très efficace de rechercher, mais lorsque vous recherchez un nombre premier, vous pouvez utiliser lambda pour écrire:
nums = range(2,30)
for i in range(2,8):
nums = list(filter(lambda x: x == i or x % i, nums))
print(nums)
L'autre est de trouver une phrase appropriée, de la mettre en tant que phrase, puis d'exécuter le script suivant pour mettre le nombre de caractères pour chaque mot dans la liste et le renvoyer. Par exemple:
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)
Lien référencé
Recommended Posts