Pourquoi Python lambdas utile?

Tu parles lambda fonctions? Comme

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

Ces choses sont en fait très utile. Python supporte un style de programmation appelé de la programmation fonctionnelle où vous pouvez passer des fonctions à d'autres fonctions à faire des trucs. Exemple:

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

jeux de mult3 à [3, 6, 9], les éléments de la liste d'origine qui sont des multiples de 3. C'est plus courte (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, on pourrait 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 y a beaucoup d'autres, plus sophistiquées cas où vous ne pouvez pas utiliser une liste de compréhension et d'une fonction lambda peut être le chemin le plus court à écrire quelque chose.

• Retour d'une fonction à partir d'une autre fonction

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

  Il est souvent utilisé pour créer la fonction wrappers, tels que le Python, les décorateurs.

• Combinant des éléments d'un objet iterable séquence 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'

• De 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]

- Je utiliser les lambda fonctions sur une base régulière. Il m'a fallu un certain temps pour s'y habituer, mais finalement j'en suis venu à comprendre qu'ils sont une précieuse partie de la langue.

Les deux résumé en ligne:

1. Fermetures: Très utile. Apprenez-les, utilisez-les, aimez-les.
2. Python lambda mot-clé: inutile, de temps en temps utiles. Si vous vous retrouver à faire quelque chose à distance complexes avec elle, de la mettre à l'écart et de définir une fonction réelle.

Je doute lambda ira loin.
Voir Guido post parle finalement d'abandonner la tentative de l'enlever. Voir aussi un aperçu du conflit.

Vous pouvez consulter ce post pour plus d'une histoire au sujet de l'affaire derrière Python caractéristiques fonctionnelles:
http://python-history.blogspot.com/2009/04/origins-of-pythons-functional-features.html

Curieusement, la carte, le 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 de réduction a été retiré de la liste de fonctions internes en Python 3.0. (Toutefois, il n'est pas nécessaire d'envoyer des plaintes au sujet de la suppression de la lambda, de carte ou de filtre: ils sont logés. 🙂

Mes deux cents: il est Rarement lambda vaut autant que la clarté va. Généralement, il y a une solution qui ne comprend pas le lambda.

En Python, lambda est juste une façon de définir des fonctions inline,

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

et..

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

..sont les exacte même.

Il n'y a rien que vous pouvez faire avec lambda qui vous ne pouvez pas faire avec une fonction régulière Python fonctions sont un objet tout comme toute autre chose, et les lambdas il vous suffit de définir une fonction:

>>> a = lambda x: x + 1
>>> type(a)
<type 'function'>

Honnêtement, je pense que le lambda mot-clé est redondante en Python—je n'ai jamais eu le besoin de les utiliser (ou vu utilisé lorsqu'une fonction régulière, une liste-de la compréhension ou de l'une des nombreuses fonctions internes qui aurait pu être mieux utilisé à la place)

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

Pour voir comment lambda est en panne, essayez de générer une liste de fonctions fs=[f0,...,f9] où 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 fait un travail, c'est horriblement et "unpythonic", la même fonctionnalité peut être écrit 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, mais j'ai jamais vu une cause où la génération d'un groupe de lambda fonctions dans une liste a été nécessaire. Il peut être judicieux dans d'autres langues, mais Python n'est pas Haskell (ou Lisp, ou ...)

Veuillez noter que nous pouvons utiliser lambda et encore atteindre l'objectif souhaité
les 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, il est souvent pratique lors de la connexion des signaux en PyQt applications, comme ceci:

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

Juste faire w.textChanged.connect(dothing) pourrait appeler la dothing méthode avec un supplément de event argument et de provoquer une erreur. En utilisant le lambda moyen, on peut bien placé, baisse de l'argument sans avoir à définir un emballage de fonction.

À peu près tout ce que vous pouvez faire avec lambda vous pouvez faire mieux avec soit nommé à des fonctions ou de la liste et le générateur d'expressions.

Par conséquent, pour la plupart, vous devriez juste un de ces dans pratiquement n'importe quelle situation (sauf peut-être pour gratter le code écrit dans interactive interprète).

Je ne peux pas parler de python particulier la mise en œuvre de la lambda, mais en général, les lambda fonctions sont vraiment à portée de main. Ils sont une base technique (peut-être même de LA technique) de la programmation fonctionnelle, et ils sont également très useuful dans des 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 map (que des liens vers python docs, mais il existe dans presque toutes les langues qui prend en charge constructions fonctionnelles) pour voir pourquoi c'est utile.

Une des belles choses au sujet de lambda c'est à mon avis sous-estimées, c'est que c'est la façon de reporter à une évaluation pour des formes simples, jusqu'à la valeur nécessaire. Laissez-moi vous expliquer.

De nombreuses routines de la bibliothèque sont mis en œuvre de manière à permettre à certains paramètres callables (dont lambda est un). 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 (fictive) exemple peut aider à illustrer ce point. Supposons que vous avez une routine qui allait faire du journal un timestamp. Vous voulez la routine d'utiliser l'heure actuelle moins de 30 minutes. Vous souhaitez appeler comme

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 faire cela comme

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

En supposant que le log_timestamp peut gérer callables comme ça, il va évaluer ce quand il en a besoin et vous obtiendrez le timestamp de l'époque.

Il y a bien sûr d'autres façons de le faire (à l'aide de la operator module par exemple), mais j'espère que je vous ai transmis le point.

