Comment utiliser la fonction Python Map

Introduction

Nous pouvons utiliser la fonction intégrée Python map() pour appliquer une fonction à chaque élément d’un itérable (comme une list ou dictionary) et renvoyer un nouvel itérateur pour récupérer les résultats. map() renvoie un objet map (un itérateur) que nous pouvons utiliser dans d’autres parties de notre programme. Nous pouvons également passer l’objet map à la fonction list(), ou à un autre type de séquence, pour créer un itérable.

La syntaxe de la fonction map() est la suivante :

map(function, iterable, [iterable 2, iterable 3, ...])

Au lieu d’utiliser une boucle for, la fonction map() permet d’appliquer une fonction à chaque élément d’un itérable. Il peut donc souvent être plus performant, puisqu’il n’applique la fonction qu’un élément à la fois plutôt que de rendre itérative la copie des éléments dans un autre. Ceci est particulièrement utile lorsque l’on travaille sur des programmes traitant de grands ensembles de données. map() peut également prendre plusieurs itérables comme arguments de la fonction en envoyant un élément à la fois de chaque itérable à la fonction.

Dans ce tutoriel, nous allons passer en revue trois façons différentes de travailler avec map() : avec une fonction lambda, avec une fonction définie par l’utilisateur, et enfin avec une fonction intégrée utilisant de multiples arguments itérables.

Utiliser une fonction Lambda

Le premier argument de map() est une fonction, que nous utilisons pour l’appliquer à chaque élément. Python appelle la fonction une fois pour chaque élément de l’itérable que nous passons dans map() et il renvoie l’élément manipulé dans un objet map . Pour le premier argument de fonction, nous pouvons soit passer une fonction définie par l’utilisateur, soit utiliser des fonctions lambda, en particulier lorsque l’expression est moins complexe.

La syntaxe de map() avec une fonction lambda est la suivante :

map(lambda item: item[] expression, iterable)

Avec une liste comme celle qui suit, nous pouvons mettre en œuvre une fonction lambda avec une expression que nous voulons appliquer à chaque élément de notre liste :

numbers = [10, 15, 21, 33, 42, 55]

Pour appliquer une expression à chacun de nos numéros, nous pouvons utiliser map() et lambda :

mapped_numbers = list(map(lambda x: x * 2 + 3, numbers))

Ici, nous déclarons un élément de notre liste comme x . Puis nous ajoutons notre expression. Nous passons dans notre liste de numéros comme étant l’itérable pour map() .

Afin de recevoir les résultats immédiatement, nous imprimons une liste de l’objet map :

print(mapped_numbers)

Output
[23, 33, 45, 69, 87, 113]

Nous avons utilisé list() pour que l’objet map nous soit renvoyé sous forme de liste, plutôt que sous forme d’objet moins lisible à l’oeil : <map object at 0x7fc250003a58>. L’objet map est un itérateur sur nos résultats, nous pouvons donc le survoler avec for, ou nous pouvons utiliser list() pour le transformer en liste. Nous faisons cela ici parce que c’est une bonne façon d’examiner les résultats.

En fin de compte, map() est plus utile lorsque l’on travaille avec de grands ensembles de données, donc nous travaillerons probablement davantage avec l’objet map, et nous n’utiliserons généralement pas un constructeur comme list() sur eux.

Pour les petits ensembles de données, la compréhension de listes peut être plus appropriée, mais pour les besoins de ce tutoriel, nous utilisons un petit ensemble de données pour faire la démonstration de map().

Mettre en œuvre une fonction définie par l’utilisateur

De la même manière qu’une lambda, nous pouvons utiliser une fonction que nous avons définie pour qu’elle s’applique à un itérable. Si les fonctions lambda sont plus utiles à mettre en œuvre lorsque vous travaillez avec une expression d’une ligne, les fonctions définies par l’utilisateur sont plus appropriées lorsque l’expression devient plus complexe. En outre, lorsque nous devons transmettre une autre donnée à la fonction que vous appliquez à vos fonctions itératives, les fonctions définies par l’utilisateur peuvent être un meilleur choix pour la lisibilité.

Par exemple, dans l’itérable suivant, chaque élément est un dictionnaire qui contient différents détails sur chacune de nos créatures d’aquarium :

aquarium_creatures = [
	{"name": "sammy", "species": "shark", "tank number": 11, "type": "fish"},
	{"name": "ashley", "species": "crab", "tank number": 25, "type": "shellfish"},
	{"name": "jo", "species": "guppy", "tank number": 18, "type": "fish"},
	{"name": "jackie", "species": "lobster", "tank number": 21, "type": "shellfish"},
	{"name": "charlie", "species": "clownfish", "tank number": 12, "type": "fish"},
	{"name": "olly", "species": "green turtle", "tank number": 34, "type": "turtle"}
]

Nous avons décidé que toutes les créatures de l’aquarium vont en fait se déplacer dans le même réservoir. Nous devons mettre à jour nos registres pour refléter le fait que toutes nos créatures se déplacent dans le réservoir 42. Pour que map() puisse accéder à chaque dictionnaire et à chaque paire clé:valeur dans les dictionnaires, nous construisons une fonction imbriquée :

