Fonctions Lambda Python : Un guide clair avec des exemples pratiques

Name

Soren Atelier

Updated on 09/02/2026

Chaque projet Python accumule de petites fonctions utilitaires. Une fonction qui double un nombre. Une autre qui supprime les espaces blancs. Encore une qui extrait un nom de famille d'un dictionnaire. Chacune fait deux ou trois lignes, est utilisée exactement une fois et encombre le module avec des noms que vous ne retiendrez jamais. Les fonctions lambda Python résolvent ce problème en vous permettant de définir de minuscules fonctions jetables exactement là où vous en avez besoin -- pas de def, pas de nom, pas d'espace vertical gaspillé.

Ce guide couvre tout ce que vous devez savoir sur les fonctions lambda Python : la syntaxe, les fonctions intégrées avec lesquelles elles s'associent, les modèles pratiques pour du code réel et les situations spécifiques où vous devriez les éviter.

Qu'est-ce qu'une fonction Lambda ?

Une fonction lambda est une fonction anonyme à expression unique. "Anonyme" signifie qu'elle n'a pas de nom. "Expression unique" signifie que le corps de la fonction est exactement une expression dont le résultat est automatiquement retourné. Python évalue cette expression et renvoie le résultat -- pas besoin d'instruction return.

Le terme vient du calcul lambda, un système formel en logique mathématique. Mais vous n'avez pas besoin de comprendre les mathématiques. En Python pratique, un lambda est simplement une façon plus courte d'écrire une petite fonction.

Voici une fonction régulière et son équivalent lambda :

# Regular function
def double(x):
    return x * 2
 
print(double(5))
# 10
 
# Lambda equivalent
double_lambda = lambda x: x * 2
 
print(double_lambda(5))
# 10

Les deux produisent le même résultat. La version lambda tient sur une ligne et évite la cérémonie du def et du return.

Syntaxe Lambda

La syntaxe pour un lambda Python est :

lambda arguments: expression

• lambda -- le mot-clé qui signale une fonction anonyme.
• arguments -- zéro ou plusieurs paramètres, séparés par des virgules. Pas de parenthèses requises.
• expression -- une expression unique qui est évaluée et retournée. Pas d'instructions (pas de blocs if, pas de boucles for, pas d'affectations avec =).

Quelques exemples rapides pour montrer l'éventail :

# No arguments
greet = lambda: "Hello, world!"
print(greet())
# Hello, world!
 
# One argument
square = lambda x: x ** 2
print(square(9))
# 81
 
# Two arguments
add = lambda a, b: a + b
print(add(3, 7))
# 10
 
# Default argument
power = lambda base, exp=2: base ** exp
print(power(3))
# 9
print(power(3, 3))
# 27

La contrainte clé est que le corps doit être une expression unique. Vous ne pouvez pas écrire de logique multiligne, utiliser des instructions if (bien que vous puissiez utiliser des expressions conditionnelles), ni inclure d'affectations. C'est intentionnel -- les lambdas sont conçus pour des opérations simples.

Lambda avec map() -- Transformer des listes

map() applique une fonction à chaque élément d'un itérable et retourne un itérateur. Les fonctions lambda sont le compagnon naturel de map() car la transformation est souvent assez simple pour être exprimée en une ligne.

numbers = [1, 2, 3, 4, 5]
 
# Square each number
squared = list(map(lambda x: x ** 2, numbers))
print(squared)
# [1, 4, 9, 16, 25]
 
# Convert temperatures from Celsius to Fahrenheit
celsius = [0, 20, 37, 100]
fahrenheit = list(map(lambda c: round(c * 9/5 + 32, 1), celsius))
print(fahrenheit)
# [32.0, 68.0, 98.6, 212.0]
 
# Extract first names from full names
names = ["Ada Lovelace", "Grace Hopper", "Alan Turing"]
first_names = list(map(lambda name: name.split()[0], names))
print(first_names)
# ['Ada', 'Grace', 'Alan']

map() avec un lambda est une alternative propre à une compréhension de liste lorsque la logique de mappage est une transformation directe en une seule étape. Pour des transformations plus complexes, les compréhensions de liste tendent à être plus lisibles.

Lambda avec filter() -- Filtrer des éléments

filter() prend une fonction et un itérable, et retourne un itérateur qui ne produit que les éléments pour lesquels la fonction retourne True. Les fonctions lambda facilitent la définition du prédicat en ligne.

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
 
# Keep only even numbers
evens = list(filter(lambda x: x % 2 == 0, numbers))
print(evens)
# [2, 4, 6, 8, 10]
 