Mise à jour: Ici est un peu plus concrète l'exemple du monde réel.

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

Lambdas sont effectivement très puissant des constructions que les souches à partir d'idées dans la programmation fonctionnelle, et c'est quelque chose qui, par aucun moyen sera facilement révisé, redéfini ou retiré dans un avenir proche de Python. Ils vous aider à écrire du code qui est plus puissant car il permet de passer des fonctions en tant que paramètres, ainsi, l'idée de fonctions comme des citoyens de première classe.

Lambdas ne ont tendance à obtenir déroutant, mais une fois une solide connaissance est obtenue, vous pouvez écrire nettoyer élégant de code comme ceci:

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

Au-dessus de la ligne de code renvoie une liste des carrés des nombres dans la liste. Bien sûr, vous pouvez aussi faire il aime:

def square(x):
    return x*x

squared = map(square, [1, 2, 3, 4, 5])

Il est évident que le code est plus court, et cela est particulièrement vrai si vous avez l'intention d'utiliser la fonction map (ou de toute autre fonction qui prend une fonction en tant que paramètre) dans un seul endroit. Également, cela rend le code plus intuitive et élégante.

Aussi, comme @David Zaslavsky mentionné dans sa réponse, interprétations de la liste ne sont pas toujours la voie à suivre, surtout si votre liste a pour obtenir les valeurs de quelque obscure manière mathématique.

D'un point de vue pratique, l'un des plus grands avantages de lambdas pour moi a été récemment dans l'interface graphique et la programmation événementielle. Si vous jetez un oeil à des rappels dans Tkinter, tous ils prennent comme arguments sont l'événement qui a déclenché eux. E. g.

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 à 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

Maintenant, vous pouvez faire valoir que cela peut être fait en utilisant des variables globales, mais voulez-vous vraiment bang votre tête vous soucier de la gestion de la mémoire et de la fuite en particulier si la variable globale sera utilisé uniquement dans un endroit particulier? Ça serait juste mauvais style de programmation.

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

D'abord félicitations que réussi à comprendre lambda. À mon avis, c'est vraiment puissante construction d'agir avec. La tendance ces jours-ci vers les langages de programmation fonctionnelle est certainement un indicateur qu'il ne doit pas non plus être évité, ni qu'il sera redéfini dans un avenir proche.

Vous suffit de réfléchir un peu différent. Je suis sûr que bientôt vous allez l'adorer. Mais attention, si vous ne traitez qu'avec python. Parce que le lambda n'est pas un véritable fermeture, il est "cassé" en quelque sorte: pythons lambda est cassé

Je suis juste débutant en Python et a couru la tête la première dans la Lambda - ce qui m'a pris un certain temps à comprendre.

Noter 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 un de ces "intéressants" en langue que dans la vie réelle doit être oublié?

Pas.

Je suis sûr qu'il y a certains cas où il peut être nécessaire, mais compte tenu de l'obscurité de cela,

Il n'est pas obscur. Les 2 dernières équipes qui j'ai travaillé, tout le monde à utiliser cette fonctionnalité tout le temps.

le potentiel d'être redéfini dans les futures versions (mon hypothèse fondée sur les diverses définitions de celle-ci)

Je n'ai pas vu de propositions sérieuses de la redéfinir en Python, au-delà de la fixation de la fermeture de la sémantique il y a quelques années.

et la réduction de la codification de la clarté - devrait-il être évité?

Il n'est pas moins clair, si vous avez droit. Au contraire, avoir plus de constructions de langage disponible augmente clarté.

Cela me rappelle de 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...en quelque sorte la pointe de la technique de mise en scène, mais l'entretien codeur cauchemar..

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

Un cas utile pour l'utilisation de lambda est à améliorer la lisibilité de la longue liste des compréhensions.
Dans cet exemple loop_dic est court pour plus de clarté, mais imaginez loop_dic être très long. Si vous utilisez un simple valeur qui inclut i au lieu de le lambda version de cette valeur, vous obtiendrez une 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'ai réellement besoin lambda grave. Je suis en train de faire un programme graphique, où l'utilisation clique droit sur un fichier et l'attribue à l'une des trois options. Il s'avère que dans Tkinter (l'interface graphique de l'interfaçage programme que j'ai écris ceci dans), lorsque quelqu'un appuie sur un bouton, il ne peut pas être attribué à 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'

Puis pas une grosse affaire. Mais que faire si j'ai besoin de mon choix d'avoir un détail particulier. Par exemple, si je choisis Un choix, il appelle une fonction qui prend un argument qui est dépendant du choix A, B ou C, TKinter, pourrait ne pas appuyer cette démarche. Lamda était la seule option pour obtenir autour de cette réalité...

- Je utiliser lambda pour créer des rappels qui comprennent 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