def assign_to_tank(aquarium_creatures, new_tank_number):
	def apply(x):
		x["tank number"] = new_tank_number
		return x
	return map(apply, aquarium_creatures)

Nous définissons une fonction assign_to_tank() qui prend aquarium_creatures et new_tank_number comme paramètres. Dans assign_to_tank(), nous passons apply() comme fonction à map() sur la ligne finale. La fonction assign_to_tank retournera l’itérateur résultant de map() .

apply() prend x comme argument qui représente un élément de notre liste - un dictionnaire unique.

Ensuite, nous définissons que x est la clé "tank number" de aquarium_creatures et qu’il devrait stocker le passé dans new_tank_number. Nous retournons chaque article après avoir appliqué le nouveau numéro de réservoir.

Nous appelons assign_to_tank() avec notre liste de dictionnaires et le nouveau numéro de réservoir que nous voulons remplacer pour chaque créature :

assigned_tanks = assign_to_tank(aquarium_creatures, 42)

Une fois la fonction terminée, nous avons notre objet filtre stocké dans la variable assigned_tanks, que nous transformons en liste et imprimons :

print(list(assigned_tanks))

Nous recevrons les résultats suivants de ce programme :

Output
[{'name': 'sammy', 'species': 'shark', 'tank number': 42, 'type': 'fish'}, {'name': 'ashley', 'species': 'crab', 'tank number': 42, 'type': 'shellfish'}, {'name': 'jo', 'species': 'guppy', 'tank number': 42, 'type': 'fish'}, {'name': 'jackie', 'species': 'lobster', 'tank number': 42, 'type': 'shellfish'}, {'name': 'charlie', 'species': 'clownfish', 'tank number': 42, 'type': 'fish'}, {'name': 'olly', 'species': 'green turtle', 'tank number': 42, 'type': 'turtle'}]

Nous avons fait correspondre le nouveau numéro de réservoir à notre liste de dictionnaires. En utilisant une fonction que nous définissons, nous pouvons incorporer map() pour appliquer la fonction efficacement sur chaque élément de la liste.

Utilisation d’une fonction intégrée avec plusieurs itérables

De la même manière que les fonctions lambda ou nos propres fonctions définies, nous pouvons utiliser les fonctions intégrées de Python avec map(). Pour appliquer une fonction à itérations multiples, on passe un autre nom d’itération à la suite du premier. Par exemple, en utilisant la fonction pow() qui prend en compte deux nombres pour trouver la puissance du nombre de base par rapport à l’exposant fourni.

Nous avons ici nos listes d’entiers que nous aimerions utiliser avec pow() :

base_numbers = [2, 4, 6, 8, 10]
powers = [1, 2, 3, 4, 5]

Ensuite, nous passons dans pow() comme notre fonction dans map() et fournissons les deux listes comme nos itérables :

numbers_powers = list(map(pow, base_numbers, powers))

print(numbers_powers)

map() appliquera la fonction pow() au même élément de chaque liste pour donner le pouvoir. Par conséquent, nos résultats seront de 2**1 , 4**2 , 6**3 , et ainsi de suite :

Output
[2, 16, 216, 4096, 100000]

Si nous devions fournir à map() un itérable plus long que l’autre, map() cesserait de calculer une fois qu’elle aurait atteint la fin de l’itérable le plus court. Dans le programme suivant, nous étendons base_numbers avec trois numéros supplémentaires :

base_numbers = [2, 4, 6, 8, 10, 12, 14, 16]
powers = [1, 2, 3, 4, 5]

numbers_powers = list(map(pow, base_numbers, powers))

print(numbers_powers)

Par conséquent, rien ne changera dans le calcul de ce programme et il donnera donc toujours le même résultat :

Output
[2, 16, 216, 4096, 100000]

Nous avons utilisé la fonction map() avec une fonction Python intégrée et nous avons vu qu’elle peut gérer plusieurs itérations. Nous avons également vérifié que map () continuerait à traiter de multiples itérables jusqu’à ce qu’elle ait atteint la fin de l’itérable avec le moins d’éléments possible.

Conclusion

Dans ce tutoriel, nous avons appris les différentes façons d’utiliser la fonction map() en Python. Vous pouvez maintenant utiliser map() avec votre propre fonction, une fonction lambda, et avec toute autre fonction intégrée. Vous pouvez également implémenter map() avec des fonctions qui nécessitent plusieurs itérables.

Dans ce tutoriel, nous avons immédiatement imprimé les résultats de map() sous forme de liste à des fins de démonstration. Dans nos programmes, nous utilisons généralement l’objet map renvoyé pour manipuler davantage les données.

Si vous souhaitez en savoir plus sur Python, consultez notre série Comment coder en Python 3 et notre page thématique Python. Pour en savoir plus sur le travail avec des ensembles de données dans la programmation fonctionnelle, consultez notre article sur la fonction filter() .