Pourquoi les lambdas Python sont-ils utiles? [fermé]

J'essaie de comprendre les lambdas Python. Lambda fait-il partie de ces éléments de langage "intéressants" qui, dans la vraie vie, devraient être oubliés?

Je suis sûr qu'il y a des cas marginaux où cela pourrait être nécessaire, mais étant donné son obscurité, son potentiel d'être 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 - si cela devait être évité?

Cela me rappelle le débordement (débordement de tampon) des types C - pointant vers la variable supérieure et surchargeant pour définir les autres valeurs de champ. Cela ressemble à une sorte de mise en scène technique, mais au cauchemar du codeur de maintenance.

Parlez-vous des fonctions lambda ? Comme

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

Ces choses sont en fait très utiles. Python prend en charge 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])

définit mult3à [3, 6, 9], les éléments de la liste d'origine qui sont des multiples de 3. Ceci est plus court (et, pourrait-on dire, 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 pouvez 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 où vous ne pouvez pas utiliser une compréhension de liste et une fonction lambda peut être le moyen le plus court d'écrire quelque chose.

• Retourner 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 wrappers de fonction, 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 clé alternative

  >>> 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 des fonctions lambda. Il m'a fallu un certain temps pour m'y habituer, mais j'ai fini par comprendre qu'ils sont une partie très précieuse de la langue.

lambdaest juste une façon élégante de dire function. À part son nom, il n'a rien d'obscur, d'intimidant ou de cryptique. Lorsque vous lisez la ligne suivante, remplacez lambdapar functiondans votre esprit:

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

Il définit simplement une fonction de x. Certaines autres langues, comme R, le disent explicitement:

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

Tu vois? C'est l'une des choses les plus naturelles à faire en programmation.

Le résumé en deux lignes:

1. Fermetures : très utile. Apprenez-les, utilisez-les, aimez-les.
2. lambdaMot - clé de Python : inutile, parfois utile. Si vous vous retrouvez à faire quelque chose de complexe à distance avec lui, 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, veuillez regarder les leçons de haute qualité d' Abelson et Sussman et lire le livre SICP

Ce sont des questions pertinentes dans le secteur des logiciels modernes et qui deviennent de plus en plus populaires.

les lambdas sont extrêmement utiles dans la programmation graphique. Par exemple, supposons que vous créez un groupe de boutons et que vous souhaitez utiliser un rappel unique 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 porte spécifiquement sur lambda, vous pouvez également utiliser functools.partial pour obtenir le même type de résultat)

L'alternative consiste à créer un rappel distinct pour chaque bouton, ce qui peut entraîner un code dupliqué.

Je doute que lambda s'en ira. Voir le post de Guido sur l'abandon final de la tentative de suppression. Voir également un aperçu du conflit .

Vous pouvez consulter ce post pour plus d'historique sur l'accord derrière les fonctionnalités de Python: http://python-history.blogspot.com/2009/04/origins-of-pythons-functional-features.html

Curieusement, les fonctions de mappage, de filtrage et de réduction qui ont initialement motivé l'introduction de lambda et d'autres fonctionnalités ont été largement remplacées par des listes de compréhension et des expressions de générateur. 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, de la carte ou du filtre: ils restent. :-)

Mes propres deux cents: Rarement lambda en vaut la peine en ce qui concerne la clarté. Il existe généralement une solution plus claire qui n'inclut pas lambda.

En Python, lambdaest juste 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 exactement les mêmes.

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 que le lambdamot-clé est redondant en Python - je n'ai jamais eu besoin de les utiliser (ou vu une utilisée là où une fonction régulière, une compréhension de liste ou l'une des nombreuses fonctions intégrées aurait pu être mieux utilisée à la place)

Pour un exemple complètement aléatoire, extrait 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 a fonctionné, c'est horriblement et "impythonique", la même fonctionnalité pourrait être écrite de nombreuses 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 je n'ai jamais vu de cause où la génération d'un groupe de fonctions lambda dans une liste a été requise. Cela pourrait avoir du sens dans d'autres langages, mais Python n'est pas Haskell (ou Lisp, ou ...)

Veuillez noter que nous pouvons utiliser lambda tout en obtenant 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

Éditer:

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

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

Le simple fait d' w.textChanged.connect(dothing)appeler la dothingméthode avec un eventargument supplémentaire et de provoquer une erreur. L'utilisation du lambda signifie que nous pouvons supprimer proprement l'argument sans avoir à définir une fonction de wrapping.

Je trouve lambda utile pour une liste de fonctions qui font de même, mais pour des circonstances différentes.

