Les fonctions anonymes avec Python (lambda)

En Python, le mot-clé lambda permet de créer ce que l’on appelle des fonctions anonymes.

Il s’agit de fonctions sans nom explicite, souvent utilisées pour des opérations simples et ponctuelles, comme :

• le tri ;
• la transformation ;
• ou le filtrage de données.

L’intérêt principal des fonctions lambda réside dans leur concision (on les écrit rapidement 😉) et leur utilisation contextuelle (elles sont pratiques). C'est pour cela qu'elles sont souvent utilisées à l’intérieur d’autres fonctions ou comme arguments de fonctions de haut niveau comme map(), filter() ou sorted().

Syntaxe d'une fonction anonyme (lambda)

La syntaxe d’une fonction lambda est l’un de ses plus grands atouts. Elle est minimaliste, simple et directe :

lambda arguments: expression

Décortiquons cette syntaxe :

• lambda : notre mot-clé pour définir une fonction anonyme ;
• arguments : un ou plusieurs paramètres qui sont passés à la fonction ;
• expression : une ligne de code qui sera évaluée et retournée automatiquement.

Notez bien ceci : elle est retournée automatiquement ! Ce qui veut dire que nous n'avons pas besoin d'utiliser le mot-clé return.

Prenons un exemple assez simple pour illustrer notre syntaxe :

addition = lambda x, y: x + y
print(addition(3, 5))  # Résultat : 8

Dans cet exemple, nous avons une variable qui s'appelle addition et qui prend une fonction lambda (lambda).

Elle prend deux arguments (x, y) et retourne le résultat situé après les deux point (:) soit x + y.

Quand on affiche le résultat de cette fonction lambda avec print() nous avons donc bien 8.

Caractéristiques clés des fonctions lambda

Les fonctions lambda ont plusieurs caractéristiques distinctes qui les rendent uniques dans l’écosystème Python :

• Sans nom (anonyme) : Elles sont généralement utilisées pour des instructions rapides ;
• Concision : Rapides à écrire de part leur syntaxe (que nous venons de voir), elles permettent de réduire le besoin d'écrire des blocs complets d'instructions pour des tâches simples ;
• Pas de blocs multiples : Une seule expression est autorisée (on ne peut donc pas utiliser les boucles par exemple 😋) ;
• Pas de documentation : On ne peut pas inclure de docstring ;

En résumé, il est recommandé d'utiliser lambda quand cela permet une simplification immédiate du code.

Il vaut mieux privilégier les fonctions classiques avec def si la logique devient trop complexe ou si la fonction doit être réutilisée.

Différences entre lambda et def

Des buts différents

Puisque nous venons d'en faire l'introduction rapide, parlons maintenant des différences entre lambda et def ! 😬

Tous deux permettent de créer des fonctions en Python.

Cependant, ils sont destinés à des usages bien différents :

• lambda est une syntaxe courte et inline (sans retour à la ligne), réservée aux expressions uniques (bref, aux instructions simples et basiques uniques) ;
• def permet de définir des fonctions avec plusieurs lignes de code, incluant conditions, boucles et blocs complexes.

Des syntaxes différentes

Voici un exemple qui permet de bien comprendre les différences de syntaxe entre une fonction lambda et une fonction dite classique avec def :

# Avec lambda
add = lambda x, y: x + y

# Avec def
def add(x, y):
    return x + y

Comme nous pouvons le voir,  une fonction lambda tient sur une seule ligne pour une instruction simple, là où il nous faut généralement au moins deux lignes pour une fonction traditionnelle.

Quand utiliser quoi entre lambda et def ?

Exemples d'utilisation des fonctions lambda

Les fonctions lambda sont très utilisées quand elles sont passées comme argument pour des fonctions, comme dans map(), filter(), reduce() ou encore sorted().

Comment utiliser une fonction lambda avec map()

Voici comment nous pouvons appliquer une fonction à chaque élément itérable et grâce à map() :

nombres = [1, 2, 3]
double = list(map(lambda x: x * 2, nombres))
print(double)  # [2, 4, 6]

Dans cet exemple, notre fonction lambda reçoit x comme argument, qui vient justement de notre fonction map().

Comment utiliser une fonction lambda avec filter()

On combine souvent filter() avec une fonction lambda pour filtrer selon une condition :

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

Comme pour notre exemple précédent, notre fonction lambda reçoit dans son paramètre x les éléments dans nombres un par un afin de retourner uniquement les nombres pairs (donc avec un modulo % restant égal à zéro).

