Pourquoi Python lambdas est-il utile? [fermé]

j'essaie de comprendre Python lambdas. Lambda est-il l'un de ces éléments linguistiques "intéressants" qui, dans la vie réelle, devraient être oubliés?

je suis sûr qu'il y a des cas extrêmes où il pourrait être nécessaire, mais étant donné l'obscurité de celui - ci, la possibilité qu'il soit redéfini dans les versions futures (mon hypothèse basée sur les différentes définitions de celui-ci) et la clarté de codage réduite-devrait-il être évitée?

cela me rappelle le débordement (dépassement de tampon) de types C - pointant vers le haut de la variable ou de la surcharge pour régler les autres valeurs de champ. Ça ressemble à une sorte de technique de mise en scène mais un cauchemar de codeur d'entretien.

839
demandé sur ayhan 2009-05-21 00:40:01
la source

26 ответов

parlez-vous de fonctions lambda ? Comme

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

ces choses sont en fait très utiles. Python soutient un style de programmation appelé programmation fonctionnelle où vous pouvez passer des fonctions à d'autres fonctions pour faire des choses. Exemple:

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

jeux mult3 à [3, 6, 9] , les éléments de la liste d'origine qui sont des multiples de 3. C'est plus court (et, pourrait-on argumenter, plus claire) 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 liste de compréhension:

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 où vous ne pouvez pas utiliser une compréhension de liste et une fonction lambda peut être le moyen le plus court pour écrire quelque chose.

  • retournant une fonction d'une autre fonction

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

    ceci est souvent utilisé pour créer des enveloppements de fonctions, tels que les décorateurs de Python.

  • combinant des é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 des fonctions lambda sur une base régulière. Il m'a fallu un certain temps pour s'habituer à mais j'ai fini par comprendre que c'était une partie très précieuse de la langue.

908
répondu David Z 2016-12-06 14:26:54
la source

lambda est juste une façon fantaisiste de dire function . À part son nom, il n'y a rien d'obscur, d'intimidant ou de mystérieux à son sujet. Quand vous lisez la ligne suivante, remplacer lambda par function dans votre esprit:

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

il définit simplement une fonction de x . D'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.

332
répondu user251650 2010-01-16 18:03:17
la source

Les deux de la ligne de résumé:

  1. fermetures : très utile. Apprenez-les, utilisez-les, aimez-les.
  2. Python's lambda mot clé: inutile, parfois utile. Si vous vous trouvez à faire quelque chose de quelque peu complexe avec elle, rangez-la et définissez une fonction réelle.
96
répondu John Fouhy 2009-05-21 02:37:58
la source

Un lambda fait partie d'un important mécanisme d'abstraction qui traite des fonctions d'ordre supérieur. Pour obtenir une bonne compréhension de sa valeur, s'il vous plaît regarder des leçons de haute qualité de Abelson et Sussman , et lire le livre SICP

ce sont des questions pertinentes dans les entreprises de logiciels modernes, et de plus en plus populaire.

72
répondu egaga 2009-05-21 00:49:01
la source

je doute que lambda s'en aille. Voir L'article de Guido à propos de finalement renoncer à essayer de l'enlever. Voir aussi un aperçu du conflit .

vous pouvez vérifier ce post pour plus d'une histoire sur l'affaire derrière les fonctionnalités de Python: http://python-history.blogspot.com/2009/04/origins-of-pythons-functional-features.html

curieusement, le carte, filtre, et de réduire les fonctions qui a initialement motivé l'introduction de lambda et d'autres caractéristiques fonctionnelles ont, dans une large mesure, été remplacées par des interprétations de la liste et le générateur d'expressions. En fait, la fonction reduce a été retirée de la liste des fonctions builtin dans Python 3.0. (Cependant, il n'est pas nécessaire d'envoyer des plaintes sur le retrait de lambda, carte ou filtre: ils restent. :- )

mes propres deux cents: lambda en vaut rarement la peine la mesure de la clarté va. En général, il y a une solution plus claire qui n'inclut pas lambda.

57
répondu rhettg 2014-07-31 03:44:51
la source

lambdas sont extrêmement utiles dans la programmation GUI. Par exemple, disons que vous créez un groupe de boutons et que vous voulez utiliser un seul callback paramétré plutôt qu'un seul callback par bouton. Lambda vous laisse accomplir cela avec facilité:

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

(Note: Bien que cette question concerne spécifiquement lambda , vous pouvez également utiliser les functools .partielle pour obtenir le même type de résultat)