Comme les 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 que vous deviendriez fous à la fin de celui-ci.
En outre, il ne serait pas bien avec les noms de fonctions comme plural_rule_1, plural_rule_2, etc. Et vous devez eval()quand vous êtes en fonction d'un identifiant de fonction variable.

À peu près tout ce que vous pouvez faire avec lambdavous pouvez faire mieux avec les fonctions nommées ou les expressions de liste et de générateur.

Par conséquent, pour la plupart, vous ne devriez en utiliser qu'une dans pratiquement toutes les situations (sauf peut-être pour le code de travail écrit dans l'interpréteur interactif).

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

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 également très utiles dans les programmes orientés objet. Pour certains types de problèmes, ils sont la meilleure solution, il ne faut donc pas les oublier!

Je vous suggère de lire les fermetures et la fonction de carte (qui relie aux documents python, mais elle existe dans presque tous les langages qui prennent en charge les constructions fonctionnelles) pour voir pourquoi elle est utile.

La fonction lambda est un moyen 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 mettre les valeurs au carré. Voyons la manière traditionnelle et la manière lambda de le faire:

Manière traditionnelle:

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

def square(x):
    return x**2

La façon 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 les compréhensions de listes ou les cartes. En fait, la compréhension des listes 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 signifie chaque élément de la syntaxe:

[]: "Donnez-moi une liste"

x ** 2: "en utilisant cette fonction nouveau-né"

pour x dans un: "dans chaque élément d'un"

C'est pratique euh? 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]

Maintenant, utilisons map, qui est la même chose, mais plus neutre en termes de langue. Maps prend 2 arguments:

(i) une fonction

(ii) un itérable

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 et de manière concise. Les fonctions lambda ne sont ni obscures ni nettes de 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.

À lambdamon avis, une des bonnes choses sous-estimées est que c'est une façon de reporter une évaluation pour des formulaires simples jusqu'à ce que la valeur soit nécessaire. Laisse-moi expliquer.

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

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

Supposons maintenant que la fonction réelle ne sera appelée que lorsqu'un certain événement 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_timestamppeut gérer les callables comme celui-ci, il évaluera cela quand il en aura 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 operatormodule par exemple) mais j'espère avoir bien fait comprendre ce point.

Mise à jour : Voici un exemple un peu plus concret du monde réel.

Mise à jour 2 : Je pense que c'est un exemple de ce qu'on appelle un thunk .

Comme indiqué ci-dessus, l'opérateur lambda en Python définit une fonction anonyme, et dans les fonctions Python sont des fermetures. Il est important de ne pas confondre le concept de fermeture 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'utilisais beaucoup les lambdas, pensant qu'ils étaient cool, ainsi que des listes de compréhension. Cependant, j'ai écrit et dois maintenir un gros site web écrit en Python, avec de l'ordre de plusieurs milliers de points de fonction. J'ai appris par expérience que les lambdas pourraient être corrects pour prototyper des choses, mais n'offrent rien sur les fonctions en ligne (fermetures nommées), sauf pour enregistrer quelques touches, ou parfois non.

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, d'où nous voyons souvent des exemples comme lambda x: x + 1
• il est plus facile de réutiliser les fermetures nommées, car elles peuvent être référencées plusieurs fois par leur nom, lorsqu'il existe un nom pour s'y référer.
• il est plus facile de déboguer du code qui utilise des fermetures nommées au lieu de lambdas, car le nom apparaîtra dans les traces et autour de l'erreur.

C'est une raison suffisante pour les rassembler et les convertir en fermetures nommées. Cependant, je garde deux autres rancunes contre les fermetures anonymes.

La première rancune est simplement qu'ils ne sont qu'un autre mot clé inutile encombrant la langue.

La deuxième 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 le style de passage de message, orienté objet ou procédural, parce que le calcul lambda n'est pas Turing- complet (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 les lambdas font la promotion de ce style sont:

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

• Ils sont un mécanisme alternatif de masquage d'état à un autre mécanisme, plus explicite, plus lisible, plus réutilisable et plus général: les méthodes.

Je m'efforce d'écrire du Python sans lambda et de supprimer les lambdas à vue. Je pense que Python serait un langage légèrement meilleur sans lambdas, mais c'est juste mon opinion.

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

