Vous devez trier les produits par prix. Écrire une fonction nommée distincte juste pour dire « utiliser le prix » ressemble à beaucoup de cérémonie. Les fonctions Python lambda vous permettent de définir ce petit élément de logique en ligne, exactement là où vous l’utilisez.

Les lambdas sont pratiques, mais ils sont également faciles à abuser. Ce guide montre où ils aident vraiment et où ils rendent le code plus difficile à lire. Nous avons exécuté chaque exemple sur Python 3.13 et le résultat affiché provient de cette exécution.

Qu’est-ce qu’un lambda ?

Un lambda est une fonction sans nom, écrite avec le mot clé lambda :

lambda arguments: expression

Il prend n’importe quel nombre d’arguments et renvoie automatiquement la valeur d’une seule expression. Il n’y a pas de mot-clé return ni de corps d’instructions.

square = lambda x: x * x
print(square(4))                     # 16

print((lambda a, b=10: a + b)(5))    # 15

La deuxième ligne définit un lambda avec un argument par défaut et l’appelle immédiatement. Vous écririez rarement cela dans du code réel, mais cela montre qu’un lambda est un objet fonction ordinaire.

lambda contre déf

Ces deux produits produisent des fonctions qui se comportent de la même manière :

square = lambda x: x * x

def square_def(x):
    return x * x

print(square(4), square_def(4))                 # 16 16
print(square.__name__, square_def.__name__)     # <lambda> square_def

Regardez les noms. Chaque lambda est simplement appelé <lambda>, donc les messages d’erreur et les journaux ne peuvent pas vous dire lequel a échoué. C’est la principale raison pour laquelle les guides de style tels que PEP 8 recommandent un def chaque fois que vous souhaitez donner un nom à une fonction.

Tri avec clé : la meilleure utilisation

Les fonctions telles que sorted, min et max acceptent une fonction key qui décide quoi comparer. C’est là que les lambdas brillent :

products = [("pen", 10), ("bag", 900), ("book", 250)]

sorted(products, key=lambda p: p[1])
# [('pen', 10), ('book', 250), ('bag', 900)]

max(products, key=lambda p: p[1])
# ('bag', 900)

Pour trier selon plusieurs éléments, renvoyez un tuple. Ici, les gens sont triés par âge, les plus âgés d’abord, puis par nom :

people = [{"name": "Asha", "age": 31}, {"name": "Ben", "age": 25},
          {"name": "Dev", "age": 31}]

[p["name"] for p in sorted(people, key=lambda p: (-p["age"], p["name"]))]
# ['Asha', 'Dev', 'Ben']

Le signe moins inverse l’ordre du nombre uniquement. Parfois, vous n’avez pas du tout besoin d’un lambda, car une fonction existante fait déjà le travail. Comparez le tri par défaut avec un tri insensible à la casse :

names = ["Asha", "ben", "Chitra", "dev"]

sorted(names)                  # ['Asha', 'Chitra', 'ben', 'dev']
sorted(names, key=str.lower)   # ['Asha', 'ben', 'Chitra', 'dev']

La valeur par défaut place tous les mots en majuscules en premier. Passer str.lower corrige cela sans aucun lambda. Le module operator propose des aides similaires, telles que itemgetter(1) pour lambda p: p[1].

cartographier et filtrer

map applique une fonction à chaque élément et filter conserve les éléments pour lesquels il renvoie vrai. Les deux fonctionnent avec des lambdas, mais comparez chacun avec une compréhension de liste :

nums = [1, 2, 3, 4, 5, 6]

list(map(lambda n: n * 10, nums))      # [10, 20, 30, 40, 50, 60]
[n * 10 for n in nums]                 # [10, 20, 30, 40, 50, 60]

list(filter(lambda n: n % 2 == 0, nums))   # [2, 4, 6]
[n for n in nums if n % 2 == 0]            # [2, 4, 6]

Les résultats sont identiques et la plupart des développeurs Python trouvent les compréhensions plus faciles à lire. Notez également que map et filter renvoient des itérateurs paresseux, vous avez donc besoin de list() pour voir les valeurs. Notre guide de Compréhension des listes Python couvre ce style en profondeur. map se lit toujours bien avec une fonction nommée existante, comme dans map(str.strip, lines).