le une alternative est de créer un callback séparé pour chaque bouton qui peut conduire à du code dupliqué.

56
répondu Bryan Oakley 2016-07-27 17:50:07
la source

en Python, lambda est juste une façon de définir les fonctions en ligne,

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

et..

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

..sont le exact même.

il n'y a rien que vous puissiez faire avec lambda que vous ne pouvez pas faire avec une fonction régulière-en 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'>

je pense honnêtement le mot-clé lambda est redondant en Python-je n'ai jamais eu le besoin de les utiliser (ou d'en voir un Utilisé où une fonction régulière, une compréhension de liste ou l'une des nombreuses fonctions intégrées auraient pu être mieux utilisées à la place)

Pour un complètement aléatoire exemple, à partir de l'article "Python lambda est cassé!" :

pour voir comment lambda est cassé, essayez de générer une liste de fonctions fs=[f0,...,f9]fi(n)=i+n . Première tentative:

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

je dirais, même si cela a fonctionné, il est horriblement et "unpythonic", la même fonctionnalité pourrait être écrite d'innombrables autres façons, 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 cause où la génération d'un groupe de fonctions lambda dans une liste a été nécessaire. Cela pourrait avoir du sens dans d'autres langues, mais Python n'est pas Haskell (ou Lisp, or ...)

s'il vous plaît noter que nous pouvons utiliser lambda et encore atteindre le résultats de cette façon:

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

Edit:

il y a quelques cas où lambda est utile, par exemple c'est souvent pratique lors de la connexion de signaux dans les applications PyQt, comme ceci:

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

faire w.textChanged.connect(dothing) pourrait appeler le dothing méthode avec un argument supplémentaire event et de causer une erreur. L'utilisation de la lambda signifie que nous pouvons facilement abandonner l'argument sans avoir à définir une fonction d'enrubannage.

31
répondu dbr 2018-04-02 16:13:20
la source

je trouve lambda utile pour une liste de fonctions qui font la même chose, mais pour des circonstances différentes. Comme le Mozilla au pluriel règles .

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, vous deviendriez fou à la fin. En outre, il ne serait pas agréable avec des noms de fonction comme plural_rule_1 , plural_rule_2 , etc. Et vous avez besoin de eval() quand vous dépendez d'un id de fonction variable.

28
répondu Tor Valamo 2018-06-21 05:59:16
la source

à peu près tout ce que vous pouvez faire avec lambda vous pouvez faire mieux avec les fonctions nommées ou les expressions list et generator.

par conséquent, pour la plupart, vous devriez juste un de ceux essentiellement dans n'importe quelle situation (sauf peut-être pour le code à gratter écrit dans l'interprète interactif).

26
répondu Aaron Maenpaa 2009-05-21 00:45:27
la source

j'utilise Python depuis quelques années et je n'ai jamais couru dans un cas où j'ai besoin de lambda. Vraiment, comme le dit le tutoriel , c'est juste pour le sucre syntaxique.

19
répondu Matt Schmidt 2009-05-21 00:47:48
la source

Je ne peux pas parler de l'implémentation particulière de lambda par python, mais en général les fonctions lambda sont vraiment pratiques. Ils sont une technique de base (peut-être même la technique) de la programmation fonctionnelle, et ils sont aussi très utiles dans les programmes orientés objet. Pour certains types de problèmes, ils sont la meilleure solution, donc certainement ne devrait pas être oublié!

je vous suggère de lire sur fermetures et la fonction de carte (qui renvoie à python docs, mais il existe dans presque tous les langages qui supportent les constructions fonctionnelles) pour voir pourquoi il est utile.

17
répondu rmeador 2009-05-21 00:45:12
la source

fonction Lambda c'est une façon non bureaucratique de créer une fonction.

C'est ça. Par exemple, supposons que vous ayez votre fonction principale et que vous ayez besoin de quadriller les valeurs. Voyons la façon traditionnelle et la façon lambda de le faire:

de façon Traditionnelle:

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

def square(x):
    return x**2

La lambda:

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

vous voyez la différence?

fonctions Lambda go très bien avec des listes, comme des compréhensions de listes ou des cartes. En fait, la compréhension de liste c'est une façon" pythonique " de s'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 : "l'utilisation de ce nouveau-né de la fonction"

pour x dans r: "dans chaque élément dans un"

c'est pratique euh? La création de fonctions de ce genre. Réécrivons-le en utilisant lambda:

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

