Fonctions lambda Python : Guide pour débutants

Les fonctions lambda en Python sont des outils puissants et concis permettant de créer à la volée de petites fonctions anonymes. Ils sont particulièrement adaptés pour simplifier les tâches à court terme, rationaliser le code à l'aide de fonctions d'ordre supérieur telles que 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 explore la nature des fonctions lambda, leurs caractéristiques et la manière de les utiliser efficacement.

Dans ce guide, nous vous proposons un guide complet sur les fonctions lambda en Python, couvrant leur mécanisme, 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 dans les paradigmes de programmation fonctionnelle et leur efficacité par rapport aux fonctions standard. Des exemples pratiques et des bonnes pratiques sont inclus pour vous aider à intégrer 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 de plusieurs manières importantes. Il s'agit d'expressions anonymes, ce qui signifie 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 nécessiter d'instruction d'return. Cela les rend idéales pour des opérations simples et ponctuelles, ainsi que pour une utilisation en tant qu'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 :

fn = lambda x, y: x + y
print(fn)

# <function <lambda> at 0xe508b8>

Fonctionnement des fonctions lambda

Comment cette fonction lambda fonctionne-t-elle ? Pour mieux 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.

Maintenant, examinons comment notre fonction lambda accomplit la même tâche.

# Example: add two numbers using a lambda function
fn = lambda x, y: x + y
print(fn)

# <function <lambda> at 0xbfb968>

Le mot-clé lambda indique que nous définissons une fonction lambda, éliminant ainsi le besoin du mot-clé def. À la suite de ce mot-clé d'lambda, les arguments d'entrée x et y sont répertoriés. Après le deux-points, nous indiquons l'expression dont le résultat sera renvoyé, x + y.

Écrire des fonctions Lambda en Python : Exemples

Afin de vous aider à mieux comprendre les concepts abordés jusqu'à présent, examinons quelques exemples illustrant le fonctionnement des fonctions Lambda en Python. 

Guide étape par étape pour la rédaction 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 seule ligne assignée à une variable : is_even = lambda x: x % 2 == 0. 

Ici, la fonction lambda située à droite de l'affectation prend en 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 assignée à la variable is_even, ce qui permet de l'appeler comme une fonction classique. 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 des degrés Celsius en degrés Fahrenheit, vous pouvez utiliser une fonction lambda : c_to_f = lambda c: (c * 9/5) + 32. Vous pouvez ensuite appeler la fonction comme n'importe quelle autre fonction : c_to_f(0).

Cas d'utilisation courants des fonctions lambda

Les fonctions lambda sont fréquemment 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. Veuillez examiner 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 d'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 affichons ensuite la liste des nombres pairs identifiés par la fonction filter.

De même, nous pouvons utiliser la fonction map pour appliquer une fonction lambda à une collection d'éléments. Dans l'exemple ci-dessous, nous calculons la longueur des chaînes d'une liste en appliquant 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 afin de renvoyer une nouvelle collection. 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 souhaitions trier la liste de nombres par valeur absolue. Comment pourrions-nous y parvenir ? La fonction sorted() inclut 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 d'sort() avec une fonction lambda consiste à trier une liste de tuples en fonction 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 les deux sont compilées en un bytecode similaire. Cependant, ils peuvent réduire légèrement la charge dans les cas où la définition d'une fonction complète ajouterait du code standard inutile.

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 équipé d'une puce Apple M1 Pro, de 16 Go de mémoire et fonctionnant sous macOS Sequoia 15.2.

Les fonctions lambda peuvent être utilisées en ligne comme fonctions anonymes lorsqu'elles sont transmises directement à des fonctions d'ordre supérieur telles que map(), filter() ou sorted(). Cela évite d'avoir à définir et à référencer une fonction nommée distincte, ce qui réduit à la fois le code standard et la charge de 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 ponctuelle ou temporaire, car elles éliminent le besoin d'un bloc d'def s 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 contenant un million d'éléments, où les clés sont des codes aléatoires à deux lettres et les valeurs sont 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']

Fonctions lambda Python : Exemples et pratique

Examinons quelques exemples pratiques supplémentaires pour illustrer le fonctionnement des fonctions Lambda en Python. 

Exemples concrets

Les fonctions Lambda sont fréquemment utilisées avec les méthodes intégrées de Python. Par exemple, examinons l'utilisation de 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.

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

Maintenant, examinons 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}.')

# The result of multiplying corresponding elements is [4, 10, 18].

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

Exemple concret : transformation des données

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

Tout d'abord, nous créons quelques enregistrements de ventes. Ensuite, nous utilisons 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, garantissant que toutes ses clés et valeurs sont conservées dans le nouveau dictionnaire. Enfin, nous imprimons chaque enregistrement des données transformées.

# 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},
]

# 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
	)
)

# 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 que les utilisateurs peuvent résoudre à l'aide de fonctions lambda

