Accéder au contenu principal

Les fonctions Lambda de Python : Guide du débutant

Découvrez les fonctions lambda de Python, leur utilité et quand les utiliser. Il comprend des exemples concrets et des bonnes pratiques pour une mise en œuvre efficace.
Actualisé 31 janv. 2025  · 10 min de lecture

Les fonctions lambda en Python sont des outils puissants et concis permettant de créer à la volée de petites fonctions anonymes. Ils sont parfaits pour simplifier les tâches à court terme, rationaliser le code avec des fonctions d'ordre supérieur comme map, filter, ou sorted, et réduire l'encombrement lors de la définition d'une logique temporaire ou jetable. Ils offrent également une solution élégante pour améliorer la lisibilité du code dans des scénarios simples. Cet article examine ce que sont les fonctions lambda, leurs caractéristiques et la manière de les utiliser efficacement.

Dans ce guide, nous vous proposons un guide complet des fonctions lambda en Python, couvrant leur mécanique, leur syntaxe et leur comparaison avec les fonctions standard, avec des exemples simples pour illustrer les concepts clés.Nous explorons les cas d'utilisation courants, tels que l'utilisation des fonctions lambda au sein des paradigmes de programmation fonctionnelle et leur efficacité par rapport aux fonctions standard.... Des exemples pratiques et des bonnes pratiques sont inclus pour vous aider à incorporer efficacement les fonctions lambda dans votre programmation Python.

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

Les fonctions lambda diffèrent des fonctions Python standard sur plusieurs points essentiels. Ce sont des expressions anonymes, c'est-à-dire qu'elles n'ont pas de nom à moins d'être explicitement assignées à une variable. Ils sont également plus concis et définis en une seule ligne, sans qu'il soit nécessaire d'ajouter une déclaration à l'adresse return. Elles sont donc idéales pour des opérations simples et uniques et pour être utilisées comme arguments en ligne dans des fonctions d'ordre supérieur telles que map, filter et sorted.

Voici un exemple de fonction lambda qui additionne deux nombres :

lambda x, y: x + y

    (x, y)>

Fonctionnement des fonctions lambda

Comment fonctionne cette fonction lambda ? Pour le comprendre, comparons-le à une fonction Python standard.

# Example: add two numbers using standard Python function
def add_numbers(x, y):
    return x + y

Cette fonction standard est simple. Le mot-clé def définit la fonction, qui prend deux arguments, x et y. Il calcule la somme de x et y et renvoie le résultat.

Voyons maintenant comment notre fonction lambda accomplit la même tâche.

# Example: add two numbers using a lambda function
lambda x, y: x + y

    (x, y)>

Le mot-clé lambda signifie que nous définissons une fonction lambda, ce qui rend inutile le mot-clé def. Après le mot-clé lambda, les arguments d'entrée x et y sont énumérés. Après les deux points, nous spécifions l'expression dont le résultat sera retourné, x + y.

Écrire des fonctions Lambda en Python : Exemples

Pour vous aider à vous familiariser avec les concepts que nous avons explorés jusqu'à présent, examinons quelques exemples de fonctionnement des fonctions Lambda en Python. 

Guide pas à pas pour l'écriture de fonctions lambda

Les fonctions lambda sont idéales pour créer des fonctions courtes et simples, sans complexité supplémentaire. 

Par exemple, supposons que vous souhaitiez vérifier si un entier non nul donné est pair. Vous pourriez écrire une fonction Python standard, mais la même fonctionnalité peut être obtenue avec une fonction lambda concise d'une ligne assignée à une variable : is_even = lambda x: x % 2 == 0

Ici, la fonction lambda du côté droit de l'affectation prend une entrée x et renvoie True si x est pair (c'est-à-dire si le reste de la division par 2 est égal à 0). 

Cette fonction lambda est ensuite affectée à la variable is_even, ce qui permet de l'appeler comme une fonction normale. Par exemple, is_even(5) (renvoie à False) et is_even(678432) (renvoie à True).