# Keep strings longer than 4 characters
words = ["cat", "elephant", "dog", "butterfly", "ant"]
long_words = list(filter(lambda w: len(w) > 4, words))
print(long_words)
# ['elephant', 'butterfly']
 
# Filter out None values
data = [1, None, 3, None, 5, None, 7]
clean = list(filter(lambda x: x is not None, data))
print(clean)
# [1, 3, 5, 7]

Comme map(), la combinaison filter() + lambda fonctionne mieux pour des conditions simples. Si la logique de filtrage implique plusieurs vérifications, une compréhension de liste ou une fonction nommée est généralement plus claire.

Lambda avec sorted() et sort() -- Clés de tri personnalisées

Le tri est l'un des usages les plus courants et pratiques des fonctions lambda. La fonction sorted() et la méthode .sort() acceptent toutes deux un paramètre key -- une fonction qui extrait une valeur de comparaison de chaque élément.

# Sort strings by length
fruits = ["banana", "kiwi", "strawberry", "fig", "apple"]
by_length = sorted(fruits, key=lambda s: len(s))
print(by_length)
# ['fig', 'kiwi', 'apple', 'banana', 'strawberry']
 
# Sort tuples by the second element
pairs = [(1, 'b'), (3, 'a'), (2, 'c')]
by_second = sorted(pairs, key=lambda pair: pair[1])
print(by_second)
# [(3, 'a'), (1, 'b'), (2, 'c')]
 
# Sort dictionaries by a specific key
students = [
    {"name": "Alice", "grade": 88},
    {"name": "Bob", "grade": 95},
    {"name": "Charlie", "grade": 72},
]
by_grade = sorted(students, key=lambda s: s["grade"], reverse=True)
for s in by_grade:
    print(f"{s['name']}: {s['grade']}")
# Bob: 95
# Alice: 88
# Charlie: 72

Le tri avec lambda est si largement utilisé qu'il est devenu un modèle idiomatique Python. Chaque fois que vous devez trier des objets complexes par un attribut ou un champ spécifique, une fonction key lambda est l'approche standard.

Tri avec plusieurs critères

Vous pouvez retourner un tuple depuis le lambda pour trier par plusieurs champs :

employees = [
    {"name": "Alice", "dept": "Engineering", "salary": 95000},
    {"name": "Bob", "dept": "Marketing", "salary": 72000},
    {"name": "Charlie", "dept": "Engineering", "salary": 88000},
    {"name": "Diana", "dept": "Marketing", "salary": 85000},
]
 
# Sort by department (ascending), then by salary (descending)
sorted_emp = sorted(employees, key=lambda e: (e["dept"], -e["salary"]))
for e in sorted_emp:
    print(f"{e['dept']:12s} {e['name']:8s} ${e['salary']:,}")
# Engineering  Alice    $95,000
# Engineering  Charlie  $88,000
# Marketing    Diana    $85,000
# Marketing    Bob      $72,000

Lambda avec reduce() de functools

functools.reduce() applique une fonction à deux arguments de manière cumulative aux éléments d'un itérable, le réduisant à une valeur unique. Les fonctions lambda s'associent naturellement avec reduce() pour des agrégations concises.

from functools import reduce
 
numbers = [1, 2, 3, 4, 5]
 
# Product of all numbers
product = reduce(lambda x, y: x * y, numbers)
print(product)
# 120
 
# Find the maximum value (for demonstration; use max() in practice)
largest = reduce(lambda a, b: a if a > b else b, numbers)
print(largest)
# 5
 
# Concatenate a list of strings
words = ["Python", " ", "lambda", " ", "functions"]
sentence = reduce(lambda a, b: a + b, words)
print(sentence)
# Python lambda functions
 
# Flatten a list of lists
nested = [[1, 2], [3, 4], [5, 6]]
flat = reduce(lambda acc, lst: acc + lst, nested)
print(flat)
# [1, 2, 3, 4, 5, 6]

Un mot de prudence : reduce() peut obscurcir l'intention. Pour les opérations courantes comme la sommation, utilisez sum(). Pour trouver min/max, utilisez min() et max(). Réservez reduce() avec lambda pour les accumulations personnalisées où aucune fonction intégrée n'existe.

Lambda vs def -- Quand utiliser chacun

C'est la question qui compte le plus en pratique. Lambda et def créent tous deux des objets fonction, mais ils servent des objectifs différents.

Quand utiliser Lambda

