Dans ce guide, vous allez explorer les fonctions lambda en Python, en partant de la manière de les définir jusqu’à leurs diverses applications, illustrées par des exemples de code.
Les lambdas en Python sont des fonctions anonymes, caractérisées par une syntaxe concise, souvent utilisées avec d’autres fonctions intégrées. À l’issue de ce tutoriel, vous maîtriserez la définition des fonctions lambda et saurez identifier les situations où elles sont préférables aux fonctions Python conventionnelles.
C’est parti !
Fonctions Lambda en Python : syntaxe et illustrations
La structure générale d’une fonction lambda en Python est la suivante :
lambda paramètre(s): valeur_de_retour
Dans cette syntaxe :
- Le mot-clé `lambda` introduit la fonction, suivi d’un ou plusieurs paramètres qu’elle reçoit.
- Les paramètres et la valeur de retour sont séparés par deux points (`:`).
💡 Lors de la création d’une fonction lambda, assurez-vous que la valeur de retour est le résultat d’une expression simple, tenant sur une seule ligne. Les exemples suivants vous éclaireront davantage.
Exemples de fonctions Lambda en Python
La meilleure manière d’appréhender les fonctions lambda est de les construire à partir de fonctions Python standards.
👩🏽💻 Vous pouvez expérimenter dans un REPL Python ou dans l’éditeur Python en ligne de toptips.fr.
#1. Prenons la fonction `square()`, qui prend un nombre, `num`, et retourne son carré.
def square(num):
return num*numVous pouvez tester son fonctionnement avec différents arguments :
>>> square(9) 81 >>> square(12) 144
Pour une définition plus concise, cette expression lambda peut être assignée à une variable, par exemple `carre1`: `carre1 = lambda num: num*num`. Cependant, les lambdas étant des fonctions anonymes, il est préférable de ne pas les assigner.
Dans la fonction `square()`, `num` est le paramètre et `num*num` est la valeur de retour. On peut donc l’exprimer comme une lambda et l’invoquer avec un argument :
>>> (lambda num: num*num)(2) 4
Il s’agit d’une fonction immédiatement invoquée, appelée juste après sa définition.
#2. Convertissons la fonction `add()`, qui prend deux nombres, `num1` et `num2`, et renvoie leur somme, `num1 + num2`.
def add(num1,num2):
return num1 + num2Testons cette fonction avec quelques exemples :
>>> add(4,3) 7 >>> add(12,5) 17 >>> add(12,6) 18
Ici, `num1` et `num2` sont les paramètres, et la valeur de retour est `num1 + num2`.
>>> (lambda num1, num2: num1 + num2)(3,7) 10
Les fonctions Python peuvent avoir des valeurs par défaut pour leurs paramètres. Modifions la fonction `add()` pour que `num2` ait une valeur par défaut de 10.
def add(num1, num2=10):
return num1 + num2Dans les appels suivants :
- Lors du premier appel, `num1` vaut 1 et `num2` vaut 3, car sa valeur est spécifiée, ce qui donne 4.
- Si seul `num1` (valant 7) est fourni, `num2` prend sa valeur par défaut de 10, et la fonction retourne 17.
>>> add(1,3) 4 >>> add(7) 17
Lors de la transcription en lambda, on peut aussi définir des valeurs par défaut :
>>> (lambda num1, num2 = 10: num1 + num2)(1) 11
Quand privilégier l’usage des fonctions Lambda en Python ?
Maintenant que vous connaissez les bases des fonctions lambda, voici quelques cas d’emploi :
- Si une fonction se réduit à une simple expression de retour sur une ligne, et qu’elle n’est pas appelée ailleurs dans le même module, une fonction lambda est un bon choix. Les exemples précédents l’illustrent.
- Les fonctions lambda sont couramment utilisées avec les fonctions intégrées comme `map()`, `filter()` et `reduce()`.
- Elles sont également très utiles pour personnaliser le tri de structures de données comme les listes et dictionnaires.
Utilisation des fonctions Lambda avec les fonctions intégrées Python
1. Lambda et `map()`
La fonction `map()` applique une fonction à chaque élément d’un itérable :
Prenons une liste de nombres et utilisons `map()` avec une lambda pour générer une nouvelle liste avec les carrés de ces nombres.
>>> nums = [4,5,6,9] >>> list(map(lambda num:num*num,nums)) [16, 25, 36, 81]
Comme `map()` retourne un objet `map`, il faut le convertir en liste.
▶️ Plus d’informations dans ce tutoriel sur la fonction `map()` en Python.
2. Lambda et `filter()`
Définissons la liste de nombres suivante :
>>> nums = [4,5,6,9]
Supposons que l’on souhaite extraire uniquement les nombres impairs de cette liste.
La fonction `filter()` de Python peut être utilisée à cet effet.
`filter()` prend une condition et un itérable : `filter(condition, iterable)`. Le résultat ne contient que les éléments de l’itérable d’origine qui respectent la condition. L’objet renvoyé peut être transformé en une liste.
Pour filtrer et ne garder que les nombres impairs, l’expression lambda sera : `lambda num: num%2!=0`. `num%2` est le reste de la division de `num` par 2.
- `num%2!=0` est vrai si `num` est impair, et
- `num%2!=0` est faux si `num` est pair.
>>> nums = [4,5,6,9] >>> list(filter(lambda num:num%2!=0,nums)) [5, 9]
3. Lambda et `reduce()`
La fonction `reduce()` applique une fonction de manière itérative aux éléments d’un itérable, le réduisant à une seule valeur.
Pour utiliser `reduce()`, il faut l’importer du module `functools` :
>>> from functools import reduce
Utilisons `reduce()` pour calculer la somme des nombres d’une liste. On définit une expression lambda `lambda num1,num2:num1+num2` pour effectuer l’addition.
L’opération de réduction s’effectue comme suit : f(f(f(4,5),6),9) = f(f(9,6),9) = f(15,9) = 24. Ici, `f` est l’opération d’addition définie par la fonction lambda.
>>> from functools import reduce >>> nums = [4,5,6,9] >>> reduce(lambda num1,num2:num1+num2,nums) 24
Fonctions Lambda et tri personnalisé en Python
En plus de `map()`, `filter()` et `reduce()`, les fonctions lambda peuvent être utilisées pour personnaliser le comportement des fonctions et méthodes de tri.
1. Tri des listes Python
Lorsqu’on travaille avec des listes, il est souvent nécessaire de les trier selon des critères spécifiques. La méthode `sort()` permet de trier une liste sur place, et `sorted()` retourne une nouvelle liste triée.
La syntaxe de `sorted()` est la suivante : `sorted(iterable, key=…, reverse=True|False)`. Le paramètre `key` personnalise le tri, et `reverse` définit l’ordre (croissant ou décroissant). Par défaut, `reverse` est `False`.
Le tri par défaut s’effectue par ordre croissant pour les nombres, et alphabétique pour les chaînes. Cependant, il est parfois nécessaire de définir un critère de tri spécifique.
Supposons que l’on souhaite trier la liste de fruits suivante, en fonction du nombre de `p` dans chaque chaîne, par ordre décroissant.
>>> fruits = ['apple','pineapple','grapes','mango']
Il faut utiliser le paramètre optionnel `key`. Les chaînes étant itérables, la méthode `.count()` permet d’obtenir le nombre d’occurrences d’un caractère. On définit donc `key=lambda x:x.count(‘p’)` pour trier en fonction du nombre de `p` dans la chaîne.
>>> fruits = ['apple','pineapple','grapes','mango']
>>> sorted(fruits,key=lambda x:x.count('p'),reverse=True)
['pineapple', 'apple', 'grapes', 'mango']Dans cet exemple :
- La clé de tri est le nombre d’occurrences de `p`, définie par une expression lambda.
- `reverse` étant à `True`, le tri est effectué par ordre décroissant.
`’pineapple’` a trois `p`, `’apple’` en a deux, `’grapes’` un seul, et `’mango’` aucun.
Comprendre le tri stable
Reprenons l’exemple, mais avec une liste légèrement différente, en utilisant le même critère de tri. `apple` et `grapes` contiennent respectivement deux et un `p`, tandis que `mango` et `melon` n’en contiennent aucun.
>>> fruits = ['mango','apple','melon','grapes']
>>> sorted(fruits,key=lambda x:x.count('p'),reverse=True)
['apple', 'grapes', 'mango', 'melon']Pourquoi `’mango’` précède-t-il `’melon’` ? La fonction `sorted()` effectue un tri stable : en cas d’égalité du critère de tri (ici, zéro `p`), l’ordre des éléments dans la liste d’origine est conservé.
Pour vous exercer, inversez les positions de `’mango’` et `’melon’` dans la liste, puis observez le résultat du tri.
▶️ Plus d’informations sur le tri des listes en Python.
2. Tri d’un dictionnaire Python
Les lambdas sont également utiles pour trier des dictionnaires. Prenons l’exemple du dictionnaire `price_dict`, contenant des articles et leurs prix.
>>> price_dict = {
... 'Milk':10,
... 'Honey':15,
... 'Bread':7,
... 'Candy':3
... }Pour obtenir les paires clé-valeur sous forme de liste de tuples, on utilise la méthode `.items()` :
>>> price_dict_items = price_dict.items()
dict_items([('Milk', 10), ('Honey', 15), ('Bread', 7), ('Candy', 3)])En Python, tous les itérables (listes, tuples, chaînes) sont indexés à partir de zéro. L’élément à l’index 0 est le premier, celui à l’index 1 le deuxième, et ainsi de suite.
Pour trier par prix, c’est-à-dire par la valeur de chaque article du dictionnaire, on utilise l’élément à l’index 1 de chaque tuple. On définit donc `key=lambda x:x[1]` pour trier par le prix.
>>> dict(sorted(price_dict_items,key=lambda x:x[1]))
{'Candy': 3, 'Bread': 7, 'Milk': 10, 'Honey': 15}Le dictionnaire est trié par ordre croissant de prix, de `’Candy’` (3) à `’Honey’` (15).
▶️ Pour approfondir, consultez ce guide détaillé sur le tri des dictionnaires en Python par clé et par valeur.
Résumé
Voilà ! Vous savez désormais définir et utiliser efficacement les fonctions lambda avec d’autres fonctions Python intégrées. Voici les principaux points à retenir :
- Les lambdas sont des fonctions anonymes qui peuvent prendre plusieurs arguments et retourner une valeur. L’expression générant cette valeur de retour doit tenir sur une seule ligne. Elles sont utiles pour définir des fonctions courtes de manière plus concise.
- La syntaxe de définition est : `lambda paramètre(s) : valeur_de_retour`.
- Elles sont souvent utilisées avec `map()`, `filter()` et `reduce()`, ainsi que comme paramètre `key` pour personnaliser le tri des itérables.
Ensuite, explorez la division entière en Python.