Guide ultime de la fonction map Python pour le traitement des données

Introduction

Nous pouvons utiliser la fonction intégrée de Python map() pour appliquer une fonction à chaque élément d’un itérable (comme une liste ou un dictionnaire) et retourner 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() offre un moyen d’appliquer une fonction à chaque élément d’un itérable. Par conséquent, elle peut souvent être plus performante car elle n’applique la fonction qu’à un élément à la fois plutôt que de faire des copies des éléments dans un autre itérable. Cela est particulièrement utile lors de l’exécution de programmes traitant de grands ensembles de données. map() peut également prendre plusieurs itérables comme arguments pour la fonction en envoyant un élément de chaque itérable à la fonction à la fois.

Dans ce tutoriel, nous allons examiner 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 plusieurs arguments itérables.

Utilisation d’une fonction Lambda

Le premier argument de map() est une fonction, que nous utilisons pour appliquer à chaque élément. Python appelle la fonction une fois pour chaque élément de l’itérable que nous passons à map() et elle retourne 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 suit, nous pouvons implémenter 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 nombres, 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. Ensuite, nous ajoutons notre expression. Nous passons notre liste de nombres comme itérable pour map().

Pour 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 de mappage nous soit retourné sous forme de liste, plutôt que sous la forme d’un objet moins lisible pour les humains comme : <map object at 0x7fc250003a58>. L’objet de mappage est un itérateur sur nos résultats, nous pourrions donc le parcourir avec for ou nous pouvons utiliser list() pour le transformer en liste. Nous faisons cela ici car c’est une bonne manière de revoir les résultats.

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

Pour les petits ensembles de données, les compréhensions de liste peuvent être plus adaptées, mais aux fins de ce tutoriel, nous utilisons un petit ensemble de données pour démontrer map().

Implémentation d’une fonction définie par l’utilisateur

De manière similaire à une lambda, nous pouvons utiliser une fonction que nous avons définie pour appliquer à un itérable. Bien que les fonctions lambda soient plus utiles à mettre en œuvre lorsque vous travaillez avec une expression d’une seule ligne, les fonctions définies par l’utilisateur sont plus appropriées lorsque l’expression devient plus complexe. De plus, lorsque nous devons passer une autre pièce de données à la fonction que vous appliquez à votre itérable, 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 déménager dans le même réservoir. Nous devons mettre à jour nos dossiers pour refléter que toutes nos créatures déménagent dans le réservoir 42. Pour que map() accède à 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 renverra l’itérateur résultant de map().

apply() prend x comme argument, qui représente un élément de notre liste — un seul dictionnaire.

Ensuite, nous définissons que x est la clé "tank number" de aquarium_creatures et qu’elle doit stocker le new_tank_number passé. Nous retournons chaque élément 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 map stocké dans la variable assigned_tanks, que nous transformons en liste et imprimons :

print(list(assigned_tanks))

Nous recevrons la sortie suivante 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 mappé 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.

Utiliser 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 avec plusieurs itérables, nous passons un autre nom d’itérable après le premier. Par exemple, en utilisant la pow() fonction qui prend deux nombres pour trouver la puissance du nombre de base à l’exposant fourni.

Voici 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 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 dans chaque liste pour fournir la puissance. Par conséquent, nos résultats afficheront 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’il atteint la fin de l’itérable le plus court. Dans le programme suivant, nous étendons base_numbers avec trois nombres 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)

En conséquence, rien ne changera dans le calcul de ce programme et il produira donc toujours le même résultat :

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

Nous avons utilisé la fonction map() avec une fonction intégrée de Python et avons constaté qu’elle peut gérer plusieurs itérables. Nous avons également revu que map() continuera à traiter plusieurs itérables jusqu’à ce qu’il atteigne la fin de l’itérable ayant le moins d’éléments.

Conclusion

Dans ce tutoriel, nous avons exploré diverses méthodes d’utilisation de la fonction map() en Python. Vous avez maintenant la possibilité d’utiliser map() avec des fonctions personnalisées, des expressions lambda, et d’autres fonctions intégrées. De plus, map() peut être appliqué à des fonctions nécessitant plusieurs itérables, améliorant ainsi sa polyvalence dans les tâches de traitement de données.

À des fins de démonstration, nous avons converti les résultats de map() directement en une liste. Dans des applications pratiques, l’objet map retourné peut être manipulé davantage pour répondre à des besoins spécifiques.

Pour approfondir votre compréhension de Python, veuillez utiliser les ressources suivantes :

• Tutoriel sur la fonction map() de Python pour des exemples plus détaillés et des cas d’utilisation.
• Comprendre les dictionnaires en Python pour améliorer vos connaissances sur les structures de données en Python.
• Fonctions de chaîne en Python pour explorer diverses techniques de manipulation de chaînes.

Ces ressources vous fourniront une compréhension complète des capacités de Python et de la manière de les utiliser efficacement dans vos projets.

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

FAQs

Que fait map() en Python ?