• Clés de tri : sorted(items, key=lambda x: x.name)
• Opérations rapides map/filter : map(lambda x: x.strip(), lines)
• Arguments callback : fonctions qui acceptent un paramètre appelable
• Accès simple aux dictionnaires ou tuples : key=lambda item: item[1]

Quand utiliser def

• La fonction a plus d'une expression
• Vous avez besoin d'un docstring ou de type hints
• La fonction sera appelée depuis plusieurs endroits
• La logique nécessite une gestion d'erreurs ou des branchements
• Vous avez besoin d'un nom significatif dans les traces de pile pour le débogage

Règle générale : si le lambda ne tient pas confortablement sur une seule ligne, ou si vous devez le lire deux fois pour comprendre ce qu'il fait, utilisez def à la place.

Lambda avec plusieurs arguments

Les fonctions lambda peuvent accepter n'importe quel nombre d'arguments, y compris *args et **kwargs :

# Three arguments
volume = lambda l, w, h: l * w * h
print(volume(3, 4, 5))
# 60
 
# Using *args for variable arguments
sum_all = lambda *args: sum(args)
print(sum_all(1, 2, 3, 4, 5))
# 15
 
# Using **kwargs
build_greeting = lambda **kwargs: f"Hello, {kwargs.get('name', 'stranger')}!"
print(build_greeting(name="Alice"))
# Hello, Alice!
print(build_greeting())
# Hello, stranger!
 
# Conditional expression inside lambda
classify = lambda x: "positive" if x > 0 else ("zero" if x == 0 else "negative")
print(classify(5))
# positive
print(classify(0))
# zero
print(classify(-3))
# negative

Notez l'expression conditionnelle (a if condition else b) dans le dernier exemple. C'est la seule façon d'ajouter une logique de branchement à l'intérieur d'un lambda. Cela fonctionne, mais imbriquer plusieurs conditions réduit rapidement la lisibilité.

Lambda dans les opérations sur les dictionnaires

Les fonctions lambda sont utiles pour transformer et trier les données de dictionnaires :

# Sort a dictionary by value
scores = {"Alice": 88, "Bob": 95, "Charlie": 72, "Diana": 91}
sorted_scores = dict(sorted(scores.items(), key=lambda item: item[1], reverse=True))
print(sorted_scores)
# {'Bob': 95, 'Diana': 91, 'Alice': 88, 'Charlie': 72}
 
# Apply a transformation to all dictionary values
prices = {"apple": 1.20, "banana": 0.50, "cherry": 2.00}
discounted = {k: round(v * 0.9, 2) for k, v in prices.items()}
print(discounted)
# {'apple': 1.08, 'banana': 0.45, 'cherry': 1.8}
 
# Group items using a lambda as a key function
from itertools import groupby
 
data = ["apple", "avocado", "banana", "blueberry", "cherry", "cranberry"]
data_sorted = sorted(data, key=lambda x: x[0])
 
for letter, group in groupby(data_sorted, key=lambda x: x[0]):
    print(f"{letter}: {list(group)}")
# a: ['apple', 'avocado']
# b: ['banana', 'blueberry']
# c: ['cherry', 'cranberry']

Lambda avec Pandas : df.apply() et df.sort_values()

Les fonctions lambda sont intensément utilisées dans pandas pour les transformations au niveau des lignes et le tri personnalisé. La méthode apply() exécute une fonction sur chaque ligne ou colonne d'un DataFrame, et lambda garde le code en ligne.

import pandas as pd
 
df = pd.DataFrame({
    "name": ["Alice", "Bob", "Charlie", "Diana"],
    "score": [88, 95, 72, 91],
    "department": ["Engineering", "Marketing", "Engineering", "Marketing"]
})
 
# Add a new column with a grade label
df["grade"] = df["score"].apply(lambda x: "A" if x >= 90 else ("B" if x >= 80 else "C"))
print(df)
#       name  score   department grade
# 0    Alice     88  Engineering     B
# 1      Bob     95    Marketing     A
# 2  Charlie     72  Engineering     C
# 3    Diana     91    Marketing     A

Utiliser Lambda avec sort_values(key=)

Le paramètre key dans sort_values() accepte une fonction appliquée à la colonne avant le tri :

import pandas as pd
 
df = pd.DataFrame({
    "product": ["Widget A", "Widget B", "Widget C"],
    "price": ["$29.99", "$9.50", "$149.00"]
})
 
# Sort by numeric price value (strip the $ sign first)
df_sorted = df.sort_values("price", key=lambda col: col.str.replace("$", "", regex=False).astype(float))
print(df_sorted)
#     product    price
# 1  Widget B    $9.50
# 0  Widget A   $29.99
# 2  Widget C  $149.00