maintenant, utilisons la carte, qui est la même chose, mais plus neutre sur le plan linguistique. Maps prend 2 arguments:

(i) une fonction

(ii) un objet 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 lambdas et la cartographie, vous aurez un grand pouvoir pour manipuler les données et d'une manière concise. Les fonctions Lambda ne sont ni obscures ni enlèvent la clarté du code. Ne confondez pas quelque chose de dur avec quelque chose de nouveau. Une fois que vous commencez à les utiliser, vous le trouverez très clair.

16
répondu Lucas Ribeiro 2015-09-01 22:31:56
la source

une des bonnes choses à propos de lambda qui est à mon avis sous-estimé est que c'est une façon de reporter une évaluation pour les formes simples jusqu'à ce que la valeur est nécessaire. Laissez-moi vous expliquer.

de nombreuses routines de bibliothèques sont implémentées de sorte qu'elles permettent à certains paramètres d'être des callables (dont lambda fait partie). L'idée est que la valeur réelle sera calculée uniquement au moment où il va être utilisé (plutôt que lorsqu'elle est appelée). Un exemple (artificiel) pourrait aider pour illustrer ce point. Supposons que vous ayez une routine qui allait faire enregistrer un horodatage donné. Vous voulez que la routine utilise l'heure actuelle moins 30 minutes. Vous appelleriez ça comme ça

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

supposons Maintenant que la fonction réelle va être appelée uniquement lorsqu'un certain événement se produit et que vous voulez le timestamp être calculées qu'à l'époque. Vous pouvez le faire comme ça

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

en supposant que le log_timestamp peut traiter des ceci, il va l'évaluer quand il en a besoin et vous obtiendrez l'horodatage à ce moment-là.

il y a bien sûr d'autres façons de le faire (en utilisant le module operator par exemple), mais j'espère que j'ai fait passer le message.

Update : Here est un exemple un peu plus concret du monde réel.

Update 2 : je pense que c'est un exemple de ce qu'on appelle un thunk .

13
répondu Noufal Ibrahim 2015-10-29 06:37:30
la source

comme indiqué ci-dessus, l'opérateur lambda en Python définit une fonction anonyme, et en Python les fonctions sont des fermetures. Il est important de ne pas confondre le concept de fermetures avec l'opérateur lambda, qui n'est pour eux que de la méthadone syntaxique.

quand j'ai commencé en Python il y a quelques années, j'ai beaucoup utilisé lambdas, pensant qu'ils étaient cool, avec des compréhensions de liste. Cependant, j'ai écrit et je dois maintenir un grand site web écrit en Python, avec sur l'ordre de plusieurs milliers de points de fonction. J'ai appris par expérience que lambdas pourrait être D'accord pour faire des prototypes, mais n'offre rien sur les fonctions en ligne (nommées fermetures) sauf pour sauvegarder quelques touches-stokes, ou parfois pas.

fondamentalement, cela se résume à plusieurs points:

  • il est plus facile de lire un logiciel qui est écrit explicitement en utilisant des noms significatifs. Les fermetures anonymes, par définition, ne peuvent pas avoir de nom significatif, car elles n'ont aucun nom. Cette brièveté semble, pour une raison quelconque, infecter également les paramètres lambda, d'où nous voyons souvent des exemples comme lambda x: x+1
  • il est plus facile de réutiliser les fermetures nommément désignées, car elles peuvent être désignées par leur nom plus d'une fois, lorsqu'il y a un nom pour les désigner.
  • il est plus facile de déboguer le code qui utilise les fermetures nommées au lieu de lambdas, parce que le nom apparaîtra dans tracebacks, et autour de l'erreur.

C'est assez de raison pour les rassembler et les convertir en fermetures nommées. Cependant, je tiens deux autres rancunes contre les fermetures anonymes.

la première rancune est tout simplement qu'ils sont juste un autre mot-clé inutile encombrant le langage.

la deuxième rancune est plus profonde et au niveau du paradigme, i.e. Je n'aime pas qu'Ils favorisent un style de programmation fonctionnelle, parce que ce style est moins flexible que le passage de message, orienté objet ou les styles de procédure, parce que le calcul lambda n'est pas Turing-complète (heureusement en Python, nous pouvons encore sortir de cette restriction même à l'intérieur d'un lambda). Les raisons pour lesquelles je pense que lambdas promouvoir ce style sont:

  • il y a un retour implicite, c'est-à-dire qu'ils semblent comme ils "devraient" être des fonctions.

  • il s'agit d'un mécanisme alternatif de dissimulation d'État à un autre, plus explicite, plus lisible, plus réutilisable et plus de mécanisme général: méthodes.

