Recherche de site Web

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

Introduction

Nous pouvons utiliser la fonction intégrée 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() retourne 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 applique la fonction 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 du traitement 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 examinerons trois façons différentes de travailler avec map() : en utilisant une fonction lambda, avec une fonction définie par l'utilisateur, et enfin avec une fonction intégrée utilisant plusieurs arguments itérables.

Utiliser 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 dans 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, particulièrement 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-ci, nous pouvons implémenter une fonction lambda avec une expression que nous souhaitons 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 dans notre liste comme x. Ensuite, nous ajoutons notre expression. Nous passons notre liste de nombres comme l'itérable pour map().

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

print(mapped_numbers)

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

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

En fin de compte, map() est le plus utile lorsqu'on travaille avec de grands ensembles de données, donc nous travaillerions probablement davantage avec l'objet map, 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 la même manière qu'un lambda, nous pouvons utiliser une fonction que nous avons définie pour l'appliquer à un itérable. Alors que les fonctions lambda sont plus utiles à mettre en œuvre lorsque vous travaillez avec une expression en une 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 donnée à 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 aquatiques :

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() dans la dernière ligne. 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é "numéro de réservoir" de aquarium_creatures et qu'elle doit stocker le new_tank_number passé en paramètre. 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 carte 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 :

[{'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 associé 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 de manière efficace 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 fonction pow() 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 montreront 2**1, 4**2, 6**3, et ainsi de suite:

[2, 16, 216, 4096, 100000]

Si nous devions fournir map() avec un itérable qui était 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 :

[2, 16, 216, 4096, 100000]

Nous avons utilisé la fonction map() avec une fonction intégrée de Python et avons vu qu'elle peut gérer plusieurs itérables. Nous avons également passé en revue que map() continuera à traiter plusieurs itérables jusqu'à ce qu'elle atteigne la fin de l'itérable contenant 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 qui nécessitent plusieurs itérables, ce qui améliore 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 s'adapter à 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 et des cas d'utilisation plus détaillés.
  • Comprendre les dictionnaires en Python pour améliorer vos connaissances des structures de données Python.
  • Fonctions de chaîne 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().

FAQ

Que fait la fonction map() dans 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 sur 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ée-t-on 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)  # Creates a map object

Vous pouvez ensuite itérer sur les éléments mappés ou les convertir en une liste pour voir les résultats :

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

Est-ce que la fonction map est 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 en même temps. Au lieu de cela, il calcule chaque résultat à la demande lorsque vous l'itérer. Cela peut être plus efficace en termes de mémoire, surtout pour des ensembles de données volumineux, mais cela signifie également que vous ne pouvez pas indexer directement ou itérer plusieurs fois sur le même objet de mappage 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. Il appelle la fonction avec ces éléments comme arguments.
  4. Elle produit le résultat de cet appel de fonction.
  5. Il répète ce processus jusqu'à ce que l'un des itérables soit épuisé.

Si plusieurs itérables sont donnés, 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]

Devrais-je utiliser map en Python ?

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

Avantages :

  • Cela peut être plus concis dans certains cas.
  • Cela 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 listes 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 que les compréhensions de liste sont 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 de caractères en Python ?

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

  • Conversion en une liste puis en une représentation sous forme de chaîne :
mapped = map(str, [1, 2, 3])
string_representation = str(list(mapped))  # "[‘1’, ‘2’, ‘3’]"
  • Rejoindre les 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 voulez 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, because 2*2=4 appears twice

Si vous avez besoin d'un décompte sans convertir en liste, vous pourriez 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(fonction, iterable): Renvoie un itérateur d'éléments de iterable pour lesquels fonction(element) est True. Si fonction est None, elle renvoie des éléments qui sont eux-mêmes considérés comme véritables.

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.