Les lambdas ont tendance à être déroutants, mais une fois qu'une bonne compréhension est obtenue, vous pouvez écrire du code propre et élégant comme ceci:

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 dans la liste. Bien sûr, vous pouvez également 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 de carte (ou toute 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 l'a mentionné dans sa réponse, la compréhension des listes n'est 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 des lambdas pour moi récemment a été la GUI et la programmation événementielle. Si vous regardez les rappels dans Tkinter, tout ce qu'ils prennent comme arguments 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

Et si vous aviez des arguments à passer? 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 affirmer que cela peut être fait à l'aide de variables globales, mais voulez-vous vraiment vous cogner la tête en vous inquiétant de la gestion de la mémoire et des fuites, surtout si la variable globale ne sera utilisée qu'à un endroit particulier? Ce serait juste un mauvais style de programmation.

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

Les lambdas sont profondément liés au style de programmation fonctionnel en général. L'idée que vous pouvez résoudre des problèmes en appliquant une fonction à certaines données et en fusionnant les résultats, est ce que Google utilise pour implémenter 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 multicœurs modernes. Donc en bref, NON, vous ne devez pas les oublier.

Premiers félicitations qui ont réussi à comprendre lambda. À mon avis, c'est une construction vraiment puissante pour agir avec. La tendance actuelle vers les langages de programmation fonctionnels est certainement un indicateur qu'il ne faut ni l'éviter ni le redéfinir dans un avenir proche.

Il suffit de penser un peu différemment. Je suis sûr que vous allez bientôt l'adorer. Mais soyez prudent si vous ne traitez qu'avec python. Parce que le lambda n'est pas une vraie fermeture, il est "cassé" en quelque sorte: les pythons lambda sont cassés

Je viens de commencer Python et j'ai couru la tête la 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 un de ces éléments de langage «intéressants» qui, dans la vraie vie, devraient être oubliés?

Non.

Je suis sûr qu'il y a des cas marginaux où cela pourrait être nécessaire, mais étant donné 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 celui-ci étant redéfini dans les versions futures (mon hypothèse basée sur les différentes définitions de celui-ci)

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

et la clarté de codage réduite - faut-il l'éviter?

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

Cela me rappelle le débordement (débordement de tampon) des types C - pointant vers la variable supérieure et surchargeant pour définir les autres valeurs de champ ...

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'utilise des 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 lambda temp

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)

J'ai commencé à lire le livre de David Mertz aujourd'hui «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 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 au stade de la découverte, donc je n'essaierai pas d'ajouter à ces réponses autres que les suivantes: je suis nouveau sur Python je suis nouveau sur OOP Lambdas était une lutte pour moi Maintenant que j'ai lu Mertz, je pense que je les ai et je les vois aussi très utiles que je pense qu'ils permettent une approche plus propre de la programmation.

Il reproduit le Zen of Python, dont une ligne est simple, c'est mieux que complexe. En tant que programmeur non-OOP lisant du code avec lambdas (et jusqu'à la semaine dernière, liste des compréhensions), j'ai pensé: c'est simple? . J'ai finalement réalisé aujourd'hui que ces fonctionnalités rendent le code beaucoup plus lisible et compréhensible que l'alternative, qui est invariablement une boucle. J'ai également réalisé que, comme les états financiers, Python n'était pas conçu pour l'utilisateur novice, mais plutôt pour l'utilisateur qui veut s'instruire. Je ne peux pas croire à quel point ce langage est puissant. Quand j'ai compris (enfin) le but et la valeur des lambdas, j'ai voulu déchirer environ 30 programmes et recommencer à mettre des lambdas le cas échéant.

Un cas utile pour l'utilisation de lambdas est d' améliorer la lisibilité des compréhensions de longue liste . Dans cet exemple, loop_dicc'est court pour la clarté, mais imaginez loop_dicêtre très long. Si vous utilisiez simplement une valeur simple qui inclut iau 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'}]

Je peux vous donner un exemple où j'avais réellement besoin de lambda sérieux. Je fais un programme graphique, où l'utilisation clique avec le bouton droit sur un fichier et lui attribue l'une des trois options. Il s'avère que dans Tkinter (le programme d'interface GUI dans lequel j'écris ceci), lorsque quelqu'un appuie sur un bouton, il ne peut pas être affecté à une commande qui accepte 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 ce n'est pas grave. 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 qui accepte un argument qui dépend du choix A, B ou C, TKinter ne pourrait pas le prendre en charge. Lamda était la seule option pour contourner cela en fait ...

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

Voici quelques exemples:

pour implémenter un modèle 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()

j'utilise lambda pour créer des rappels qui incluent des paramètres. Il est plus simple d'écrire un lambda sur une seule 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

Je suis un débutant en python, donc pour avoir une idée claire de lambda, je l'ai comparé avec une boucle 'for'; 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)

Lambda est un constructeur de procédures. 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 type de programmation.