Python Lambda

Qu'est-ce qu'une fonction lambda ?

Une fonction lambda est une petite fonction anonyme définie avec le mot-clé lambda à la place de def. Anonyme signifie qu'elle n'a pas de nom associé — bien que vous puissiez en assigner une à une variable si vous avez besoin de la réutiliser. Les fonctions lambda sont un moyen concis d'écrire des fonctions simples à expression unique en ligne, sans la surcharge d'une définition de fonction complète.

Les fonctions lambda sont particulièrement utiles comme callbacks de courte durée passés aux fonctions d'ordre supérieur comme map(), filter() et sorted().

Syntaxe

lambda arguments: expression

• arguments — zéro ou plusieurs paramètres séparés par des virgules (identique à la liste de paramètres d'une fonction def, y compris les valeurs par défaut).
• expression — une expression unique dont la valeur est automatiquement retournée. Les instructions (comme les blocs if/else, les boucles for ou return) ne sont pas autorisées dans le corps d'un lambda.

Une comparaison côte à côte valide :

def square(x):
    return x ** 2

square_lambda = lambda x: x ** 2

print(square(5))        # Output: 25
print(square_lambda(5)) # Output: 25

Exemples de base

# No arguments
greet = lambda: "Hello, World!"
print(greet())  # Output: Hello, World!

# One argument
square = lambda x: x ** 2
print(square(5))  # Output: 25

# Two arguments
add = lambda x, y: x + y
print(add(10, 20))  # Output: 30

# Default argument value
greet_name = lambda name="World": "Hello, " + name + "!"
print(greet_name())          # Output: Hello, World!
print(greet_name("Alice"))   # Output: Hello, Alice!

Logique conditionnelle dans un lambda

Comme les lambdas doivent être une expression unique, vous ne pouvez pas utiliser une instruction if/else. Vous pouvez cependant utiliser une expression ternaire (conditionnelle) :

classify = lambda n: "positive" if n > 0 else ("zero" if n == 0 else "negative")

print(classify(5))   # Output: positive
print(classify(0))   # Output: zero
print(classify(-3))  # Output: negative

Les expressions ternaires profondément imbriquées nuisent rapidement à la lisibilité — passez à une fonction def classique dès que la logique se complexifie.

Utilisation de lambda avec map()

map(function, iterable) applique une fonction à chaque élément d'un itérable et retourne un objet map. Lambda est parfaitement adapté comme argument de fonction.

nums = [1, 2, 3, 4, 5]
doubled = list(map(lambda x: x * 2, nums))
print(doubled)  # Output: [2, 4, 6, 8, 10]

La compréhension de liste équivalente est souvent préférée pour sa lisibilité :

doubled = [x * 2 for x in nums]  # same result

Consultez List Comprehension pour en savoir plus sur cette approche.

Utilisation de lambda avec filter()

filter(function, iterable) ne conserve que les éléments pour lesquels la fonction retourne True.

nums = [1, 2, 3, 4, 5]
evens = list(filter(lambda x: x % 2 == 0, nums))
print(evens)  # Output: [2, 4]

Utilisation de lambda avec sorted()

Le paramètre key de sorted() (et de list.sort()) accepte un callable qui retourne la valeur de comparaison pour chaque élément. Lambda permet de définir des clés de tri ponctuelles de façon concise.

# Sort strings by length
words = ["banana", "apple", "cherry", "date"]
by_length = sorted(words, key=lambda s: len(s))
print(by_length)  # Output: ['date', 'apple', 'banana', 'cherry']

# Sort a list of tuples by the second element
pairs = [(1, "b"), (2, "a"), (3, "c")]
by_second = sorted(pairs, key=lambda p: p[1])
print(by_second)  # Output: [(2, 'a'), (1, 'b'), (3, 'c')]

Pour en savoir plus sur le tri des listes, consultez Sort Lists.

Lambda invoqué immédiatement

Un lambda peut être appelé au moment où il est défini en l'encadrant de parenthèses et en ajoutant les arguments :

result = (lambda x, y: x + y)(3, 7)
print(result)  # Output: 10

Ce modèle est peu courant en production, mais peut s'avérer utile dans des scripts ponctuels ou des tests rapides.

Lambda stocké dans une structure de données

Comme un lambda est un objet de première classe en Python, vous pouvez stocker des lambdas dans des listes ou des dictionnaires pour créer de simples tables de dispatch :

ops = {
    "add": lambda x, y: x + y,
    "sub": lambda x, y: x - y,
    "mul": lambda x, y: x * y,
}

print(ops["add"](3, 4))   # Output: 7
print(ops["sub"](10, 3))  # Output: 7
print(ops["mul"](2, 6))   # Output: 12

Lambda vs. def — Quand utiliser lequel

Le guide de style PEP 8 recommande de ne pas assigner un lambda à un nom de variable quand un def serait plus clair. Par exemple, préférez def add(x, y): return x + y plutôt que add = lambda x, y: x + y lorsque la fonction se trouve au niveau du module.

Limitations clés

• Expression unique uniquement. Pas d'affectations, de boucles ou de logique multiligne.
• Pas d'instructions. print() est un appel de fonction (valide), mais assert, raise ou return sont des instructions et ne peuvent pas apparaître dans le corps d'un lambda.
• Pas d'annotations. Les annotations de type (x: int) ne sont pas autorisées dans les listes de paramètres d'un lambda.
• Plus difficile à déboguer. Les traces de pile affichent <lambda> au lieu d'un nom de fonction significatif.
• Ne peut pas être sérialisé. Le module standard pickle ne peut pas sérialiser les objets lambda — ce qui est pertinent lors de l'utilisation du multiprocessing.

Relation avec les fermetures et les décorateurs

Comme une fonction classique définie avec def, un lambda capture les variables de sa portée englobante :

def make_multiplier(n):
    return lambda x: x * n   # 'n' is captured from the enclosing scope

double = make_multiplier(2)
triple = make_multiplier(3)

print(double(5))  # Output: 10
print(triple(5))  # Output: 15

Pour un aperçu approfondi du fonctionnement des fermetures en Python, consultez Python Closures. Les fonctions lambda apparaissent également fréquemment dans les Python Decorators comme enveloppes légères. Pour une vue complète des définitions de fonctions, consultez Python Functions.

Pratique