Les fonctions lambda sont également très utiles pour définir des formules simples. Par exemple, pour convertir les degrés Celsius en degrés Fahrenheit, vous pouvez utiliser une fonction lambda : c_to_f = lambda c: (c * 9/5) + 32. Vous appelez ensuite la fonction comme n'importe quelle autre fonction : c_to_f(0).

Cas d'utilisation courants des fonctions lambda

Les fonctions lambda sont souvent utilisées dans la programmation fonctionnelleLes fonctions lambda sont souvent utilisées dans la programmation fonctionnelle, en particulier avec des fonctions telles que map() et filter(), qui prennent d'autres fonctions comme arguments pour traiter les éléments d'une collection. Voyons comment utiliser une fonction lambda avec filter(). Voici un extrait de code :

# Use filter with lambda function
numbers = [1, 2, 3, 4, 5, 6, 7, 8]
evens = filter(lambda x: x % 2 == 0, numbers)
print(list(evens))  # print the list of the filter object to see the result

    [2, 4, 6, 8]

Dans ce code, nous commençons par définir un ensemble de numbers. Ensuite, nous créons une fonction lambda pour vérifier si un nombre est pair. La fonction filter applique cette fonction lambda à l'ensemble numbers. Nous imprimons ensuite la liste des nombres pairs identifiés par la fonction filter.

De même, nous pouvons utiliser la fonction map pour appliquer un lambda à une collection d'éléments. Dans l'exemple ci-dessous, nous calculons la longueur des chaînes de caractères d'une liste en associant la fonction len() à chaque élément.

# Use map with lambda function
fruits = ['apple', 'banana', 'cherry']
lengths = list(map(lambda x: len(x), fruits))
print(lengths)

    [5, 6, 6]

Les fonctions lambda sont également utilisées avec la fonction sorted(), qui trie les éléments d'une collection pour en renvoyer une nouvelle. Dans l'exemple suivant (sans lambda), nous utilisons la fonction sorted() pour trier une liste de nombres.

numbers = [1, 10, -1, 3, -10, 5]
sorted_stuff = sorted(numbers)
print(sorted_stuff)

    [-10, -1, 1, 3, 5, 10]

Supposons que nous voulions trier la liste des nombres par valeur absolue. Comment y parvenir ? La fonction sorted() comprend un argument key qui nous permet de personnaliser l'ordre de tri en fournissant une fonction lambda.

# Sort according to absolute value
sorted_numbers_absolute = sorted(numbers, key=lambda x: abs(x))
print(sorted_numbers_absolute)

    [1, -1, 3, 5, 10, -10]

Un autre cas d'utilisation de sort() avec une fonction lambda consiste à trier une liste de tuples sur la base d'un élément spécifique, par exemple le deuxième.

# Sort a list of tuples by the second element
data = [(1, 3), (2, 1), (4, 2)]
sorted_data = sorted(data, key=lambda x: x[1])
print(sorted_data)

    [(2, 1), (4, 2), (1, 3)]

Dans cet extrait de code, nous définissons data comme une liste de tuples. Nous utilisons ensuite la fonction sorted() avec le paramètre key, où une fonction lambda extrait le deuxième élément de chaque tuple pour le tri.

Les fonctions Lambda sont-elles plus rapides en Python ?

En Python, les fonctions lambda ne sont pas intrinsèquement plus rapides que les fonctions standard, car elles sont toutes deux compilées en un bytecode similaire. Toutefois, elles peuvent réduire légèrement la charge de travail dans les cas où la définition d'une fonction complète ajouterait des éléments superflus.

Voici quelques cas de test comparant les fonctions lambda aux fonctions Python standard. Le code a été exécuté sur mon ordinateur portable, un MacBook Pro avec une puce Apple M1 Pro, 16 Go de mémoire, fonctionnant sous macOS Sequoia 15.2.

