Expressions lambda — écrire des fonctions anonymes en une ligne

Dans l'article précédent sur les fonctions d'ordre supérieur, tu as vu comment passer des fonctions en argument et en valeur de retour. Définir une nouvelle fonction avec def chaque fois que tu dois transmettre un callback, c'est faire passer une opération d'une ligne à 3 ou 4 lignes.

C'est là que les expressions lambda (lambda) entrent en jeu — elles te permettent d'écrire une fonction anonyme sur une seule ligne. Parfait pour les petits bouts de logique qui ne méritent pas un def complet.

Qu'est-ce qu'un lambda — comparé à def

La syntaxe est lambda args: expression. Le résultat de expression devient directement la valeur de retour, et tu n'écris pas return (en fait, le faire déclenche un SyntaxError).

Contrairement à une fonction normale, un lambda n'a pas de nom, donc on ne peut pas l'appeler à moins de l'affecter à une variable. Le nom de la variable à laquelle tu l'affectes devient effectivement le nom de la fonction.

# Écrit avec def
def add_tax(price):
    return int(price * 1.1)

print(add_tax(980))   # 1078

# Même logique en lambda (pas besoin de return)
add_tax = lambda price: int(price * 1.1)

print(add_tax(980))   # 1078

Seules les expressions sont permises — pas d'instructions

Un corps de lambda ne peut contenir qu'une expression (quelque chose qui s'évalue en une valeur). Les instructions if, les boucles for, et les affectations (=) n'y rentrent pas. Dès que tu veux quelque chose de plus élaboré, reviens à def — c'est le bon réflexe.

Écris une fonction d'une ligne qui ajoute 10 % de TVA au prix d'un produit.

① Construis une fonction qui prend un prix et retourne le montant TTC sous forme d'entier.

② Appelle-la avec 980 euros et 2480 euros et affiche chaque résultat.

(Lorsque la réponse est correcte, l'explication apparaîtra.)

Plus d'arguments, expressions conditionnelles et valeurs par défaut

Les lambdas peuvent aussi prendre plusieurs arguments. Liste-les simplement avec des virgules, comme lambda x, y: x * y.

Tu peux aussi utiliser des arguments par défaut de la même manière qu'avec def. Pour basculer entre des valeurs selon une condition, glisse une expression conditionnelle valeur1 if condition else valeur2 dans le corps.

# Plusieurs arguments
rect_area = lambda width, height: width * height
print(rect_area(4, 5))            # 20

# Argument par défaut (omet rate pour utiliser 0.1)
add_tax = lambda price, rate=0.1: int(price * (1 + rate))
print(add_tax(1000))              # 1100
print(add_tax(1000, 0.08))        # 1080

# Expression conditionnelle
judge_age = lambda age: "adulte" if age >= 20 else "mineur"
print(judge_age(25))              # adulte
print(judge_age(17))              # mineur

# Retourner plusieurs valeurs sous forme de tuple
stats = lambda x, y: (x + y, x * y)
print(stats(3, 4))                # (7, 12)

Écris un one-liner qui retourne un palier d'adhérent (GOLD / SILVER / BRONZE) selon des points. 1000 ou plus donne GOLD, 500 ou plus donne SILVER, et tout ce qui est en dessous donne BRONZE.

① Construis une fonction qui prend des points et retourne le palier.

② Appelle-la avec 1500, 700 et 100, et affiche le résultat pour chacun.

Association avec les fonctions d'ordre supérieur — là où les lambdas brillent

Les lambdas gagnent vraiment leur place quand tu veux passer une fonction jetable à une fonction d'ordre supérieur. Par exemple, l'argument key de sorted() est une fonction d'ordre supérieur qui prend « une fonction qui retourne la clé de tri à partir de chaque élément ».

Pour un ordre de tri que tu n'as pas besoin de nommer et de réutiliser, écrire key=lambda x: x["price"] en ligne sur le site d'appel est la forme la plus naturelle.

products = [
    {"name": "Cahier", "price": 480},
    {"name": "Stylo", "price": 120},
    {"name": "Gomme", "price": 80},
]

# Tri par prix croissant (passe un lambda en ligne comme key)
cheap_first = sorted(products, key=lambda item: item["price"])
for item in cheap_first:
    print(item["name"], item["price"])
# Gomme 80
# Stylo 120
# Cahier 480

# La même fonction d'ordre supérieur process_list peut changer de comportement via lambda
def process_list(numbers, func):
    for n in numbers:
        print(func(n))

process_list([1, 2, 3, 4], lambda x: x ** 2)
# 1
# 4
# 9
# 16

Trie une liste d'utilisateurs par score, du plus haut en premier. sorted() passe en ordre décroissant quand tu passes reverse=True.

① Définis users = [{"name": "Alice", "score": 78}, {"name": "Léa", "score": 92}, {"name": "Hugo", "score": 65}].

② Trie avec sorted(users, key=lambda u: u["score"], reverse=True) et affecte le résultat à ranking.

③ Boucle avec for u in ranking: et affiche print(u["name"], u["score"]).

Quand utiliser un lambda — et quand l'éviter

Les lambdas sont pratiques, mais les utiliser partout nuit en réalité à la lisibilité. Le tableau ci-dessous résume : utilise les lambdas pour les opérations jetables d'une ligne, et garde def pour tout ce qui est complexe ou réutilisé.

N'entasse pas tout dans un lambda

Empile trois expressions conditionnelles imbriquées ou enchaîne plusieurs appels de fonction et tu te retrouves avec du code sur une ligne mais illisible. Dès que tu te dis « j'aimerais bien laisser un commentaire pour expliquer ce que fait ce lambda », tourne-toi vers def.

Passe un lambda en ligne à une fonction d'ordre supérieur appelée process_list.

① Définis def process_list(numbers, func): et appelle print(func(n)) à l'intérieur de for n in numbers:.

② Appelle process_list([1, 2, 3, 4, 5], lambda x: x ** 2) et vérifie que le carré de chaque élément s'affiche dans l'ordre.

③ Appelle-la encore avec process_list([1, 2, 3, 4, 5], lambda x: x * 10) et vérifie que le comportement change juste en échangeant le lambda.