En Python, vous pouvez utiliser map() pour appliquer des fonctions intégrées, des expressions lambda (lambda), des fonctions définies avec def, etc., à tous les éléments d’itérables tels que les listes et les tuples.
Cet article décrit le contenu suivant.
- Utilisation de base de map()
- map() renvoie un itérateur en Python3
- Convertir en liste
- Appliquer des expressions lambda (lambda)
- Appliquer les fonctions définies avec def
- Spécifiez plusieurs itérables comme arguments
- Utilisez plutôt des compréhensions de liste et des expressions génératrices
- Utilisez NumPy à la place
Notez que map() peut être remplacé par des compréhensions de liste ou des expressions de générateur. Comme décrit plus loin, il est préférable de les utiliser dans de nombreux cas.
Utilisation de base de map()
Le premier argument de map() est un objet appelable tel qu’une fonction à appliquer, et le deuxième argument est un objet itérable tel qu’une liste.
map() renvoie un itérateur en Python3
Appliquez la fonction intégrée abs() qui renvoie la valeur absolue.
En Python 3, map() renvoie un objet de type map qui est un itérateur, et print() ne génère pas d’éléments.
l = [-2, -1, 0]
print(map(abs, l))
#
print(type(map(abs, l)))
# <class 'map'>
La valeur de l’itérateur peut être récupérée avec une instruction for.
for i in map(abs, l):
print(i)
# 2
# 1
# 0
Le même résultat est obtenu si le processus est exécuté dans un bloc for sans utiliser map().
for i in l:
print(abs(i))
# 2
# 1
# 0
Notez que map() dans Python 2 renvoie une liste, soyez donc prudent lorsque vous exécutez du code Python 2 dans Python 3.
Convertir en liste
Si vous voulez convertir le résultat de map() en liste, utilisez list().
print(list(map(abs, l)))
# [2, 1, 0]
Par exemple, appliquez len() à une liste de chaînes pour la convertir en une liste du nombre de caractères.
l_s = ['apple', 'orange', 'strawberry']
print(list(map(len, l_s)))
# [5, 6, 10]
Dans le deuxième argument de map(), non seulement une liste mais aussi un itérable tel qu’un tuple ou une plage peuvent être spécifiés.
print(list(map(abs, range(-2, 1))))
# [2, 1, 0]
Appliquer des expressions lambda (lambda)
Si vous souhaitez appliquer n’importe quel processus au lieu d’une fonction intégrée, utilisez l’expression lambda (lambda).
l = [-2, -1, 0]
print(list(map(lambda x: x**2, l)))
# [4, 1, 0]
Appliquer les fonctions définies avec def
Il est également possible de définir une fonction avec def et de la spécifier comme premier argument de map().
def square(x):
return x**2
print(list(map(square, l)))
# [4, 1, 0]
Spécifiez plusieurs itérables comme arguments
Vous pouvez spécifier plus d’itérables comme map(function, iterable1, iterable2, …).
Si plusieurs itérables sont spécifiés, le premier argument doit être une fonction qui reçoit ce nombre d’arguments. Une erreur est levée si le nombre d’itérables ne correspond pas au nombre d’arguments que la fonction reçoit.
l_1 = [1, 2, 3]
l_2 = [10, 20, 30]
print(list(map(lambda x, y: x * y, l_1, l_2)))
# [10, 40, 90]
# print(list(map(abs, l_1, l_2)))
# TypeError: abs() takes exactly one argument (2 given)
Si les itérables ont des tailles différentes (nombre d’éléments), les éléments supplémentaires sont ignorés.
l_3 = [100, 200, 300, 400]
print(list(map(lambda x, y, z: x * y * z, l_1, l_2, l_3)))
# [1000, 8000, 27000]
Utilisez plutôt des compréhensions de liste et des expressions génératrices
Le même processus que map() peut être réalisé avec des compréhensions de liste et des expressions de générateur.
l = [-2, -1, 0]
print([abs(x) for x in l])
# [2, 1, 0]
print([x**2 for x in l])
# [4, 1, 0]
l_1 = [1, 2, 3]
l_2 = [10, 20, 30]
print([x * y for x, y in zip(l_1, l_2)])
# [10, 40, 90]
Si vous voulez obtenir une liste comme list(map()), utilisez les compréhensions de liste, et si vous voulez obtenir un itérateur comme map(), utilisez une expression de générateur.
Comme indiqué dans la question Stack Overflow suivante, dans la plupart des cas, l’utilisation de compréhensions de liste et d’expressions génératrices est préférable à map() car le code est plus concis et clair.
Pour la vitesse de traitement, les réponses suivantes ont été fournies.
Notez que, puisque la vitesse de traitement peut varier en raison de divers facteurs, si la vitesse est importante pour vous, il est recommandé de la mesurer dans des conditions aussi proches que possible de vos hypothèses.
Utilisez NumPy à la place
Dans le cas d’une liste de nombres, le processus de map() peut également être réalisé avec NumPy. Le code est encore plus clair que les compréhensions map() et list.
import numpy as np
a = np.array([-2, -1, 0])
print(np.abs(a))
# [2 1 0]
print(a**2)
# [4 1 0]
a_1 = np.array([1, 2, 3])
a_2 = np.array([10, 20, 30])
print(a_1 * a_2)
# [10 40 90]
NumPy est plus rapide pour les grandes listes et les traitements complexes. NumPy fournit diverses fonctions, vous devriez donc les essayer si vous traitez un tableau de nombres.