Les fonctions lambda peuvent être utilisées en ligne en tant que fonctions anonymes lorsqu'elles sont transmises directement à des fonctions d'ordre supérieur telles que map(), filter() ou sorted(). Il n'est donc pas nécessaire de définir et de référencer une fonction nommée distincte, ce qui permet de réduire à la fois le code de base et la charge de travail liée à la recherche.

import time

numbers = list(range(1, 1000000))

# Standard function
def double_standard(x):
    return x * 2

start = time.time()
map(double_standard, numbers)
print(time.time() - start)

# Lambda function
double_lambda = map(lambda x: x * 2, numbers)

start = time.time()
list(map(lambda x: x * 2, numbers))
print(time.time() - start)

    3.504753112792969e-05

    2.384185791015625e-05

Les fonctions Lambda sont idéales pour une utilisation unique ou temporaire, car elles éliminent la nécessité d'un bloc def formel, ce qui permet de gagner du temps et de l'espace. Dans le bloc de code suivant, nous comparons les performances d'une fonction standard à celles d'une fonction lambda. Nous trions un dictionnaire d'un million d'éléments, dont les clés sont des codes aléatoires à deux lettres et les valeurs des nombres entiers aléatoires.

import random
import string

# Generate a dictionary with elements of the form 'XX': number.
NUMBER_ITEMS = 1000000
items = {
    ''.join(random.choices(string.ascii_uppercase, k=2)): random.randint(1, 100)
    for _ in range(NUMBER_ITEMS)
}

# Standard function (extra definition step)
def sort_standard(item):
    return item[1]

print('Standard')
start = time.time()
sorted_items_standard = sorted(items, key=sort_standard)
print(time.time() - start)
print(sorted_items_standard[:5])
print()

# Lambda function
print('Lambda')
start = time.time()
sorted_items_lambda = sorted(items, key=lambda x: x[1])
print(time.time() - start)
print(sorted_items_lambda[:5])
print()

    Standard

    0.00011610984802246094

    ['OA', 'VA', 'XA', 'IA', 'BA']

    

    Lambda

    0.00011014938354492188

    ['OA', 'VA', 'XA', 'IA', 'BA']

Les fonctions Lambda de Python : Exemples et pratiques

Travaillons sur des exemples plus pratiques pour présenter le fonctionnement des fonctions Lambda en Python. 

Exemples pratiques

Les fonctions lambda sont souvent utilisées avec les méthodes intégrées de Python. Par exemple, utilisons reduce() pour appliquer une fonction binaire définie par l'utilisateur de manière cumulative aux éléments d'une séquence.

# Example: Use lambda function with built-in Python method reduce.
from functools import reduce

numbers = [5, -6, 2, 7]
total = reduce(lambda x, y: x + y, numbers)
print(f'The sum of the numbers is {total}.')

    The sum of the numbers is 8.

Comme filter() ou map() ci-dessus, reduce() applique une fonction, ici donnée par un lambda, à un ensemble d'éléments.

Explorons maintenant une autre fonction intégrée de Python, zip(). La fonction zip associe les éléments correspondants de plusieurs listes en tuples. Par exemple, le résultat de zip(['a', 'b', 'c'], [1, 2, 3]) est [('a', 1), ('b', 2), ('c', 3)].

# Example: Use lambda function with built-in Python method zip.
list1 = [1, 2, 3]
list2 = [4, 5, 6]

# Using zip and a lambda function to multiply corresponding elements
result = list(map(lambda x: x[0] * x[1], zip(list1, list2)))

print(f'The result of multiplying corresponding elements is {result}.')

Le résultat de la multiplication des éléments correspondants est [4, 10, 18].

Ce code calcule le produit des éléments correspondants de deux listes, list1 et list2. Il utilise zip() pour coupler les éléments des listes en tuples, puis applique une fonction lambda avec map() pour multiplier les éléments couplés, et enfin convertit le résultat en une liste.

Exemple concret : transformation des données