j'essaie d'écrire un Python sans lambda, et j'enlève lambdas à vue. Je pense que Python serait un peu mieux sans lambdas, mais c'est juste mon opinion.

11
répondu Mike A 2010-10-18 22:01:05
la source

Lambdas sont en fait des constructions très puissantes qui proviennent d'idées dans la programmation fonctionnelle, et c'est quelque chose qui ne sera en aucun cas facilement révisé, redéfini ou supprimé dans le futur proche de Python. Ils vous aident à écrire du code qui est plus puissant car il vous permet de passer des fonctions en tant que paramètres, donc l'idée de fonctions en tant que citoyens de première classe.

Lambdas ont tendance à devenir confus, mais une fois qu'une compréhension solide est obtenue, vous pouvez écrire propre code élégant comme ceci:

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

la ligne de code ci-dessus retourne une liste des carrés des nombres dans la liste. Bien sûr, vous pouvez 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 c'est particulièrement vrai si vous avez l'intention d'utiliser la fonction map (ou toute autre fonction similaire qui prend une fonction comme paramètre) en un seul endroit. Cela rend également le code plus intuitif et élégant.

En outre, comme @David Zaslavsky mentionné dans sa réponse, les compréhensions de liste ne sont pas toujours la voie à suivre, surtout si votre liste doit obtenir des valeurs d'une manière mathématique obscure.

d'un point de vue plus pratique, l'un des plus grands avantages de lambdas pour moi récemment a été dans L'interface graphique et la programmation axée sur l'événement. Si vous regardez les callbacks dans Tkinter, tout ce qu'ils prennent comme argument est 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 que faire si vous aviez des arguments à passer? Quelque chose d'aussi simple que 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

Maintenant, vous pouvez faire valoir que cela peut être fait en utilisant des variables globales, mais voulez-vous vraiment frapper votre tête en s'inquiétant de la gestion de la mémoire et des fuites, surtout si la variable globale sera juste utilisée dans un endroit particulier? Ce serait un mauvais style de programmation.

Bref, les lambdas sont géniaux et ne devraient jamais être sous-estimés. Python lambdas ne sont pas les mêmes que LISP lambdas (qui sont plus puissants), mais vous pouvez vraiment faire beaucoup de choses magiques avec eux.

11
répondu varagrawal 2013-05-24 17:02:56
la source

Lambdas sont profondément liés au style de programmation fonctionnelle en général. L'idée que vous pouvez résoudre les problèmes en appliquant une fonction à certaines données, et la fusion des résultats, Est ce que google utilise pour mettre en œuvre la plupart de ses algorithmes.

Les programmes

écrits dans un style de programmation fonctionnel, sont facilement parallélisés et deviennent donc de plus en plus importants avec les machines multi-core modernes. Donc, en résumé, non, vous ne devriez pas les oublier.

8
répondu Yogi 2018-02-09 22:49:58
la source

premières félicitations qui ont réussi à comprendre lambda. À mon avis, c'est vraiment puissante construction d'agir. La tendance actuelle vers des langages de programmation fonctionnels est certainement un indicateur qu'il ne faut ni l'éviter ni la redéfinir dans un avenir proche.

il suffit de penser un peu différemment. Je suis sûr que bientôt vous allez l'adorer. Mais faites attention si vous ne vous occupez que de python. Parce que la lambda n'est pas une vraie fermeture, il est " cassé" en quelque sorte: pythons lambda est cassé

6
répondu Norbert Hartl 2013-04-02 15:01:00
la source

je commence juste Python et j'ai couru tête première dans Lambda - ce qui m'a pris un certain temps pour 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 l'un de ces éléments linguistiques "intéressants" qui, dans la vie réelle, devraient être oubliés?

Pas de.

je suis sûr qu'il y a quelques cas de bord où il pourrait être nécessaire, mais étant donné l'obscurité de celui-ci,

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 d'être redéfini dans les futures versions (mon hypothèse fondée sur les différentes définitions de

Je n'ai vu aucune proposition sérieuse pour le redéfinir en Python, au-delà réparer la sémantique de la fermeture il y a quelques années.

et la clarté de codage réduite - devrait-elle être évitée?

ce n'est pas moins clair, si vous l'utilisez correctement. Au contraire, avoir plus de constructions linguistiques disponibles augmente" la clarté 1519300920".