Utiliser Lambda avec apply() sur les lignes

Définissez axis=1 pour appliquer un lambda à chaque ligne :

import pandas as pd
 
df = pd.DataFrame({
    "first_name": ["Ada", "Grace", "Alan"],
    "last_name": ["Lovelace", "Hopper", "Turing"],
    "birth_year": [1815, 1906, 1912]
})
 
# Create a full name column
df["full_name"] = df.apply(lambda row: f"{row['first_name']} {row['last_name']}", axis=1)
 
# Calculate age (approximate, as of 2026)
df["approx_age"] = df["birth_year"].apply(lambda y: 2026 - y)
 
print(df)
#   first_name last_name  birth_year       full_name  approx_age
# 0        Ada  Lovelace        1815  Ada Lovelace          211
# 1      Grace    Hopper        1906  Grace Hopper          120
# 2       Alan    Turing        1912    Alan Turing          114

Modèles et idiomes Lambda courants

Voici des modèles que vous rencontrerez fréquemment dans du code Python de production :

# 1. Default factory for collections.defaultdict
from collections import defaultdict
 
word_count = defaultdict(lambda: 0)
for word in ["apple", "banana", "apple", "cherry", "banana", "apple"]:
    word_count[word] += 1
print(dict(word_count))
# {'apple': 3, 'banana': 2, 'cherry': 1}
 
# 2. Immediate invocation (IIFE - Immediately Invoked Function Expression)
result = (lambda x, y: x + y)(3, 4)
print(result)
# 7
 
# 3. Lambda as a callback in GUI or event-driven code
# button.on_click(lambda event: print(f"Clicked at {event.x}, {event.y}"))
 
# 4. Using lambda with min/max for custom comparisons
products = [
    ("Laptop", 999),
    ("Mouse", 25),
    ("Keyboard", 75),
    ("Monitor", 450),
]
cheapest = min(products, key=lambda p: p[1])
print(cheapest)
# ('Mouse', 25)
 
# 5. Lambda with conditional expression for data cleaning
clean = lambda s: s.strip().lower() if isinstance(s, str) else s
print(clean("  Hello World  "))
# hello world
print(clean(42))
# 42

Quand NE PAS utiliser Lambda

Les fonctions lambda ont des limites claires. Les utiliser au-delà de ces limites conduit à du code plus difficile à lire, déboguer et maintenir.

Évitez lambda quand :

1. La logique est complexe. Si vous avez besoin de conditions imbriquées, d'opérations multiples ou de toute forme de gestion d'erreurs, utilisez def.

# Bad -- hard to read
process = lambda x: x.strip().lower().replace(" ", "_") if isinstance(x, str) and len(x) > 0 else "empty"
 
# Good -- clear and testable
def process(x):
    """Normalize a string to a snake_case identifier."""
    if not isinstance(x, str) or len(x) == 0:
        return "empty"
    return x.strip().lower().replace(" ", "_")
 
print(process("  Hello World  "))
# hello_world

2. Vous assignez le lambda à une variable pour réutilisation. PEP 8 recommande explicitement d'utiliser def au lieu d'assigner un lambda à un nom. Si la fonction mérite un nom, donnez-lui une définition appropriée.

3. Vous avez besoin d'un docstring ou de type hints. Les fonctions lambda ne supportent ni l'un ni l'autre. Les fonctions nommées si.

4. Le débogage compte. Les fonctions lambda apparaissent comme <lambda> dans les traces, ce qui rend difficile l'identification du lambda qui a causé l'erreur quand vous en avez plusieurs.

5. La lisibilité souffre. Si un collègue a besoin de plus de trois secondes pour comprendre votre lambda, réécrivez-le comme une fonction nommée.

Écrire et refactoriser des fonctions Lambda avec RunCell

Travailler avec des fonctions lambda dans des notebooks Jupyter est courant dans les flux de travail en science des données. Lorsque vous écrivez des appels complexes à pandas apply() ou que vous enchaînez plusieurs opérations map() et filter(), il peut être difficile de savoir si un lambda est le bon outil ou si vous devriez refactoriser vers une fonction nommée.

RunCell (opens in a new tab) est un agent IA conçu pour travailler directement dans les notebooks Jupyter. Il comprend le contexte de votre notebook -- les variables en mémoire, les DataFrames avec lesquels vous travaillez, les imports chargés -- et donne des suggestions ciblées.

