Les fonctions anonymes (lambda) en langage Python

En programmation fonctionnelle, une fonction anonyme est une fonction définie sans nom, créée à la volée à l'endroit exact où elle est consommée. En Python, ces fonctions sont introduites par le mot-clé lambda.

Les fonctions lambda sont particulièrement utiles comme fonctions jetables (throwaway functions) passées en argument de fonctions d'ordre supérieur comme sorted(), map(), filter() ou min() / max().

---

1. Syntaxe et règles d'écriture d'une expression lambda

La syntaxe d'une fonction lambda est condensée sur une unique ligne :

\[\textbf{lambda } \text{arg}_1, \text{arg}_2, \dots : \textbf{expression\_de\_retour}\]

# Fonction standard avec def :
def doubler(x: int) -> int:
    return x * 2

# Fonction lambda équivalente :
doubler_lambda = lambda x: x * 2

print(doubler(5))         # 10
print(doubler_lambda(5))  # 10

Les contraintes strictes d'une lambda

[!IMPORTANT] 1. Une fonction lambda ne peut contenir qu'une seule et unique expression. 2. Elle ne peut contenir aucune instruction (statement) telle que for, while, raise, ou del. 3. Le mot-clé return est implicite : le résultat de l'expression est automatiquement renvoyé. 4. Une expression conditionnelle ternaire (a if condition else b) est en revanche parfaitement valide.

---

2. Le cas d'usage roi : Tri personnalisé avec sorted()

L'intérêt majeur des lambdas réside dans le paramètre key de la fonction native sorted() ou de la méthode .sort().

Trier une liste de dictionnaires par un champ spécifique

etudiants = [
    {"nom": "Alice", "age": 22, "moyenne": 14.5},
    {"nom": "Bob", "age": 20, "moyenne": 17.0},
    {"nom": "Charlie", "age": 25, "moyenne": 11.2},
    {"nom": "Diana", "age": 21, "moyenne": 18.5}
]

# Tri par moyenne décroissante
classement_notes = sorted(etudiants, key=lambda e: e["moyenne"], reverse=True)

print("=== PALMARES DES NOTES ===")
for e in classement_notes:
    print(f"{e['nom']:<10} -> {e['moyenne']:.1f} / 20")

Tri multi-critères avec tuples

Vous pouvez trier selon plusieurs colonnes successives en renvoyant un tuple dans la clé :

employes = [
    ("Informatique", "Koffi", 3500),
    ("Marketing", "Sarah", 4200),
    ("Informatique", "Diallo", 4800),
    ("Marketing", "Alex", 3100)
]

# Tri par Département (alphabétique) puis par Salaire (décroissant)
tri_employes = sorted(employes, key=lambda emp: (emp[0], -emp[2]))
print(tri_employes)

---

3. Utilisation avec map(), filter() et reduce()

A. Filtrer des données avec filter()

filter(fonction, iterable) ne conserve que les éléments pour lesquels la fonction renvoie True :

valeurs = [12, -5, 0, 48, -19, 32, -1]

# Garder uniquement les nombres positifs
positifs = list(filter(lambda x: x > 0, valeurs))
print(positifs)  # [12, 48, 32]

B. Transformer des données avec map()

map(fonction, iterable) applique une transformation à chaque élément :

prix_dollars = [10.0, 25.5, 99.0]
taux_conversion = 0.92

# Conversion en Euros
prix_euros = list(map(lambda p: round(p * taux_conversion, 2), prix_dollars))
print(prix_euros)  # [9.2, 23.46, 91.08]

C. Réduction cumulative avec functools.reduce()

reduce(fonction, iterable) applique une fonction binaire cumulative de gauche à droite :

from functools import reduce

nombres = [1, 2, 3, 4, 5]
# Calcul du produit cumulé : (((1 * 2) * 3) * 4) * 5 = 120
produit = reduce(lambda acc, x: acc * x, nombres)
print("Produit factoriel :", produit)  # 120

---

4. lambda vs Compréhensions de listes : Que dit la PEP 8 ?

Dans la majorité des cas quotidiens, la communauté Python et le créateur Guido van Rossum recommandent d'utiliser les compréhensions de listes plutôt que map() et filter() combinés à des lambdas, car elles sont plus lisibles :

# Approche avec map et filter (style fonctionnel) :
res_map = list(map(lambda x: x ** 2, filter(lambda x: x % 2 == 0, range(10))))

# Approche Pythonique avec compréhension (claire et idiomatique) :
res_comp = [x ** 2 for x in range(10) if x % 2 == 0]

[!TIP] Recommandation PEP 8 :
N'assignez jamais une lambda à une variable (f = lambda x: x + 1). Si une fonction mérite d'avoir un nom et d'être réutilisée, écrivez toujours une définition classique avec def qui préserve le nom de la fonction dans la trace de débogage (Traceback).

---

5. Défi d'application

Soit une liste de chaînes représentant des dates au format ISO : dates = ["2026-03-03", "2024-12-25", "2025-07-14", "2024-01-01"].
À l'aide de sorted() et d'une fonction lambda, triez cette liste par mois calendaire (les deux chiffres centraux) plutôt que par année.

Partagez sur les réseaux sociaux

Commentaires