Imaginons que vous teniez un stand de fruits et que vous souhaitiez calculer le montant total des ventes pour chaque type de fruit.

Commençons par créer quelques enregistrements de vente.

# Sample data: list of dictionaries representing sales records
sales_data = [
    {'fruit': 'peaches', 'price': 1.41, 'quantity': 3},
    {'fruit': 'pears', 'price': 1.21, 'quantity': 2},
    {'fruit': 'mangoes', 'price': 0.56, 'quantity': 3},
]

Nous utilisons maintenant map() avec une fonction lambda pour calculer total_sales en multipliant le prix et la quantité de chaque article dans le dictionnaire sales_data. La syntaxe **record décompresse le dictionnaire d'origine, en veillant à ce que toutes ses clés et valeurs soient conservées dans le nouveau dictionnaire.

# Using a lambda function to calculate total sales for each record
transformed_data = list(
                        map(
                            lambda entry: {**entry, 'total_sales': round(entry['price'] * entry['quantity'], 2)},
                            sales_data
                        )
                    )

Enfin, nous imprimons chaque enregistrement des données transformées.

# Print the transformed data
for record in transformed_data:
    print(record)

    {'fruit': 'peaches', 'price': 1.41, 'quantity': 3, 'total_sales': 4.23}

    {'fruit': 'pears', 'price': 1.21, 'quantity': 2, 'total_sales': 2.42}

    {'fruit': 'mangoes', 'price': 0.56, 'quantity': 3, 'total_sales': 1.68}

Problèmes simples à résoudre par les utilisateurs à l'aide de fonctions lambda

Si vous souhaitez vous exercer à l'utilisation des fonctions lambda, voici quelques problèmes à essayer.

  • Trouvez le carré d'un nombre donné.
  • Si deux nombres sont donnés, trouvez le plus grand.
  • A partir d'un nombre donné, vérifiez s'il est impair.
  • Étant donné une liste d'entiers positifs, filtrez tous les nombres impairs.
  • Trier une liste de tuples à trois éléments en utilisant leurs troisièmes éléments.
  • Extraire le domaine d'une adresse électronique. Par exemple, étant donné user@example.com, extrayez example.com.

Erreurs courantes liées à l'utilisation de lambda

Examinons quelques erreurs courantes commises par les programmeurs avec les lambdas et quelques solutions.

1. La première erreur consiste à utiliser une fonction lambda lorsqu'elle n'est pas appropriée. Il est important de se rappeler que les fonctions lambda sont conçues pour des tâches courtes et simples, et non pour gérer une logique complexe. Par exemple, l'extrait de code suivant n'est pas un cas d'utilisation idéal pour une fonction lambda.

# Complex logic in a lambda
result = lambda x: (x ** 2 + x - 1) / (x + 1 if x != -1 else 1)
print(result(5))  # Hard to understand

    4.833333333333333

Dans ce cas, il est préférable d'utiliser une fonction Python standard.

def complex_logic(x):
    if x == -1:
        return x ** 2 + x - 1
    return (x ** 2 + x - 1) / (x + 1)
print(complex_logic(5))

    4.833333333333333

2. Une autre erreur simple à commettre est de confondre la syntaxe. Par exemple, l'oubli du mot-clé lambda entraînera une erreur. Une autre erreur de syntaxe courante consiste à omettre le(s) argument(s) d'entrée :

# Forgetting the required arguments
numbers = [1, 2, 3, 4]
squared = map(lambda: x ** 2, numbers)  # <-- Where is the input argument? Error: lambda missing argument

La solution consiste à inclure l'argument d'entrée :

squared = map(lambda x: x ** 2, numbers)

Un bon moyen d'éviter ce genre d'erreurs est d'inclure des cas de test simples et informels lors du développement.

print(list(squared))

    [1, 4, 9, 16]

3. Une autre erreur à ne pas commettre est de ne pas prévoir de logique pour les cas extrêmes. Par exemple, ce code échoue lorsque y vaut 0.