cela me rappelle le débordement (débordement de tampon) des types C-pointant vers la variable supérieure et la surcharge à régler les autres valeurs de champ...une sorte de technique de mise en scène mais un cauchemar de codeur d'entretien..

Lambda est comme un débordement de tampon? Wow. Je ne peux pas imaginer comment vous utilisez lambda si vous pensez que c'est un "entretien cauchemar".

5
répondu Ken 2009-05-21 00:57:23
la source

j'ai commencé à lire le livre de David Mertz today's Text Processing in Python."Bien qu'il ait 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 je suis encore à l'étape de la découverte donc je ne vais pas essayer d'ajouter à ces réponses autre que la suivante: Je suis nouveau en Python Je suis nouveau à la programmation orientée objet Lambdas a été une lutte pour moi Maintenant que J'ai lu Mertz, je pense que je les comprends et je les vois aussi utiles que je pense qu'ils permettent une approche plus propre de la programmation.

il reproduit le Zen de Python, dont une ligne est Simple est mieux que complexe. comme un code de lecture non-OOP programmeur avec lambdas (et jusqu'à la semaine dernière liste d'interprétations) j'ai pensé - C'est simple? . J'ai finalement réalisé aujourd'hui que en fait, ces caractéristiques rendent le code beaucoup plus lisible et compréhensible que l'alternative-qui est invariablement une sorte de boucle. J'ai aussi réalisé que, comme les états financiers-Python n'a pas été conçu pour l'utilisateur novice, c'est plutôt conçu pour l'utilisateur qui veut s'informer. Je n'arrive pas à croire à quel point ce langage est puissant. Quand je me suis rendu compte (enfin) du but et de la valeur de lambdas, j'ai voulu découper environ 30 programmes et recommencer à mettre en lambdas là où c'était approprié.

5
répondu PyNEwbie 2009-05-21 05:08:31
la source

un cas utile pour l'utilisation de lambdas est de améliorer la lisibilité de la longue liste des compréhensions . Dans cet exemple, loop_dic est court pour la clarté mais imaginez que loop_dic soit très long. Si vous utilisez une valeur simple qui inclut i au lieu 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'}]
5
répondu Bentley4 2012-11-03 16:35:20
la source

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 remplacez la par une 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)
5
répondu balki 2013-10-09 04:29:45
la source

je suis un débutant de python, donc pour obtenir une idée claire de lambda Je l'ai comparé avec 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)
5
répondu user3252158 2014-02-07 20:26:31
la source

je peux vous donner un exemple où j'avais besoin de lambda serious. Je fais un programme graphique, où l'utilisation juste clique sur un fichier et lui assigne une des trois options. Il s'avère que dans Tkinter (le programme d'interface graphique dans lequel j'écris ceci), quand quelqu'un appuie sur un bouton, il ne peut pas être assigné à une commande qui prend en arguments. Donc, si j'ai choisi l'une des options et je voulais le résultat de mon choix:

print 'hi there'

alors rien de grave. Mais et si j'avais besoin d'un détail particulier? Par exemple, si je choisis le choix A, il appelle une fonction qui prend dans un argument qui dépend du choix A, B ou C, TKinter ne pourrait pas supporter cela. Lamda était la seule option pour contourner ça...

5
répondu Glueberg 2018-05-16 16:42:56
la source

Je l'utilise assez souvent, principalement comme un objet nul ou pour lier partiellement des paramètres à une fonction.

Voici des exemples:

pour mettre en œuvre l'objet null motif:

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

pour la fixation des 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)
    #...

alors, quand je ne veux pas jeter rapidement les données reçues à un fichier je fais cela:

dump_file = file('hex_dump.txt','w')
X.callback = lambda (x): dump_hex(dump_file, x)
...
dump_file.close()
4
répondu Piotr Czapla 2009-05-21 01:20:18
la source

j'utilise lambda pour créer des callbacks qui incluent des paramètres. C'est plus propre de l'écriture d'un lambda dans une ligne que d'écrire une méthode pour effectuer 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
4
répondu NuclearPeon 2014-01-03 22:31:54
la source

Lambda est un constructeur de procédures. Vous pouvez synthétiser des programmes à l'exécution, bien que lambda de Python ne soit pas très puissant. Remarque que peu de gens comprennent ce genre de programmation.

2
répondu Nick Dandoulakis 2009-05-21 00:52:40
la source

Autres questions sur python lambda function closures