Recherche de site Web

Guide ultime de la fonction Python Map 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 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() fournit un moyen d'appliquer une fonction à chaque élément d'un itérable. Par conséquent, il peut souvent être plus performant puisqu'il 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. Ceci est particulièrement utile lorsque vous travaillez 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 de chaque itérable à la fonction à la fois.

Dans ce didacticiel, nous passerons en revue trois manières 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. en fonction en 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 de l'itérable que nous passons dans map() et renvoie l'élément manipulé dans un objet map. Pour le premier argument de fonction, nous pouvons soit transmettre 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-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 de notre liste comme x. Ensuite, nous ajoutons notre expression. Nous transmettons notre liste de nombres comme itérable pour map().

Afin de recevoir immédiatement les résultats, 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 renvoyé sous forme de liste, plutôt qu'un objet moins lisible par l'homme comme : . L'objet map est un itérateur sur nos résultats, nous pouvons donc le parcourir avec for ou utiliser list() pour le transformer en liste. Nous faisons cela ici parce que c’est un bon moyen d’examiner les résultats.

En fin de compte, map() est plus utile lorsque vous travaillez avec de grands ensembles de données, nous travaillerions donc probablement davantage avec l'objet map et n'utiliserions généralement pas un constructeur comme list() sur eux.

Pour les ensembles de données plus petits, les compréhensions de listes peuvent être plus adaptées, mais pour les besoins de ce didacticiel, 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 à implémenter lorsque vous travaillez avec une expression sur 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 transmettre 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 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 allaient en fait emménager dans le même aquarium. Nous devons mettre à jour nos enregistrements pour refléter que toutes nos créatures se déplacent 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 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 code transmis dans new_tank_number. Nous renvoyons 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 tank que nous voulons remplacer pour chaque créature :

assigned_tanks = assign_to_tank(aquarium_creatures, 42)

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

print(list(assigned_tanks))

Nous recevrons le résultat suivant 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 mappé le nouveau numéro de char à notre liste de dictionnaires. En utilisant une fonction que nous définissons, nous pouvons incorporer map() pour appliquer efficacement la fonction 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 avec plusieurs itérables, nous passons un autre nom 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 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 pow() comme fonction dans map() et fournissons les deux listes comme 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 :

[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 aurait 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)

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

[2, 16, 216, 4096, 100000]

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

Conclusion

Dans ce didacticiel, nous avons exploré différentes méthodes d'utilisation de la fonction map() en Python. Vous avez désormais 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, 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 liste. Dans les applications pratiques, l'objet cartographique renvoyé 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 Python map() pour des exemples et des cas d'utilisation plus détaillés.
  • Comprendre les dictionnaires en Python pour améliorer votre connaissance 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 thématique Python. Pour en savoir plus sur l'utilisation des ensembles de données en programmation fonctionnelle, consultez notre article sur la fonction filter().

FAQ

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, il « 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é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)  # Creates a map object

Vous pouvez ensuite parcourir 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, dans 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 au fur et à mesure que vous le parcourez. Cela peut être plus efficace en termes de mémoire, en particulier pour les grands ensembles de données, mais cela signifie également que vous ne pouvez pas indexer directement ou parcourir de manière répétée le même objet cartographique 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. Il donne 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]

Dois-je utiliser map en Python ?

L'utilisation ou non de map() dépend de vos préférences personnelles et de la lisibilité :

Avantages :

  • Cela peut être plus concis dans certains cas.
  • Cela peut être légèrement plus rapide que la compréhension de listes dans certains scénarios (mais 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 les plus récents peuvent trouver la compréhension des listes plus intuitive.

En bref, 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 parcourir celle-ci. Les approches courantes comprennent :

  • Conversion en liste puis en représentation sous forme de chaîne :
mapped = map(str, [1, 2, 3])
string_representation = str(list(mapped))  # "[‘1’, ‘2’, ‘3’]"
  • Joindre les résultats s'il s'agit d'éléments de chaîne :
mapped = map(str, [1, 2, 3])
joined_string = ''.join(mapped)  # "123"

La meilleure méthode dépend si vous souhaitez une représentation de liste lisible par l'homme (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 count() intégrée. La méthode count() est disponible sur les listes, les chaînes et certaines autres collections. Si vous souhaitez compter les occurrences d'une valeur produite par un objet cartographique, vous devez d'abord la convertir en liste (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 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 itérable et renvoie un itérateur des résultats.

  • filter(function, iterable) : renvoie un itérateur d'éléments de l'itérable pour lequel function(element) est True. Si la fonction est None, elle renvoie des éléments qui sont véridiques en 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.