# Dividing without handling zero
divide = lambda x, y: x / y

La solution consiste à inclure une simple déclaration if pour attraper le cas incriminé ou à envelopper le code dans un bloc d'exception.

safe_divide = lambda x, y: x / y if y != 0 else "undefined"
print(safe_divide(5, 0))

    undefined

4. Un problème plus subtil consiste à oublier de convertir l'itérateur en liste lors de la sortie des résultats. Par exemple, la fonction map() renvoie un objet map, et non une liste.

# Forgetting to convert to a list
numbers = [1, 2, 3]
squared = map(lambda x: x ** 2, numbers)
print(squared)  # <-- squared is the map, not the result

    

Pour accéder aux résultats, convertissez l'objet map en un objet list.

print(list(squared))  # list(squared) gives the result

    [1, 4, 9]

Stratégies de débogage des lambdas Python

Alors, comment déboguer les lambdas ? Voici quelques possibilités.

  • Décomposez le lambda. Convertissez-la temporairement en une fonction nommée à des fins de débogage.
  • Utilisez les instructions print pour afficher les valeurs intermédiaires dans les fonctions d'ordre supérieur telles que map() ou filter().
  • Cas limites de test. Testez avec des valeurs extrêmes, invalides ou limites pour détecter les erreurs potentielles.

Une astuce utile pour imprimer les étapes intermédiaires consiste à inclure une déclaration print à l'intérieur d'un tuple à côté du résultat. La sortie souhaitée peut alors être transmise à la fonction d'ordre supérieur en indexant le tuple à la position 1. 

En voici un exemple :

numbers = [1, 2, 3, 4, 5]

# Lambda function with print to debug intermediate values
filtered_numbers = filter(lambda x: (print(f'Checking: {x} -> {x >= 3}'), x >= 3)[1], numbers)

# Converting filter object to list to force evaluation
print(list(filtered_numbers))

    Checking: 1 -> False

    Checking: 2 -> False

    Checking: 3 -> True

    Checking: 4 -> True

    Checking: 5 -> True

    [3, 4, 5]

Dans ce code, une astuce est utilisée pour imprimer les étapes intermédiaires lors du filtrage d'une liste de nombres. La fonction lambda dans filter comprend un tuple : le premier élément est une déclaration print qui enregistre le nombre actuel et indique s'il satisfait à la condition (x >= 3), et le deuxième élément est la condition elle-même. 

Le [1] à la fin de la lambda garantit que la condition (x >= 3) est renvoyée à la fonction filter tout en permettant à l'instruction print de s'exécuter à des fins de débogage. 

La conversion de l'objet filter en liste force l'évaluation de tous les éléments, ce qui déclenche les instructions print pour chaque nombre. Cette approche permet de déboguer la logique tout en maintenant la fonctionnalité de l'opération de filtrage.

Meilleures pratiques pour l'utilisation des fonctions Lambda

Les meilleures pratiques en matière d'utilisation des fonctions lambda consistent à comprendre quand elles sont appropriées et quand elles doivent être évitées.

Quand utiliser les fonctions Lambda

  • Logique courte et simple. Idéal pour les opérations concises qui ne nécessitent pas une définition complète de la fonction.
  • Fonctions d'ordre supérieur. Ils peuvent servir d'arguments à des fonctions d'ordre supérieur telles que map(), filter() ou sorted().
  • Fonctions temporaires (jetables). Utile lorsqu'une fonction n'est nécessaire qu'une seule fois et que sa définition à l'aide de def encombrerait inutilement le code.
  • Amélioration de la lisibilité. Elle convient aux tâches simples pour lesquelles l'utilisation d'une fonction lambda permet de conserver un code compact et facile à suivre.

