Python Language Fonctions Lambda (Inline / Anonymous)


Exemple

Le mot clé lambda crée une fonction en ligne contenant une seule expression. La valeur de cette expression correspond à ce que la fonction renvoie lorsqu'elle est appelée.

Considérez la fonction:

def greeting():
    return "Hello"

qui, lorsqu'il est appelé comme:

print(greeting())

estampes:

Hello

Cela peut être écrit comme une fonction lambda comme suit:

greet_me = lambda: "Hello"

Voir la note au bas de cette section concernant l’affectation des lambdas aux variables. Généralement, ne le faites pas.

Cela crée une fonction en ligne avec le nom greet_me qui renvoie Hello . Notez que vous n'écrivez pas de return lors de la création d'une fonction avec lambda. La valeur après : est automatiquement renvoyée.

Une fois assigné à une variable, il peut être utilisé comme une fonction normale:

print(greet_me())

estampes:

Hello

lambda s peut aussi prendre des arguments:

strip_and_upper_case = lambda s: s.strip().upper()

strip_and_upper_case("  Hello   ")

renvoie la chaîne:

HELLO

Ils peuvent aussi prendre un nombre arbitraire d'arguments / arguments, comme les fonctions normales.

greeting = lambda x, *args, **kwargs: print(x, args, kwargs)
greeting('hello', 'world', world='world')

estampes:

hello ('world',) {'world': 'world'}

lambda s sont couramment utilisés pour les fonctions courtes qui sont pratiques à définir au point où elles sont appelées (généralement avec sorted , filter et map ).

Par exemple, cette ligne trie une liste de chaînes en ignorant leur cas et en ignorant les espaces au début et à la fin:

sorted( [" foo ", "    bAR", "BaZ    "], key=lambda s: s.strip().upper())
# Out:
# ['    bAR', 'BaZ    ', ' foo ']

Liste de tri en ignorant les espaces blancs:

sorted( [" foo ", "    bAR", "BaZ    "], key=lambda s: s.strip())
# Out:
# ['BaZ    ', '    bAR', ' foo ']

Exemples avec map :

sorted( map( lambda s: s.strip().upper(), [" foo ", "    bAR", "BaZ    "]))
# Out:
# ['BAR', 'BAZ', 'FOO']

sorted( map( lambda s: s.strip(), [" foo ", "    bAR", "BaZ    "]))
# Out:
# ['BaZ', 'bAR', 'foo']

Exemples avec des listes numériques:

my_list = [3, -4, -2, 5, 1, 7]
sorted( my_list, key=lambda x: abs(x))
# Out:
# [1, -2, 3, -4, 5, 7]

list( filter( lambda x: x>0, my_list))
# Out:
# [3, 5, 1, 7]

list( map( lambda x: abs(x), my_list))
# Out:
[3, 4, 2, 5, 1, 7]

On peut appeler d'autres fonctions (avec / sans arguments) depuis une fonction lambda.

def foo(msg):
    print(msg)

greet = lambda x = "hello world": foo(x)
greet()

estampes:

hello world

Ceci est utile car lambda peut contenir une seule expression et en utilisant une fonction subsidiaire, on peut exécuter plusieurs instructions.


REMARQUE

Gardez à l'esprit que PEP-8 (le guide de style officiel Python) ne recommande pas d'attribuer les lambdas aux variables (comme nous l'avons fait dans les deux premiers exemples):

Utilisez toujours une instruction def au lieu d'une instruction d'affectation qui lie directement une expression lambda à un identificateur.

Oui:

def f(x): return 2*x

Non:

f = lambda x: 2*x

La première forme signifie que le nom de l’objet fonction résultant est spécifiquement f au lieu du nom générique <lambda> . Ceci est plus utile pour les traces et les représentations de chaînes en général. L'utilisation de l'instruction d'affectation élimine le seul avantage qu'une expression lambda peut offrir sur une instruction def explicite (c'est-à-dire qu'elle peut être incorporée dans une expression plus grande).