Pourquoi les Python lambdas sont-ils utiles?
J'essaie de comprendre Python lambdas. Est-ce que lambda est un de ces éléments linguistiques "intéressants" qui, dans la vie réelle, devraient être oubliés?
Je suis sûr que cela pourrait être nécessaire dans certains cas Edge, mais compte tenu de son obscurité, de sa redéfinition potentielle dans les versions futures (mon hypothèse reposant sur les différentes définitions de celle-ci) et de la réduction de la clarté du codage - si cela se produisait. être évité?
Cela me rappelle le débordement (buffer overflow) de types C - en pointant sur la variable supérieure et en surcharge pour définir les autres valeurs de champ. Cela ressemble à une sorte de technicien en showmanship mais cauchemar de codeur de maintenance.
Parlez-vous de fonctions lambda ? Comme
lambda x: x**2 + 2*x - 5
Ces choses sont en fait très utiles. Python supporte un style de programmation appelé programmation fonctionnelle dans lequel vous pouvez transférer des fonctions à d'autres fonctions. Exemple:
mult3 = filter(lambda x: x % 3 == 0, [1, 2, 3, 4, 5, 6, 7, 8, 9])
définit mult3 sur [3, 6, 9], les éléments de la liste d'origine multiples de 3. Cela est plus court (et plus clair, plus clair) que
def filterfunc(x):
return x % 3 == 0
mult3 = filter(filterfunc, [1, 2, 3, 4, 5, 6, 7, 8, 9])
Bien sûr, dans ce cas particulier, vous pourriez faire la même chose qu'une compréhension de liste:
mult3 = [x for x in [1, 2, 3, 4, 5, 6, 7, 8, 9] if x % 3 == 0]
(ou même comme range(3,10,3)), mais il existe de nombreux autres cas d'utilisation plus sophistiqués dans lesquels vous ne pouvez pas utiliser une liste de compréhension et une fonction lambda peut être le moyen le plus rapide d'écrire quelque chose.
Renvoyer une fonction d'une autre fonction
>>> def transform(n): ... return lambda x: x + n ... >>> f = transform(3) >>> f(4) 7Ceci est souvent utilisé pour créer des wrappers de fonctions, tels que les décorateurs de Python.
Combinaison d'éléments d'une séquence itérable avec
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'Tri par une autre clé
>>> 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]
J'utilise régulièrement les fonctions lambda. Il m'a fallu un certain temps pour m'y habituer, mais j'ai fini par comprendre qu'ils constituaient une partie très précieuse de la langue.
lambda n'est qu'une manière élégante de dire function. À part son nom, il n’ya rien d’obscur, d’intimidant ou de mystérieux. Lorsque vous lisez la ligne suivante, remplacez lambda par function dans votre esprit:
>>> f = lambda x: x + 1
>>> f(3)
4
Il définit juste une fonction de x. Certaines autres langues, comme R, le disent explicitement:
> f = function(x) { x + 1 }
> f(3)
4
Vous voyez? C'est l'une des choses les plus naturelles à faire dans la programmation.
Le résumé en deux lignes:
- Fermetures : Très utile. Apprenez-les, utilisez-les, aimez-les.
- Mot clé
lambdade Python: inutile, occasionnellement utile. Si vous vous trouvez en train de faire quelque chose de complexe avec ce dernier, rangez-le et définissez une fonction réelle.
Un lambda fait partie d'un mécanisme d'abstraction très important qui traite des fonctions d'ordre supérieur. Pour bien comprendre sa valeur, regardez des leçons de grande qualité tirées de Abelson et Sussman , et lisez le livre SICP
Ce sont des questions pertinentes dans le secteur des logiciels modernes et qui deviennent de plus en plus populaires.
Je doute que Lambda partira. Voir message de Guido pour finalement renoncer à essayer de l'enlever. Voir aussi aperçu du conflit .
Vous pouvez consulter cet article pour en savoir plus sur l'historique des caractéristiques fonctionnelles de Python: http://python-history.blogspot.com/2009/04/origins-of-pythons-functional-features.html
Curieusement, la carte, les filtres et les fonctions de réduction qui avaient initialement motivé l'introduction de lambda et d'autres fonctionnalités ont été remplacés dans une large mesure par la compréhension de liste et les expressions génératrices. En fait, la fonction de réduction a été supprimée de la liste des fonctions intégrées dans Python 3.0. (Cependant, il n'est pas nécessaire d'envoyer des plaintes concernant la suppression de lambda, map ou filter: elles restent. :-)
Mes deux cents: Lambda vaut rarement la peine d'être clarifiée. Généralement, il existe une solution plus claire qui n'inclut pas le lambda.
les lambdas sont extrêmement utiles dans la programmation d'interface graphique. Par exemple, disons que vous créez un groupe de boutons et que vous souhaitez utiliser un seul rappel paramétré plutôt qu'un rappel unique par bouton. Lambda vous permet d'accomplir cela facilement:
for value in ["one","two","three"]:
b = tk.Button(label=value, command=lambda arg=value: my_callback(arg))
b.pack()
(Remarque: bien que cette question concerne spécifiquement lambda, vous pouvez également utiliser functools.partial pour obtenir le même type de résultat.)
L'alternative consiste à créer un rappel séparé pour chaque bouton, ce qui peut entraîner une duplication du code.
En Python, lambda n'est qu'un moyen de définir des fonctions en ligne,
a = lambda x: x + 1
print a(1)
et..
def a(x): return x + 1
print a(1)
.. sont les mêmes exact .
Avec lambda, vous ne pouvez rien faire avec une fonction normale. Dans Python, _ les fonctions sont un objet comme tout le reste, et lambdas définit simplement une fonction:
>>> a = lambda x: x + 1
>>> type(a)
<type 'function'>
Honnêtement, je pense que le mot clé lambda est redondant en Python. Je n'ai jamais eu besoin de les utiliser (ni d'en utiliser un où une fonction normale, une compréhension de liste ou l'une des nombreuses fonctions intégrées aurait pu être mieux utilisée). au lieu)
Pour un exemple complètement aléatoire, tiré de l'article "Le lambda de Python est cassé!" :
Pour voir comment lambda est cassé, essayez de générer une liste de fonctions
fs=[f0,...,f9]oùfi(n)=i+n. Premier essai:>>> fs = [(lambda n: i + n) for i in range(10)] >>> fs[3](4) 13
Je dirais que même si cela fonctionnait, c'est horriblement "antipythonique", les mêmes fonctionnalités pourraient être écrites de nombreuses autres manières, par exemple:
>>> n = 4
>>> [i + n for i in range(10)]
[4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
Oui, ce n'est pas la même chose, mais j'ai jamais vu une raison pour laquelle la génération d'un groupe de fonctions lambda dans une liste était requise. Cela pourrait avoir un sens dans d'autres langages, mais Python n'est pas Haskell (ou LISP, ou ...)
Veuillez noter que nous pouvons utiliser lambda et toujours obtenir les résultats souhaités de cette manière:
>>> fs = [(lambda n,i=i: i + n) for i in range(10)] >>> fs[3](4) 7
Modifier:
Il y a quelques cas où lambda est utile, par exemple, il est souvent pratique de connecter des signaux dans des applications PyQt, comme ceci:
w = PyQt4.QtGui.QLineEdit()
w.textChanged.connect(lambda event: dothing())
Il suffit de faire w.textChanged.connect(dothing) pour appeler la méthode dothing avec un argument supplémentaire event et provoquer une erreur. L'utilisation de lambda signifie que nous pouvons facilement supprimer l'argument sans avoir à définir une fonction d'habillage.
Je trouve que lambda est utile pour une liste de fonctions qui font la même chose, mais dans des circonstances différentes. Comme le règles plurielles de Mozilla .
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'
Si vous deviez définir une fonction pour tous ceux-là, vous deviendriez fou à la fin. En outre, cela ne serait pas agréable avec des noms de fonction tels que plural_rule_1, plural_rule_2, etc. Et vous auriez besoin de eval() lorsque vous dépendez d'un identifiant de fonction variable.
Pratiquement tout ce que vous pouvez faire avec lambda vous pouvez faire mieux avec des fonctions nommées ou des expressions de liste et de générateur.
Par conséquent, dans la plupart des cas, vous ne devriez utiliser que l'un de ceux-ci (à l'exception peut-être du code de travail écrit dans l'interpréteur interactif).
J'utilise Python depuis quelques années et je ne me suis jamais heurté à un cas où j'avais besoin de lambda . Vraiment, comme le dit tutorial , c'est juste pour le sucre syntaxique.
La fonction Lambda est une manière non bureaucratique de créer une fonction.
C'est ça. Par exemple, supposons que vous ayez votre fonction principale et que vous ayez besoin d’équilibrer les valeurs. Voyons la manière traditionnelle et la manière lambda de le faire:
Façon traditionnelle:
def main():
...
...
y = square(some_number)
...
return something
def square(x):
return x**2
Le chemin lambda:
def main():
...
square = lambda x: x**2
y = square(some_number)
return something
Regarde la différence?
Les fonctions Lambda vont très bien avec les listes, comme la compréhension des listes ou la carte. En fait, la compréhension de liste est une façon "pythonique" de vous exprimer en utilisant lambda. Ex:
>>>a = [1,2,3,4]
>>>[x**2 for x in a]
[1,4,9,16]
Voyons ce que chaque élément de la syntaxe signifie:
[]: "Donnez-moi une liste"
x ** 2: "utilisant cette fonction nouveau-né"
pour x dans un: "dans chaque élément d'un"
C'est pratique, non? Créer des fonctions comme celle-ci. Réécrivons-le en utilisant lambda:
>>> square = lambda x: x**2
>>> [square(s) for x in a]
[1,4,9,16]
Utilisons maintenant map, qui est la même chose, mais plus neutre sur le plan linguistique. Maps prend 2 arguments:
(i) une fonction
(ii) un iterable
Et vous donne une liste où chaque élément est la fonction appliquée à chaque élément de l'itérable.
Donc, en utilisant la carte, nous aurions:
>>> a = [1,2,3,4]
>>> squared_list = map(lambda x: x**2, a)
Si vous maîtrisez les lambdas et la cartographie, vous aurez un grand pouvoir pour manipuler les données de manière concise. Les fonctions Lambda ne sont ni obscures ni ne nuisent à la clarté du code. Ne confondez pas quelque chose de difficile avec quelque chose de nouveau. Une fois que vous commencez à les utiliser, vous le trouverez très clair.
Je ne peux pas parler de l'implémentation particulière de lambda dans python, mais en général, les fonctions de lambda sont vraiment pratiques. C'est une technique de base (peut-être même LA technique) de la programmation fonctionnelle, et ils sont également très utiles dans les programmes orientés objet. Pour certains types de problèmes, ce sont la meilleure solution, il ne faut donc pas oublier!
Je vous suggère de lire fermetures et la fonction map (qui renvoie à python docs, mais il existe dans presque tous les langages prenant en charge les constructions fonctionnelles) pour voir pourquoi c'est utile.
Une des bonnes choses à propos de lambda qui, à mon avis, est sous-estimée est que c'est une façon de différer une évaluation pour des formulaires simples jusqu'à ce que la valeur soit nécessaire. Laissez-moi expliquer.
De nombreuses routines de bibliothèque sont implémentées de manière à ce que certains paramètres puissent être appelés (dont lambda est l'un). L'idée est que la valeur réelle sera calculée uniquement au moment où elle sera utilisée (plutôt que lorsqu'elle sera appelée). Un exemple (artificiel) pourrait aider à illustrer ce point. Supposons que vous ayez une routine qui consignera un horodatage donné. Vous voulez que la routine utilise l'heure actuelle moins 30 minutes. Tu l'appellerais comme si
log_timestamp(datetime.datetime.now() - datetime.timedelta(minutes = 30))
Supposons maintenant que la fonction réelle sera appelée uniquement lorsqu'un événement donné se produit et que vous souhaitez que l'horodatage soit calculé uniquement à ce moment. Vous pouvez faire ça comme ça
log_timestamp(lambda : datetime.datetime.now() - datetime.timedelta(minutes = 30))
En supposant que le log_timestamp puisse gérer les callables comme ceci, il évaluera cela quand il en aura besoin et vous obtiendrez l'horodatage à ce moment-là.
Il y a bien sûr d'autres moyens de le faire (en utilisant le module operator par exemple), mais j'espère avoir bien compris le propos.
Update : Ici est un exemple concret un peu plus concret.
Update 2 : Je pense que ceci est un exemple de ce qu'on appelle un thunk .
Comme indiqué ci-dessus, l'opérateur lambda dans Python définit une fonction anonyme, et dans Python, les fonctions sont des fermetures. Il est important de ne pas confondre le concept de fermeture avec l'opérateur lambda, qui est simplement une méthadone syntaxique.
Lorsque j’ai commencé à utiliser Python il y a quelques années, j’utilisais beaucoup les lambdas, pensant qu’ils étaient cool, ainsi que les listes de compréhension. Cependant, j'ai écrit et je dois maintenir un grand site Web écrit en Python, avec quelques milliers de points de fonctionnement. J'ai appris par expérience que les lambdas seraient peut-être acceptables pour le prototypage, mais n'offriraient rien en plus des fonctions en ligne (fermetures nommées) sauf pour sauver quelques clés, ou parfois pas.
Fondamentalement, cela se résume à plusieurs points:
- il est plus facile de lire un logiciel écrit explicitement en utilisant des noms significatifs. Les fermetures anonymes, par définition, ne peuvent pas avoir de nom significatif, car elles n'ont pas de nom. Cette brièveté semble, pour une raison quelconque, infecter également les paramètres lambda. C'est pourquoi nous voyons souvent des exemples tels que lambda x: x + 1
- il est plus facile de réutiliser des fermetures nommées, car elles peuvent être référencées nommément plus d'une fois, lorsqu'il existe un nom pour les référencer.
- il est plus facile de déboguer le code qui utilise des fermetures nommées au lieu de lambdas, car le nom apparaîtra dans tracebacks et autour de l'erreur.
C'est une raison suffisante pour les arrondir et les convertir en fermetures nommées. Cependant, je garde deux autres rancunes contre des fermetures anonymes.
La première, c'est simplement qu'ils ne sont qu'un mot-clé inutile qui encombre le langage.
La seconde rancune est plus profonde et au niveau du paradigme, c’est-à-dire que je n’aime pas qu’ils promeuvent un style de programmation fonctionnelle, car ce style est moins flexible que les styles de transmission de message, orienté objet ou procédural, car le lambda calcul n’est pas de Turing. complète (heureusement en Python, nous pouvons toujours sortir de cette restriction même à l'intérieur d'un lambda). Les raisons pour lesquelles je pense que les lambdas font la promotion de ce style sont les suivantes:
Il y a un retour implicite, c’est-à-dire qu’ils semblent "devoir" être des fonctions.
Ils constituent un mécanisme alternatif de masquage d'état par rapport à un autre: mécanisme: plus explicite, plus lisible, plus réutilisable et plus général.
J'essaie beaucoup d'écrire Python sans lambda et d'enlever les lambdas à vue. Je pense que Python serait un langage légèrement meilleur sans lambdas, mais ce n’est que mon opinion.
Les lambda sont en fait des constructions très puissantes qui découlent d’idées de programmation fonctionnelle, et c’est quelque chose qui ne sera en aucun cas facilement révisable, redéfini ou supprimé dans un proche avenir de Python. Ils vous aident à écrire un code plus puissant car il vous permet de passer des fonctions sous forme de paramètres, d’où l’idée de fonctions comme citoyens de première classe.
Les Lambdas ont tendance à être déroutants, mais une fois que vous avez acquis une solide compréhension, vous pouvez écrire un code propre et élégant comme celui-ci:
squared = map(lambda x: x*x, [1, 2, 3, 4, 5])
La ligne de code ci-dessus renvoie une liste des carrés des nombres de la liste. Bien sûr, vous pourriez aussi le faire comme:
def square(x):
return x*x
squared = map(square, [1, 2, 3, 4, 5])
Il est évident que l'ancien code est plus court, et cela est particulièrement vrai si vous avez l'intention d'utiliser la fonction map (ou toute fonction similaire prenant une fonction en tant que paramètre) à un seul endroit. Cela rend également le code plus intuitif et élégant.
En outre, comme @David Zaslavsky l'a mentionné dans sa réponse, la compréhension de liste n'est pas toujours la meilleure solution, en particulier si votre liste doit obtenir des valeurs issues d'une méthode mathématique obscure.
D'un point de vue plus pratique, l'un des plus gros avantages des lambdas pour moi récemment réside dans l'interface utilisateur graphique et la programmation événementielle. Si vous examinez les callbacks dans Tkinter, ils ne prennent comme arguments que l'événement qui les a déclenchés. Par exemple.
def define_bindings(widget):
widget.bind("<Button-1>", do-something-cool)
def do-something-cool(event):
#Your code to execute on the event trigger
Maintenant, si vous aviez des arguments à transmettre? Quelque chose d'aussi simple que de passer 2 arguments pour stocker les coordonnées d'un clic de souris. Vous pouvez facilement le faire comme ceci:
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
Vous pouvez maintenant soutenir que cela peut être fait en utilisant des variables globales, mais voulez-vous vraiment vous casser la tête en vous inquiétant de la gestion de la mémoire et des fuites, en particulier si la variable globale sera simplement utilisée à un endroit particulier? Ce serait juste un mauvais style de programmation.
En bref, les lambdas sont géniaux et ne doivent jamais être sous-estimés. Les lambdas Python ne sont pas identiques aux lambdas LISP (qui sont plus puissants), mais vous pouvez vraiment faire beaucoup de choses magiques avec eux.
Les Lambda sont profondément liés au style de programmation fonctionnel en général. L’idée que Google utilise pour mettre en œuvre la plupart de ses algorithmes est de résoudre les problèmes en appliquant une fonction à certaines données et en fusionnant les résultats.
Les programmes écrits dans un style de programmation fonctionnel sont faciles à mettre en parallèle et deviennent donc de plus en plus importants avec les machines multicœurs modernes. En bref, NON, vous ne devriez pas les oublier.
Premiers félicitations qui ont réussi à comprendre lambda. À mon avis, cette construction est vraiment puissante. La tendance actuelle vers les langages de programmation fonctionnels est sûrement un indicateur qu'il ne faut ni l'éviter, ni la redéfinir dans un proche avenir.
Vous devez juste penser un peu différent. Je suis sûr que vous allez bientôt l'adorer. Mais faites attention si vous ne traitez qu'avec du python. Parce que le lambda n'est pas une vraie fermeture, il est "cassé" en quelque sorte: pythons lambda est cassé
J'utilise lambdas pour éviter la duplication de code. Cela rendrait la fonction facilement compréhensible, par exemple:
def a_func()
...
if some_conditon:
...
call_some_big_func(arg1, arg2, arg3, arg4...)
else
...
call_some_big_func(arg1, arg2, arg3, arg4...)
Je remplace ça par un temp 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)
Je suis un débutant python, alors pour avoir une idée claire de lambda, je l'ai comparé à une boucle 'pour'; en termes d'efficacité. Voici le 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)
Un cas utile pour utiliser lambdas est de améliorer la lisibilité des compréhensions à longue liste. Dans cet exemple, loop_dic est synonyme de clarté, mais imaginez que loop_dic soit très long. Si vous utilisiez une valeur simple incluant i à la place de la version lambda de cette valeur, vous obtiendrez un 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'}]
Au lieu de
>>> lis = [{"name": "Peter"}, {"name": "Josef"}]
>>> new_lis = [{"name": i["name"] + " Wallace"} for i in lis]
>>> new_lis
[{'name': 'Peter Wallace'}, {'name': 'Josef Wallace'}]
Je viens juste de commencer Python et je me suis précipité à Lambda-, ce qui m'a pris un certain temps à comprendre.
Notez que ce n'est pas une condamnation de quoi que ce soit. Tout le monde a un ensemble différent de choses qui ne viennent pas facilement.
Lambda est-il un de ces éléments linguistiques "intéressants" qui, dans la vie réelle, devraient être oubliés?
Non.
Je suis sûr qu'il y a des cas dans lesquels Edge pourrait être nécessaire, mais vu son obscurité,
Ce n'est pas obscur. Les 2 dernières équipes sur lesquelles j'ai travaillé, tout le monde a utilisé cette fonctionnalité tout le temps.
le potentiel de sa redéfinition dans les versions futures (mon hypothèse basée sur les différentes définitions de celle-ci)
Je n'ai vu aucune proposition sérieuse pour le redéfinir en Python, si ce n'est de fixer la sémantique de la fermeture il y a quelques années.
et la réduction de la clarté du codage - devrait-il être évité?
Ce n'est pas moins clair, si vous l'utilisez correctement. Au contraire, avoir plus de constructions de langage disponibles augmente clarté.
Cela me rappelle le débordement (débordement de tampon) de types C - pointer vers la variable supérieure et surcharger pour définir les autres valeurs de champ ... une sorte de technicien en spectacle mais en cauchemar de codeur de maintenance ..
Lambda est comme un débordement de tampon? Sensationnel. Je ne peux pas imaginer comment vous utilisez lambda si vous pensez que c'est un "cauchemar de maintenance".
J'ai commencé à lire aujourd'hui le livre de David Mertz intitulé "Text Processing in Python". Alors qu'il a une description assez concise de Lambda, les exemples du premier chapitre combinés à l'explication de l'annexe A les ont fait sauter de la page pour moi (enfin) et tout d'un coup j'ai compris leur valeur. Cela ne veut pas dire que son explication fonctionnera pour vous et que je suis toujours au stade de la découverte. Je ne tenterai donc pas d’ajouter à ces réponses autre que ce qui suit: Je suis nouveau sur Python Je suis nouveau sur OOP Les Lambdas ont été une lutte pour moi. Maintenant que je lis Mertz, je pense les comprendre et je les considère aussi utiles que possible car ils permettent une approche plus propre de la programmation.
Il reproduit le zen de Python, dont une ligne est Simple c'est mieux que complexe. En tant que programmeur non-POO lisant du code avec lambdas (et jusqu'à la semaine dernière, j'ai compris)C'est simple?. J'ai finalement finalement compris aujourd'hui que ces fonctionnalités rendent le code beaucoup plus lisible et compréhensible que le code alternatif, qui est invariablement une boucle. J'ai aussi réalisé que, comme les états financiers, Python n'était pas conçu pour l'utilisateur novice, mais plutôt pour l'utilisateur qui souhaite s'instruire. Je ne peux pas croire à quel point cette langue est puissante. Quand je me suis enfin rendu compte du but et de la valeur des lambdas, je voulais créer une trentaine de programmes et commencer à les intégrer, le cas échéant.
Je peux vous donner un exemple où j'avais réellement besoin de lambda grave. Je crée un programme graphique, où l’utilisation de clic droit sur un fichier et l’assigne à l’une des trois options. Il se trouve que dans Tkinter (le programme d'interface graphique dans lequel je suis en train d'écrire), lorsque quelqu'un appuie sur un bouton, il ne peut pas être affecté à une commande qui prend des arguments. Donc, si j'ai choisi l'une des options et que je voulais que le résultat de mon choix soit:
print 'hi there'
Alors pas de problème. Mais si j’ai besoin de mon choix pour avoir un détail particulier. Par exemple, si je choisis le choix A, il appelle une fonction prenant un argument dépendant du choix A, B ou C, TKinter ne pourrait pas le supporter. Lamda était la seule option pour contourner ça en fait ...
J'utilise lambda pour créer des rappels incluant des paramètres. Il est plus simple d'écrire un lambda sur une ligne que d'écrire une méthode pour exécuter la même fonctionnalité.
Par exemple:
import imported.module
def func():
return lambda: imported.module.method("foo", "bar")
par opposition à:
import imported.module
def func():
def cb():
return imported.module.method("foo", "bar")
return cb
Je l'utilise assez souvent, principalement en tant que objet null ou pour lier partiellement des paramètres à une fonction.
Voici des exemples:
pour implémenter un motif d'objet nul:
{
DATA_PACKET: self.handle_data_packets
NET_PACKET: self.handle_hardware_packets
}.get(packet_type, lambda x : None)(payload)
pour la liaison de paramètres:
disons que j'ai l'API suivante
def dump_hex(file, var)
# some code
pass
class X(object):
#...
def packet_received(data):
# some kind of preprocessing
self.callback(data)
#...
Ensuite, quand je ne veux pas vider rapidement les données reçues dans un fichier, je le fais:
dump_file = file('hex_dump.txt','w')
X.callback = lambda (x): dump_hex(dump_file, x)
...
dump_file.close()
Lambda est un constructeur de procédure. Vous pouvez synthétiser des programmes au moment de l'exécution, bien que le lambda de Python ne soit pas très puissant. Notez que peu de gens comprennent ce genre de programmation.