Comment utiliser une fonction lambda avec reduce()

Il est très courant d'utiliser une fonction lambda avec reduce() pour faire une réduction cumulative.

from functools import reduce

nombres = [1, 2, 3, 4]
produit = reduce(lambda x, y: x * y, nombres)
print(produit)  # 24

Pensez bien à importer functools depuis reduce.

Comment utiliser une fonction lambda avec sorted()

Enfin, on peut utiliser une fonction lambda avec sorted() pour trier des éléments d'une liste selon une clé personnalisée.

noms = ['Python', 'AI', 'Lambda', 'Code']
triés = sorted(noms, key=lambda x: len(x))
print(triés)  # ['AI', 'Code', 'Lambda', 'Python']

Un autre exemple avec des dictionnaires :

personnes = [
  {"nom": "Alice", "age": 25},
  {"nom": "Bob", "age": 20},
  {"nom": "Charlie", "age": 30}
]

tri = sorted(personnes, key=lambda x: x["age"])
print(tri)

# ["Bob", "Alice", "Charlie"]

Utiliser lambda avec pandas

La librairie Pandas est incontournable pour la manipulation de données en Python.

L’un des usages les plus pratiques des fonctions lambda est avec la méthode apply() de Pandas, qui permet d’appliquer une transformation sur les lignes ou les colonnes d’un DataFrame.

Voyons trois exemples d'utilisation des fonctions anonymes combinés à la librairie Pandas.

Exemple 1 : Formater une colonne en majuscule

import pandas as pd

df = pd.DataFrame({
    'nom': ['John', 'Elton', 'Magla']
})

df['nom_majuscule'] = df['nom'].apply(lambda x: x.upper())

print(df)

Dans cet exemple :

• On crée une colonne nom_majuscule à partir de la colonne nom ;
• Pour chaque valeur de la colonne, on applique x.upper() qui met le texte en majuscules.

Cela évite de créer une fonction à part juste pour cette tâche simple.

Résultat :

Exemple 2 : Calcul pondéré ligne par ligne

df = pd.DataFrame({
    'valeur': [1, 2, 3],
    'poids': [3, 4, 5]
})

df['pondéré'] = df.apply(lambda row: row['valeur'] * row['poids'], axis=1)

print(df)

Ici :

• axis=1 signifie qu'on applique la fonction ligne par ligne ;
• row['valeur'] * row['poids'] effectue un produit pondéré pour chaque ligne du DataFrame ;
• Le résultat est stocké dans une nouvelle colonne pondéré (df['pondéré']).

Résultat :

Toujours préciser axis=1 dans apply() si vous voulez travailler sur les lignes du DataFrame. Sinon, Pandas appliquera la fonction colonne par colonne (axis=0) par défaut.

Exemple 3 : Créer une colonne conditionnelle

df = pd.DataFrame({
    'score': [75, 42, 90, 60]
})

df['mention'] = df['score'].apply(lambda x: 'Réussite' if x >= 60 else 'Échec')

print(df)

Enfin dans cet exemple :

• On ajoute une colonne mention en fonction du score ;
• Si le score est supérieur ou égal à 60, on écrit 'Réussite', sinon 'Échec'.

C’est une méthode simple pour classifier les données directement dans le DataFrame.

Résultat :

Ce type d'opération est extrêmement courant dans l'analyse de données, pour créer des segments, des scores ou des labels à partir de critères numériques ou textuels.

Questions fréquentes sur les fonctions lamba en Python

Peut-on écrire plusieurs lignes dans une fonction lambda ?

Non. Une fonction lambda est limitée à une seule expression. Elle ne peut pas contenir d’instructions multiples, de boucles, ni de blocs if/else classiques. Pour des traitements complexes, il faut utiliser def.

Comment puis-je apprendre Python ?

Il est important de choisir une formation qui soit complètement à jour, comme celle que nous proposons.

Est-il possible de donner un nom à une fonction lambda ?

Techniquement oui, mais ce n’est pas recommandé. Si vous devez nommer une fonction lambda, mieux vaut utiliser def, conformément aux recommandations de la PEP 8.

# ❌ Mauvaise pratique
f = lambda x: x + 1

# ✅ Bonne pratique
def f(x): return x + 1

Peut-on typer une fonction lambda avec des annotations ?

Non. Les lambdas ne permettent pas d’annotations de type comme les fonctions classiques. Pour typer proprement une fonction, il faut utiliser def.