Si vous souhaitez vous exercer à utiliser les fonctions lambda, voici quelques problèmes à résoudre.

• À partir d'un nombre, veuillez déterminer son carré.
• Étant donné deux nombres, veuillez déterminer lequel est le plus grand.
• Veuillez vérifier si un nombre donné est impair.
• Étant donné une liste d'entiers positifs, veuillez filtrer tous les nombres impairs.
• Trier une liste de triplets en utilisant leur troisième élément.
• Veuillez extraire le domaine d'une adresse e-mail. Par exemple, étant donné user@example.com, veuillez extraire example.com.

Erreurs courantes liées à lambda

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

1. La première erreur consiste à utiliser une fonction lambda dans des circonstances inappropriées. Il est important de garder à l'esprit que les fonctions lambda sont conçues pour des tâches courtes et simples, et non pour gérer des logiques complexes. Par exemple, l'extrait de code suivant ne constitue 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 simplement 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 courante consiste à confondre la syntaxe. Par exemple, omettre le mot-clé lambda entraînera une erreur. Une autre erreur syntaxique courante consiste à omettre le ou les arguments 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)

Une méthode efficace pour détecter ce type d'erreurs consiste à inclure des cas de test informels et simples lors du développement.

print(list(squared))

3. Une autre erreur à éviter consiste à ne pas inclure de logique pour les cas limites. Par exemple, ce code échoue lorsque y est égal à 0. La solution consiste à inclure une simple instruction if pour détecter le cas problématique ou à encapsuler le code dans un bloc d'exception.

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

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. Pour accéder aux résultats, veuillez convertir l'objet map en un objet list.

# 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

# <map object at 0x106d2b0>

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

# [1, 4, 9]

Stratégies de débogage Python Lambda

Comment pouvons-nous procéder pour déboguer les lambdas ? Voici quelques possibilités.

• Décomposez l'. Veuillez le convertir temporairement en une fonction nommée à des fins de débogage.
• Veuillez utiliser des instructions d'impression pour afficher les valeurs intermédiaires dans les fonctions d'ordre supérieur telles que map() ou filter().
• Veuillez tester les cas limites. Effectuez des tests avec des valeurs extrêmes, non valides ou limites afin de détecter les erreurs potentielles.

Une astuce utile pour imprimer les étapes intermédiaires consiste à inclure une instruction print dans un tuple à côté du résultat. Le résultat souhaité peut ensuite être transmis à la fonction d'ordre supérieur en indexant le tuple à la position 1.

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 afficher 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 instruction d'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. 

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

La conversion de l'objet filter en liste force l'évaluation de tous les éléments, déclenchant les instructions print pour chaque nombre. Cette approche facilite le débogage de la logique tout en conservant la fonctionnalité de l'opération de filtrage.

Meilleures pratiques pour l'utilisation des fonctions Lambda

Les meilleures pratiques pour l'utilisation des fonctions lambda impliquent de comprendre quand elles sont appropriées et quand elles doivent être évitées.

Quand utiliser les fonctions Lambda

• , une logique simple et concise. Idéal pour les opérations concises qui ne nécessitent pas une définition complète des fonctions.
• Fonctions d'ordre supérieur. Fonctionnent efficacement comme arguments pour 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 avec def encombrerait inutilement le code.
• Amélioration de la lisibilité. Convient aux tâches simples où l'utilisation d'une fonction lambda permet de conserver un code compact et facile à suivre.

Quand éviter les fonctions Lambda

• logiques complexes ou multilignes. 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 si un nom descriptif est souhaitable, une fonction standard d'def est plus appropriée.
• Débogage ou documentation. Les fonctions lambda ne permettent pas d'inclure des chaînes de 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, veuillez suivre ces bonnes pratiques :

• Veuillez utiliser des noms descriptifs pour plus de clarté.
• Simplifiez-vous la vie: Les lambdas devraient idéalement tenir sur une seule ligne et représenter une logique simple.
• Limite d'imbrication de l': Veuillez éviter d'utiliser des fonctions lambda au sein d'autres fonctions lambda ou de structures de données complexes, sauf si cela est nécessaire.
• Veuillez privilégier la lisibilité à la concision.: Si l'utilisation d'une fonction lambda nuit à la lisibilité, il est préférable de définir une fonction nommée.

Conclusion

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

Cependant, il convient de les utiliser avec discernement, car une logique plus complexe convient mieux aux fonctions standard définies avec def. En comprenant leurs points forts, leurs limites et les meilleures pratiques, vous pouvez exploiter efficacement les fonctions lambda pour écrire un code Python propre, efficace et facile à maintenir.

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

• Fonctions Python : Comment appeler et écrire des fonctions
• Cours sur l'écriture de fonctions en Python
• Notions fondamentales sur les données Python
• Principes fondamentaux de la programmation Python
• Cours Python intermédiaire pour développeurs