Les expressions lambda en Python

Syntaxe d'une expression lambda

Une expression lambda se définit avec le mot-clé lambda, suivi des paramètres, d'un deux-points, puis d'une seule expression. Elle retourne implicitement le résultat de cette expression — pas besoin de return.

# Syntaxe générale
lambda paramètres: expression
# Équivalent avec def :
def anonymous(paramètres):
    return expression

La différence avec def : la lambda n'a pas de nom et ne peut contenir qu'une seule expression. Elle est conçue pour les cas où on a besoin d'une fonction simple, à un seul endroit.

Passer une lambda comme argument

En Python, une fonction peut recevoir une autre fonction en argument. C'est là que les lambdas sont particulièrement utiles : elles évitent de définir une fonction nommée pour un usage ponctuel.

Voici une fonction get_nom_complet() qui accepte un formateur en troisième argument. Sans lambda, on doit d'abord définir deux fonctions séparées :

def get_nom_complet(prenom, nom, formateur):
    return formateur(prenom, nom)
# Deux fonctions formateur définies séparément
def prenom_nom(prenom, nom):
    return f"{prenom} {nom}"
def nom_prenom(prenom, nom):
    return f"{nom}, {prenom}"
print(get_nom_complet('John', 'Doe', prenom_nom))  # John Doe
print(get_nom_complet('John', 'Doe', nom_prenom))  # Doe, John

Avec des lambdas, on passe directement la logique sans définir de fonctions intermédiaires :

def get_nom_complet(prenom, nom, formateur):
    return formateur(prenom, nom)
# Lambda passée directement en argument
print(get_nom_complet('John', 'Doe', lambda p, n: f"{p} {n}"))
# John Doe
print(get_nom_complet('John', 'Doe', lambda p, n: f"{n}, {p}"))
# Doe, John

Retourner une lambda depuis une fonction

Une fonction peut aussi retourner une lambda. C'est utile pour créer des fonctions spécialisées à la volée. Dans l'exemple suivant, fois(n) retourne une fonction qui multiplie par n.

def fois(n):
    return lambda x: x * n  # retourne une fonction qui multiplie par n
# triple est maintenant une fonction qui multiplie par 3
triple = fois(3)
print(triple(3))   # 9
print(triple(8))   # 24
# On peut aussi stocker le résultat dans une variable
x = triple(8)
print(x)           # 24

Piège classique : lambda dans une boucle

Une erreur fréquente consiste à créer des lambdas dans une boucle en espérant capturer la valeur de l'itérateur à chaque tour. Le résultat est souvent surprenant :

appellables = []
for i in (1, 2, 3):
    appellables.append(lambda: i)  # chaque lambda référence i, pas sa valeur
for f in appellables:
    print(f())
# Résultat obtenu : 3, 3, 3 (et non 1, 2, 3)

Le problème : toutes les lambdas pointent vers la même variable i. Au moment où on les appelle, la boucle est terminée et i vaut 3. Pour capturer la valeur courante, on utilise un argument par défaut :

appellables = []
for i in (1, 2, 3):
    appellables.append(lambda a=i: a)  # a=i capture la valeur au moment de la création
for f in appellables:
    print(f())
# Résultat correct : 1, 2, 3

En définissant a=i comme valeur par défaut, Python évalue i au moment où la lambda est créée, pas au moment où elle est appelée.

Par carabde | Mis à jour le 24 avril 2026