La fonction map() en Python prend une fonction et un ou plusieurs itérables et renvoie un itérateur qui applique la fonction donnée à chaque élément des itérables fournis. En d’autres termes, elle « mappe » la fonction à chaque élément de l’itérable. Par exemple :

numbers = [1, 2, 3, 4]
squares = map(lambda x: x**2, numbers)

Ici, squares sera un itérateur de 1, 4, 9, 16.

Comment créer une carte en Python ?

Vous créez un objet map en appelant la fonction intégrée map() avec une fonction et au moins un itérable comme arguments. Par exemple :

def add_one(x):
    return x + 1

my_list = [1, 2, 3]
mapped = map(add_one, my_list)  # Crée un objet map

Vous pouvez ensuite itérer sur le mappé ou le convertir en liste pour voir les résultats :

print(list(mapped))  # [2, 3, 4]

La carte est-elle paresseuse en Python ?

Oui, en Python 3, map() renvoie un itérateur paresseux, ce qui signifie qu’il ne traite ni ne stocke tous les résultats en mémoire à la fois. Au lieu de cela, il calcule chaque résultat à la demande au fur et à mesure que vous l’itérer. Cela peut être plus efficace en mémoire, en particulier pour de grands ensembles de données, mais cela signifie également que vous ne pouvez pas indexer directement ou itérer plusieurs fois sur le même objet map sans le reconstruire.

Comment fonctionne la fonction map() ?

La fonction map() fonctionne comme suit :

1. Vous fournissez une fonction et un ou plusieurs itérables.
2. map() récupère un élément de chaque itérable.
3. Elle appelle la fonction avec ces éléments comme arguments.
4. Elle renvoie le résultat de cet appel de fonction.
5. Elle répète ce processus jusqu’à ce qu’un des itérables soit épuisé.

Si plusieurs itérables sont fournis, map() s’arrête lorsque l’itérable le plus court est épuisé. Par exemple :

numbers = [1, 2, 3]
others = [10, 20, 30]
result = map(lambda x, y: x + y, numbers, others)
print(list(result))  # [11, 22, 33]

Dois-je utiliser map en Python ?

Que vous deviez utiliser map() dépend de votre préférence personnelle et de la lisibilité :

Avantages :

• Elle peut être plus concise dans certains cas.
• Elle peut être légèrement plus rapide que les compréhensions de liste dans certaines situations (bien que souvent pas de manière significative).

Inconvénients :

• Le code utilisant des compréhensions de liste ou des expressions génératrices est souvent considéré comme plus « Pythonique » et plus facilement lisible.
• Les programmeurs Python plus récents peuvent trouver les compréhensions de listes plus intuitives.

En résumé, utilisez map() si cela rend votre code plus clair et plus direct. Sinon, les compréhensions de listes ou les expressions génératrices sont une alternative très courante.

Comment convertir map en chaîne en Python ?

Un objet map est un itérateur, pas une chaîne. Si vous souhaitez convertir les résultats d’un appel à map() en chaîne, vous devez d’abord l’itérer. Les approches courantes incluent :

• Conversion en liste puis en représentation de chaîne :

mapped = map(str, [1, 2, 3])
string_representation = str(list(mapped))  # "[‘1’, ‘2’, ‘3’]"

• Jointure des résultats s’ils sont des éléments de chaîne :

mapped = map(str, [1, 2, 3])
joined_string = ''.join(mapped)  # "123"

La meilleure méthode dépend de si vous souhaitez une représentation de liste lisible par un humain (str(list(...))) ou une concaténation des résultats (''.join(...)).

Que fait map count() ?

Les objets map en Python n’ont pas de méthode intégrée count(). La méthode count() est disponible sur les listes, les chaînes de caractères et certaines autres collections. Si vous souhaitez compter les occurrences d’une valeur produite par un objet map, vous devez d’abord le convertir en liste (ce qui consomme l’itérateur) :

mapped = map(lambda x: x*2, [1, 2, 3, 2])
mapped_list = list(mapped)
count_of_4 = mapped_list.count(4)  # 2, car 2*2=4 apparaît deux fois

Si vous avez besoin d’un compte sans convertir en liste, vous pouvez itérer manuellement :

count_of_value = sum(1 for x in map(lambda x: x*2, [1, 2, 3, 2]) if x == 4)

Que font map et filter en Python ?

• map(function, iterable) : Applique la fonction à chaque élément de l’itérable et renvoie un itérateur des résultats.

• filter(function, iterable) : Renvoie un itérateur des éléments de l’itérable pour lesquels function(element) est True. Si function est None, il renvoie les éléments qui sont vrais par eux-mêmes.

Par exemple :

nums = [1, 2, 3, 4, 5]
mapped_nums = map(lambda x: x*2, nums)        # [2, 4, 6, 8, 10]
filtered_nums = filter(lambda x: x > 2, nums) # [3, 4, 5]

map transforme chaque élément, tandis que filter sélectionne certains éléments en fonction d’une condition.