Les expressions lambda en Python offrent une syntaxe concise pour créer des fonctions anonymes, particulièrement utiles pour des opérations simples. Elles permettent d'éviter la déclaration formelle de fonctions lorsque la logique est triviale, tout en maintenant la lisibilité du code.

Syntaxe de base

Une lambda prend des paramètres et retourne une valeur après exécution d'une expression unique. Voici une implémentation de multiplication :

calcul_produit = lambda valeur: valeur * 3
calcul_produit(4)
# Retourne 12

Structures conditionnelles

Les opérateurs ternaires s'intègrent naturellement dans les lambdas pour des décisions binaires :

evaluer_nombre = lambda n: "Supérieur" if n > 5 else "Inférieur"
evaluer_nombre(7)
# Retourne "Supérieur"

Gestion des boucles et portée

L'utilisation de boucles dans les lambdas nécessite une attention particulière à la portée des variables. L'exemple suivant illustre un piège courant :

generateurs = [lambda x, idx=i: x + idx for i in range(4)]
[resultat(2) for resultat in generateurs]
# Retourne [2, 3, 4, 5]

Contrairement à une première impression, chaque fonction capture la valeur courante de i grâce au paramètre par défaut idx, évitant ainsi le problème de late binding.

Intégration avec les fonctions natives

La combinaison avec map() permet des transformations rapides sur des collections :

valeurs = list(map(lambda item: item ** 3, [2, 3, 4]))
# Résultat : [8, 27, 64]

De même, filter() sélectionne des éléments selon un critère prédéfini :

selection = list(filter(lambda val: val % 2 == 0, [1, 2, 3, 4, 5]))
# Résultat : [2, 4]

Application dans Pandas

Dans les dataframes, les lambdas simplifient les transformations de colonnes. Cet exemple formate des décimaux en valeurs à deux chiffres après la virgule :

import pandas as pd
import numpy as np

df = pd.DataFrame([round(np.random.uniform(0, 1), 3) for _ in range(5)], columns=['valeurs'])
df['formate'] = df['valeurs'].apply(lambda x: f"{x:.2f}")

# Exemple de sortie :
#   valeurs formate
# 0   0.732    0.73
# 1   0.194    0.19
# 2   0.867    0.87

Limites et bonnes pratiques

Bien que les lambdas imbriquées soient syntaxiquement valides, elles réduisent la lisibilité. Privilégiez leur utilisation pour des opérations unilignes plutôt que pour des structures complexes. Leur force réside dans la capacité à exprimer des transformations fonctionnelles claires sans surcharge de déclaration.