réduire

functools.reduce combine les éléments en une seule valeur, portant un résultat courant :

from functools import reduce

reduce(lambda acc, n: acc + n, nums, 0)   # 21
sum(nums)                                 # 21

Pour les tâches courantes, telles que les totaux, utilisez un élément intégré tel que sum, max ou any. Gardez reduce pour les cas plus rares et envisagez une boucle simple si le lambda commence à paraître compliqué.

Conditions dans un lambda

Vous ne pouvez pas utiliser une instruction if dans un lambda, mais vous pouvez utiliser une expression conditionnelle :

label = lambda total: "large" if total >= 1000 else "small"

label(1200), label(300)
# ('large', 'small')

Une condition est bonne. Une fois que vous commencez à les imbriquer, les lecteurs doivent travailler dur, ce qui est un signe clair pour passer à un def avec des instructions if ordinaires.

Lambdas qui renvoient des fonctions

Une fonction peut créer et renvoyer un lambda qui mémorise une valeur de son environnement :

def multiplier(n):
    return lambda x: x * n

double = multiplier(2)
double(7)   # 14

Cela fonctionne grâce aux fermetures, que notre article sur les Fermetures JavaScript explique dans un langage différent. Python functools.partial propose une autre façon de pré-remplir les arguments.

Le piège de la liaison tardive

Cela finit par attraper presque tout le monde. Nous avons créé trois lambdas dans une boucle, en attendant que chacun renvoie son propre numéro :

funcs = [lambda: i for i in range(3)]
[f() for f in funcs]

# [2, 2, 2]

Tous les trois renvoient 2. Un lambda ne capture pas la valeur de i lors de sa création. Il recherche la variable lorsqu’elle est appelée, et la boucle est alors terminée, laissant i à 2. La solution habituelle consiste à capturer la valeur comme argument par défaut, puisque les valeurs par défaut sont évaluées au moment de la définition :

funcs = [lambda i=i: i for i in range(3)]
[f() for f in funcs]

# [0, 1, 2]

Ceci n’est pas propre aux lambdas, car un def à l’intérieur d’une boucle se comporte de la même manière. Il apparaît simplement plus souvent avec les lambdas, car ils sont si souvent créés dans des boucles, par exemple lors de l’attachement de rappels de boutons.

Tables de recherche de petites fonctions

Les lambdas s’intègrent parfaitement dans un dictionnaire qui mappe les noms à de petites opérations :

ops = {
    "add": lambda a, b: a + b,
    "sub": lambda a, b: a - b,
}

ops["sub"](10, 3)   # 7

Cela peut remplacer une longue chaîne de if et elif. Le guide Dictionnaire Python couvre davantage de modèles de dictionnaire, et le module operator fournit déjà operator.add et operator.sub.

Limites des lambdas

• Une seule expression. Aucune affectation avec =, pas de boucles et pas de blocs try.
• Aucune déclaration. L’écriture de lambda x: return x échoue avec un SyntaxError, comme notre test l’a confirmé.
• Pas d’indications de docstring ou de type. Les outils et les lecteurs reçoivent moins d’aide.
• Débogage plus difficile. Les erreurs pointent vers <lambda> plutôt que vers un nom utile.

Bien entendu, les Lambdas peuvent toujours déclencher des exceptions. Leur gestion fonctionne de la même manière que pour n’importe quelle fonction, comme expliqué dans Gestion des exceptions Python.

Quand ne pas utiliser un lambda

Ce dernier point est important. Une logique qui mérite d’être réutilisée vaut la peine d’être testée, et une fonction nommée est beaucoup plus facile à tester, comme le montre notre tutoriel pytest.

Pour conclure

Un bon lambda est suffisamment court pour être lu d’un seul coup d’œil et utilisé une seule fois, généralement comme argument. Les clés de tri sont l’exemple classique. Pour vérifier votre propre code, recherchez = lambda et transformez-le en fonctions nommées. Ensuite, regardez n’importe quel map ou filter avec un lambda et voyez si une compréhension se lit mieux.

Questions fréquentes

Continuez à apprendre