Voici comment RunCell aide spécifiquement avec les fonctions lambda :

• Refactorisation lambda vers def. Quand un lambda devient trop long, RunCell peut suggérer une version propre avec def, des type hints et un docstring, en préservant le comportement exact.
• Conseils de performance. Si vous utilisez df.apply(lambda ...) sur un grand DataFrame, RunCell peut suggérer des alternatives vectorisées utilisant des opérations natives pandas ou NumPy qui sont 10 à 100 fois plus rapides.
• Explications en ligne. Vous travaillez avec le code de quelqu'un d'autre plein de lambdas imbriqués ? RunCell peut détailler ce que chaque lambda fait en langage simple, directement dans le notebook.
• Suggestions de modèles. Décrivez ce que vous voulez -- "trier cette liste de dicts par date, puis par nom" -- et RunCell génère l'appel sorted() correct avec la bonne fonction key lambda.

Comme RunCell s'exécute dans votre environnement Jupyter existant, il n'y a pas de changement de contexte. Vous restez dans le notebook et l'agent IA travaille à vos côtés.

FAQ

Qu'est-ce qu'une fonction lambda en Python ?

Une fonction lambda est une petite fonction anonyme définie avec le mot-clé lambda. Elle peut prendre n'importe quel nombre d'arguments mais ne peut contenir qu'une seule expression. Le résultat de l'expression est automatiquement retourné. Les fonctions lambda sont typiquement utilisées pour des opérations courtes et jetables comme les clés de tri, les callbacks map/filter et les transformations en ligne.

Un lambda Python peut-il avoir plusieurs lignes ?

Non. Un lambda Python est restreint à une seule expression. Vous ne pouvez pas utiliser plusieurs instructions, boucles ou affectations dans un lambda. Si vous avez besoin de logique multiligne, utilisez une fonction def régulière. Vous pouvez cependant utiliser une expression conditionnelle (a if condition else b) à l'intérieur d'un lambda pour un branchement simple.

Quelle est la différence entre lambda et def en Python ?

Les deux créent des objets fonction, mais ils diffèrent dans leur portée : lambda crée des fonctions anonymes à expression unique utilisées en ligne, tandis que def crée des fonctions nommées qui peuvent contenir plusieurs instructions, des docstrings, des type hints et des décorateurs. Utilisez lambda pour des opérations simples à usage unique ; utilisez def pour tout ce qui nécessite un nom, de la documentation ou une logique complexe.

Quand devrais-je utiliser lambda au lieu d'une compréhension de liste ?

Utilisez lambda avec map() ou filter() quand l'opération est une transformation ou un prédicat simple et unique. Utilisez les compréhensions de liste quand vous avez besoin à la fois du filtrage et de la transformation en une seule étape, ou quand la logique bénéficie de la structure [expr for x in iterable if condition]. En Python moderne, les compréhensions de liste sont généralement préférées pour la lisibilité, mais lambda est standard pour les clés de tri et les paramètres callback.

Les fonctions lambda Python sont-elles lentes ?

Non. Les fonctions lambda ont les mêmes performances que les fonctions def équivalentes. Le surcoût d'appel de l'une ou l'autre est identique. Cependant, utiliser df.apply(lambda ...) dans pandas est lent comparé aux opérations vectorisées. Le goulot d'étranglement est l'exécution ligne par ligne en Python, pas le lambda lui-même. Chaque fois que possible, remplacez apply(lambda ...) par des méthodes intégrées pandas ou NumPy pour de meilleures performances.

Conclusion

Les fonctions lambda Python remplissent un créneau spécifique : des fonctions courtes et anonymes que vous définissez exactement là où vous en avez besoin. Elles sont à leur meilleur comme clés de tri, callbacks map()/filter() et transformations en ligne. Elles s'associent naturellement avec sorted(), map(), filter(), reduce() et pandas apply().

Les règles pour bien les utiliser sont simples :

• Limitez-les à une expression simple.
• Utilisez-les en ligne, pas assignées à des variables (directive PEP 8).
• Passez à def dès que la logique devient difficile à lire.
• Dans pandas, préférez les opérations vectorisées à apply(lambda ...) pour les performances.
• Utilisez les expressions conditionnelles avec parcimonie -- les ternaires imbriqués dans un lambda sont un piège de lisibilité.

Lambda est un outil, pas un badge d'intelligence. Le meilleur code Python utilise lambda là où il simplifie et def là où il clarifie. Connaître la frontière entre les deux est ce qui sépare le code lisible du code qui fait lutter votre futur vous (ou vos coéquipiers).