Ce guide vous initiera à l’utilisation de la fonction `map()` en Python pour appliquer une opération à chaque élément d’une structure itérable.
Python supporte la programmation fonctionnelle, un paradigme où les tâches sont définies comme des calculs de fonctions. En Python, les fonctions sont traitées comme des objets, pouvant être passées en arguments à d’autres fonctions et retournées comme résultats.
La fonction `map()` accepte une fonction en tant qu’argument, permettant son application à tous les éléments d’une séquence.
À l’issue de ce tutoriel, vous maîtriserez l’emploi de la fonction `map()` de Python, notamment pour simplifier les boucles et les listes en compréhension. Plusieurs exemples seront codés pour illustrer les différentes manières d’utiliser cette fonction.
Appliquer une fonction à des éléments d’une liste en Python
Débutons avec un exemple concret. 👩🏫
Soit `nums` une liste de nombres :
nums = [2,4,3,7]
Considérons maintenant la fonction `self_pow()`. Elle prend un nombre comme paramètre et retourne ce nombre élevé à sa propre puissance (n**n).
En Python, `**` est l’opérateur d’exponentiation. `a**b` retourne la valeur de a élevée à la puissance b, soit ab.
def self_pow(n): return n**n
Objectif : Créer une nouvelle liste `nums_pow` en appliquant `self_pow()` à chaque élément de la liste `nums`.
Utilisation de la boucle `for`
Pour cela, les boucles `for` en Python sont une option :
- Pour chaque nombre dans `nums`, invoquer `self_pow()` avec ce nombre comme argument.
- Ajouter le résultat de chaque appel à la nouvelle liste `nums_pow`.
nums_pow = [] for num in nums: nums_pow.append(self_pow(num)) print(nums_pow)
Le résultat affiche chaque nombre de `nums` élevé à sa propre puissance. Les éléments de `nums_pow` sont : 2², 4⁴, 3³, 7⁷.
Output [4, 256, 27, 823543]
Utilisation de la compréhension de liste
La compréhension de liste permet une écriture plus concise. À partir de la boucle `for` précédente, nous pouvons identifier l’expression de sortie et la liste à itérer.
L’expression générique de la compréhension de liste est :
new_list = [<expression de sortie> for item in iterable]
Pour générer `nums_pow`, l’expression de compréhension de liste est :
nums_pow = [self_pow(num) for num in nums] print(nums_pow)
Le résultat est identique à celui obtenu avec la boucle `for`, comme attendu.
Output [4, 256, 27, 823543]
Plutôt que les boucles et les listes en compréhension, `map()` offre une syntaxe plus concise pour appliquer une fonction à tous les éléments d’un itérable. Examinons la syntaxe de cette fonction.
Syntaxe de la fonction `map()` en Python
La syntaxe générale de la fonction `map()` est :
map(fonction, iterable_1,[iterable_2,...,iterable_n])
La fonction `map()` prend au minimum deux arguments : une fonction et un itérable.
Dans la syntaxe ci-dessus :
- `fonction` désigne une fonction Python, qu’elle soit définie par l’utilisateur, intégrée ou même une méthode de classe ou d’instance, etc.
- `iterable` représente n’importe quel itérable valide en Python : une liste, un tuple, une chaîne, etc.
- `map()` applique la `fonction` à chaque élément de l’`iterable`.
Que retourne `map()` ?
Elle retourne un objet map. Cet objet peut être converti en liste en utilisant `list(map(fonction,iterable))`.
Selon les besoins, il peut également être converti en tuple.
Maintenant que nous connaissons la syntaxe de `map()`, passons à des exemples concrets.
Ce tutoriel nécessite Python 3.x. Vous pouvez également exécuter les extraits de code dans un éditeur Python en ligne.
Utiliser `map()` avec des fonctions définies par l’utilisateur
#1. Auparavant, nous avons appliqué `self_pow()` à chaque élément de la liste `nums`. Avec `map()`, nous passons simplement la fonction `self_pow` et la liste `nums` comme arguments.
Note : Spécifiez uniquement le nom de la fonction, et non un appel de fonction. Utilisez `self_pow`, et non `self_pow()`.
`map()` retourne un objet map.
print(map(self_pow,nums)) <map object at 0x7f7d315c14d0>
Transformons cet objet map en une liste en utilisant `list()` :
nums_pow = list(map(self_pow,nums)) print(nums_pow)
Voici le résultat, où chaque élément de `nums` est élevé à sa propre puissance et stocké dans `nums_pow`.
Output [4, 256, 27, 823543]
#2. La fonction suivante, `inch_to_cm()`, convertit les pouces en centimètres (1 pouce = 2,54 cm) :
def inch_to_cm(inch): return inch*2.54
Pour convertir une liste de valeurs en pouces en centimètres, utilisons `map()` comme ci-dessous :
inches = [5.54,3.4,1,25,8.2] cms = list(map(inch_to_cm,inches)) print(cms)
La liste `cms` contient les valeurs en pouces converties en centimètres.
Output [14.0716, 8.636, 2.54, 63.5, 20.828]
Utiliser `map()` avec des fonctions intégrées
Cette section explore l’utilisation de `map()` avec les fonctions natives de Python.
#1. Soit une liste de chaînes de caractères, représentant des langages de programmation. Pour créer une liste `strings_upper` contenant ces langages en majuscules :
strings = ['JavaScript','Rust','Python','Go']
La méthode de chaîne intégrée `.upper()` retourne une copie de la chaîne, transformée en majuscules.
strings_upper = list(map(str.upper,strings)) print(strings_upper)
La liste `strings_upper` contient les chaînes de `strings`, converties en majuscules.
Output ['JAVASCRIPT', 'RUST', 'PYTHON', 'GO']
#2. La fonction native `len()` de Python retourne la longueur d’une séquence. Pour obtenir la longueur de chaque chaîne dans `strings`, appliquons la fonction `len()` avec `map()` :
strings_len = list(map(len,strings)) print(strings_len)
Output [10, 4, 6, 2]
#3. `map()` fonctionne aussi avec d’autres collections, comme les tuples.
L’exemple suivant montre un tuple contenant des informations sur une maison (nombre de pièces, superficie et ville).
En Python, `type()` renvoie le type de données d’un objet. Pour obtenir le type de chaque élément du tuple, utilisez `map()` avec la fonction `type` :
house = (2,758.5,'Bangalore') house_elt_type = tuple(map(type,house)) print(house_elt_type)
Nous avons converti l’objet map en tuple. Il est aussi possible de le transformer en liste.
Le résultat indique que les types de données de 2, 758.5 et Bangalore sont respectivement `int`, `float` et `str`.
Output (<class 'int'>, <class 'float'>, <class 'str'>)
#4. En Python, vous pouvez importer des modules et utiliser les fonctions qu’ils contiennent.
Pour calculer la racine carrée de chaque nombre d’une liste, utilisez la fonction `sqrt` du module `math` :
import math nums = [30,90,34,45,97] nums_sqrt = list(map(math.sqrt,nums)) print(nums_sqrt)
Output [5.477225575051661, 9.486832980505138, 5.830951894845301, 6.708203932499369, 9.848857801796104]
Ce résultat est difficile à lire. Arrondissons chaque racine carrée à deux décimales.
Arrondir un nombre à virgule flottante en Python
Définissons une fonction `round_2()` qui prend un nombre à virgule flottante et l’arrondit à deux décimales :
def round_2(num): return round(num,2)
Maintenant, utilisez `map()` avec les listes `round_2` et `nums_sqrt` :
nums_sqrt_round = list(map(round_2,nums_sqrt)) print(nums_sqrt_round)
Output [5.48, 9.49, 5.83, 6.71, 9.85]
Il est également possible d’imbriquer des fonctions `map()`. La fonction `map()` interne calcule la racine carrée, et la fonction externe arrondit le résultat :
nums_sqrt_round = list(map(round_2,list(map(math.sqrt,nums)))) print(nums_sqrt_round)
Output [5.48, 9.49, 5.83, 6.71, 9.85]
Les deux approches donnent le même résultat. Cependant, assurez-vous que le code reste lisible et maintenable lors de l’imbrication de fonctions.
Utiliser `map()` avec des fonctions lambda
Nous avons vu comment utiliser `map()` avec des fonctions définies par l’utilisateur et des fonctions intégrées. Voyons maintenant comment l’utiliser avec des fonctions lambda, qui sont des fonctions anonymes en Python.
Les fonctions lambda sont utiles pour des opérations courtes (une seule ligne de code) ou pour une utilisation unique sans référence ailleurs dans le programme.
Note : `lambda args : expression` est la syntaxe générale d’une fonction lambda.
#1. Soit la liste de chaînes `strings`. Supposons que vous vouliez créer une liste `strings_rev`, contenant une copie inversée de chaque chaîne.
strings = ['JavaScript','Rust','Python','Go']
Nous pouvons inverser une chaîne en utilisant le découpage de chaîne.
Note : `str[start:stop:step]` est la syntaxe générale du découpage de chaîne.
– Sans les valeurs de début et de fin, la tranche commence au début de la chaîne et s’étend jusqu’à la fin.
– Les valeurs de pas négatives inversent la chaîne.
– Ainsi, `str[::-1]` retourne une copie inversée de `str`.
Utilisons cette fonction lambda : `lambda x:x[::-1]` avec `map()`, comme ci-dessous :
strings_rev = list(map(lambda x:x[::-1],strings)) print(strings_rev)
Comme dans les autres exemples, nous transformons l’objet map en liste. Le résultat montre chaque chaîne inversée.
Output ['tpircSavaJ', 'tsuR', 'nohtyP', 'oG']
#2. Nous avons précédemment calculé les racines carrées puis arrondi les résultats à deux décimales.
Nous avons utilisé `round_2()`. Recréons cette fonction comme une fonction lambda et utilisons-la avec `map()` :
nums_sqrt_round_l =list(map(lambda num:round(num,2),nums_sqrt)) print(nums_sqrt_round_l)
Le résultat est identique à celui obtenu avec `round_2()`.
Output [5.48, 9.49, 5.83, 6.71, 9.85]
Utiliser `map()` avec plusieurs itérables
Dans les exemples précédents, nous avons appliqué une fonction à chaque élément d’un seul itérable.
Certaines fonctions peuvent prendre plusieurs arguments. Dans ce cas, chaque argument est stocké dans une liste ou une collection similaire.
Python `map()` peut être utilisé avec plusieurs listes.
#1. La fonction `area()` accepte la longueur et la largeur comme entrées, et retourne la surface (longueur * largeur) :
def area(length,breadth): return length*breadth
Les longueurs et les largeurs de plusieurs rectangles sont stockées dans les listes `lengths` et `breadths` :
lengths = [4,8,10,18] breadths = [9,4,6,11]
Nous pouvons utiliser `map()` pour appliquer la fonction `area()` avec ces listes :
areas = list(map(area,lengths,breadths)) print(areas)
Comme `area()` accepte deux arguments, les valeurs de longueur et de largeur sont extraites des listes `lengths` et `breadths` respectivement.
Output [36, 32, 60, 198]
#2. Le module `math` de Python contient la fonction `log` pour calculer le logarithme d’un nombre dans une base donnée.
Note : `log(x, base)` renvoie la valeur de log x à la base `base`. Si la base n’est pas spécifiée, la base par défaut est `e` (logarithme népérien).
Dans cet exemple :
- La liste `x` contient les valeurs dont on veut calculer le logarithme.
- La liste `base` contient les bases à utiliser pour le calcul.
x = [2,6,12,10] base = [2,3,2,5]
Utilisons `map()` avec `math.log`, les listes `x` et `base` pour obtenir la nouvelle liste `log_x` :
log_x = list(map(math.log,x,base)) print(log_x)
Voici le résultat :
Output [1.0, 1.6309297535714573, 3.5849625007211565, 1.4306765580733933]
Conclusion
Voici un résumé de ce que vous avez appris dans ce tutoriel :
- La fonction `map()` prend au moins deux arguments : une fonction et un itérable (ou plusieurs), avec la syntaxe `map(fonction, iterable(s))`.
- La fonction peut être n’importe quelle fonction Python valide (intégrée, utilisateur, lambda…).
- Quand la fonction prend `k` arguments, utilisez `map()` avec la fonction et chacun des `k` arguments, fournis dans un itérable respectif.
Ensuite, apprenez comment travailler avec des ensembles en Python.