Quand éviter les fonctions Lambda

  • Logique complexe ou multiligne. Les lambdas sont limités à une seule expression et peuvent rapidement devenir illisibles pour des opérations plus complexes.
  • Fonctions réutilisables ou nommées. Si la fonction doit être réutilisée ou bénéficier d'un nom descriptif, une fonction standard def est plus appropriée.
  • Débogage ou documentation. Les fonctions lambda n'ont pas la possibilité d'inclure une documentation et peuvent être plus difficiles à déboguer que les fonctions nommées.

Pour améliorer la lisibilité et la maintenabilité lors de l'utilisation des lambdas, suivez ces bonnes pratiques :

  • Utilisez des noms descriptifs pour plus de clarté.
  • Restez simple: Les lambdas doivent idéalement tenir sur une ligne et représenter une logique simple.
  • Limiter l'imbrication: Évitez d'utiliser des fonctions lambda à l'intérieur d'autres fonctions lambda ou de structures de données complexes, sauf en cas de nécessité.
  • Préférez la lisibilité à la concision: Si l'utilisation d'un lambda sacrifie la lisibilité, il est préférable de définir une fonction nommée.

Conclusion

Les fonctions lambda de Python sont un outil puissant pour écrire des fonctions concises et anonymes. Ils se distinguent dans les scénarios nécessitant des opérations courtes, temporaires ou en ligne, en particulier lorsqu'ils sont utilisés avec des fonctions d'ordre supérieur telles que map, filter ou sorted

Il convient toutefois de les utiliser à bon escient, car les fonctions standard définies à l'aide de def conviennent mieux à une logique plus complexe. En comprenant leurs forces, leurs limites et les meilleures pratiques, vous pouvez exploiter efficacement les fonctions lambda pour écrire du code Python propre, efficace et facile à maintenir.

Pour en savoir plus sur les fonctions Python, consultez les ressources de DataCamp.

FAQ sur les fonctions Lambda de Python

Pourquoi utiliser une fonction lambda ?

Ils sont parfaits pour simplifier les tâches à court terme, rationaliser le code avec des fonctions d'ordre supérieur comme map, filter, ou sorted, et réduire l'encombrement lors de la définition d'une logique temporaire ou jetable.

Quand dois-je utiliser des fonctions lambda ?

Les fonctions lambda sont appropriées pour : une logique courte et simple, adaptée aux lignes uniques, comme arguments de fonctions d'ordre supérieur, telles que map() ou filter(), et pour les fonctions temporaires qui ne sont utilisées qu'une seule fois.

Quand dois-je éviter les fonctions lambda ?

Les fonctions lambda peuvent ne pas être le meilleur choix pour une logique complexe ou des fonctions qui nécessitent une documentation (comme les docstrings).


Mark Pedigo's photo
Author
Mark Pedigo
LinkedIn

Mark Pedigo, PhD, est un éminent scientifique des données, spécialisé dans la science des données de santé, la programmation et l'éducation. Titulaire d'un doctorat en mathématiques, d'une licence en informatique et d'un certificat professionnel en intelligence artificielle, Mark allie connaissances techniques et résolution de problèmes pratiques. Au cours de sa carrière, il a joué un rôle dans la détection des fraudes, la prédiction de la mortalité infantile et les prévisions financières, et a contribué au logiciel d'estimation des coûts de la NASA. En tant qu'éducateur, il a enseigné à DataCamp et à l'université Washington de St. Louis et a encadré des programmeurs juniors. Pendant son temps libre, Mark profite de la nature du Minnesota avec sa femme Mandy et son chien Harley, et joue du piano jazz.

Sujets

Les meilleurs cours de DataCamp

cursus

Principes de base des données en Python

28 heures hr
Développez vos compétences en matière de données, découvrez comment manipuler et visualiser les données, et appliquez des analyses avancées pour prendre des décisions basées sur les données.
Afficher les détailsRight Arrow
Commencer le cours
Certification disponible

cours

Écrire des fonctions en Python

4 hr
93.8K
Apprenez à utiliser les meilleures pratiques pour écrire des fonctions complexes, réutilisables et faciles à maintenir, avec une bonne documentation.
Voir plusRight Arrow