Python Language
Fonction de la carte

Syntaxe

• map (fonction, iterable [, * additional_iterables])
• future_builtins.map (fonction, iterable [, * additional_iterables])
• itertools.imap (function, iterable [, * additional_iterables])

Paramètres

Remarques

list(map(abs, [-1,-2,-3]))    # [1, 2, 3]
[abs(i) for i in [-1,-2,-3]]  # [1, 2, 3]

import operator
alist = [1,2,3]
list(map(operator.add, alist, alist))  # [2, 4, 6]
[i + j for i, j in zip(alist, alist)]  # [2, 4, 6]

Utilisation basique de map, itertools.imap et future_builtins.map

La fonction de carte est la plus simple parmi les éléments intégrés Python utilisés pour la programmation fonctionnelle. map() applique une fonction spécifiée à chaque élément dans une itération:

names = ['Fred', 'Wilma', 'Barney']

map(len, names)  # map in Python 3.x is a class; its instances are iterable
# Out: <map object at 0x00000198B32E2CF8>

Une map compatible avec Python 3 est incluse dans le module future_builtins :

from future_builtins import map  # contains a Python 3.x compatible map()
map(len, names)                  # see below
# Out: <itertools.imap instance at 0x3eb0a20>

Alternativement, en Python 2, on peut utiliser imap d' itertools pour obtenir un générateur.

map(len, names)   # map() returns a list
# Out: [4, 5, 6]

from itertools import imap
imap(len, names)  # itertools.imap() returns a generator
# Out: <itertools.imap at 0x405ea20>

Le résultat peut être explicitement converti en une list pour supprimer les différences entre Python 2 et 3:

list(map(len, names))
# Out: [4, 5, 6]

map() peut être remplacé par une expression de compréhension de liste ou de générateur équivalente:

[len(item) for item in names] # equivalent to Python 2.x map()
# Out: [4, 5, 6]

(len(item) for item in names) # equivalent to Python 3.x map()
# Out: <generator object <genexpr> at 0x00000195888D5FC0>

Mapper chaque valeur dans une itération

Par exemple, vous pouvez prendre la valeur absolue de chaque élément:

list(map(abs, (1, -1, 2, -2, 3, -3))) # the call to `list` is unnecessary in 2.x
# Out: [1, 1, 2, 2, 3, 3]

La fonction anonyme prend également en charge le mappage d'une liste:

map(lambda x:x*2, [1, 2, 3, 4, 5])
# Out: [2, 4, 6, 8, 10]

ou convertir les valeurs décimales en pourcentages:

def to_percent(num):
    return num * 100

list(map(to_percent, [0.95, 0.75, 1.01, 0.1]))
# Out: [95.0, 75.0, 101.0, 10.0]

ou convertir des dollars en euros (compte tenu d'un taux de change):

from functools import partial
from operator import mul

rate = 0.9  # fictitious exchange rate, 1 dollar = 0.9 euros
dollars = {'under_my_bed': 1000,
           'jeans': 45,
           'bank': 5000}

sum(map(partial(mul, rate), dollars.values()))
# Out: 5440.5

functools.partial est un moyen pratique de corriger les paramètres des fonctions pour qu'elles puissent être utilisées avec map au lieu d'utiliser lambda ou de créer des fonctions personnalisées.

Mappage des valeurs de différentes itérations

Par exemple le calcul de la moyenne de chaque i -ième élément de multiples iterables:

def average(*args):
    return float(sum(args)) / len(args)  # cast to float - only mandatory for python 2.x

measurement1 = [100, 111, 99, 97]
measurement2 = [102, 117, 91, 102]
measurement3 = [104, 102, 95, 101]

list(map(average, measurement1, measurement2, measurement3))
# Out: [102.0, 110.0, 95.0, 100.0]

Il existe différentes exigences si plusieurs itérables sont transmises à map selon la version de python:

• La fonction doit prendre autant de paramètres qu’il ya d’itérables:

  def median_of_three(a, b, c):
      return sorted((a, b, c))[1]
  
  list(map(median_of_three, measurement1, measurement2))
  

  TypeError: median_of_three () manquant 1 argument de position requis: 'c'

  list(map(median_of_three, measurement1, measurement2, measurement3, measurement3))
  

  TypeError: median_of_three () prend 3 arguments positionnels mais 4 ont été donnés

Transposer avec Map: Utiliser "None" comme argument de fonction (python 2.x uniquement)

from itertools import imap
from future_builtins import map as fmap # Different name to highlight differences

image = [[1, 2, 3],
         [4, 5, 6],
         [7, 8, 9]]

list(map(None, *image))
# Out: [(1, 4, 7), (2, 5, 8), (3, 6, 9)]
list(fmap(None, *image))
# Out: [(1, 4, 7), (2, 5, 8), (3, 6, 9)]
list(imap(None, *image))
# Out: [(1, 4, 7), (2, 5, 8), (3, 6, 9)]

image2 = [[1, 2, 3],
          [4, 5],
          [7, 8, 9]]
list(map(None, *image2))
# Out: [(1, 4, 7), (2, 5, 8), (3, None, 9)]  # Fill missing values with None
list(fmap(None, *image2))
# Out: [(1, 4, 7), (2, 5, 8)]                # ignore columns with missing values
list(imap(None, *image2))
# Out: [(1, 4, 7), (2, 5, 8)]                # dito

list(map(None, *image))

def conv_to_list(*args):
    return list(args)

list(map(conv_to_list, *image))
# Out: [[1, 4, 7], [2, 5, 8], [3, 6, 9]]

Cartographie en série et parallèle

map () est une fonction intégrée, ce qui signifie qu’elle est disponible partout sans avoir à utiliser une instruction «importation». Il est disponible partout, tout comme print () Si vous regardez l'exemple 5, vous verrez que je devais utiliser une instruction d'importation avant de pouvoir utiliser une jolie impression (importation pprint). Ainsi, pprint n'est pas une fonction intégrée

Cartographie en série

Dans ce cas, chaque argument de l'itérable est fourni comme argument de la fonction de mappage dans l'ordre croissant. Cela se produit lorsque nous n’avons qu’une seule option à mapper et que la fonction de mappage nécessite un seul argument.

Exemple 1

insects = ['fly', 'ant', 'beetle', 'cankerworm']
f = lambda x: x + ' is an insect'
print(list(map(f, insects))) # the function defined by f is executed on each item of the iterable insects

résulte en

['fly is an insect', 'ant is an insect', 'beetle is an insect', 'cankerworm is an insect']

Exemple 2

print(list(map(len, insects))) # the len function is executed each item in the insect list

résulte en

[3, 3, 6, 10]

Cartographie parallèle

Dans ce cas, chaque argument de la fonction de mappage est extrait de toutes les itérables (une de chaque itérable) en parallèle. Le nombre d'itérables fourni doit donc correspondre au nombre d'arguments requis par la fonction.

carnivores = ['lion', 'tiger', 'leopard', 'arctic fox']
herbivores = ['african buffalo', 'moose', 'okapi', 'parakeet']
omnivores = ['chicken', 'dove', 'mouse', 'pig']

def animals(w, x, y, z):
    return '{0}, {1}, {2}, and {3} ARE ALL ANIMALS'.format(w.title(), x, y, z)

Exemple 3

# Too many arguments
# observe here that map is trying to pass one item each from each of the four iterables to len. This leads len to complain that
# it is being fed too many arguments
print(list(map(len, insects, carnivores, herbivores, omnivores)))

résulte en

TypeError: len() takes exactly one argument (4 given)

Exemple 4

# Too few arguments
# observe here that map is suppose to execute animal on individual elements of insects one-by-one. But animals complain when
# it only gets one argument, whereas it was expecting four.
print(list(map(animals, insects)))

résulte en

TypeError: animals() missing 3 required positional arguments: 'x', 'y', and 'z'

Exemple 5

# here map supplies w, x, y, z with one value from across the list
import pprint
pprint.pprint(list(map(animals, insects, carnivores, herbivores, omnivores)))

résulte en

 ['Fly, lion, african buffalo, and chicken ARE ALL ANIMALS',
 'Ant, tiger, moose, and dove ARE ALL ANIMALS',
 'Beetle, leopard, okapi, and mouse ARE ALL ANIMALS',
 'Cankerworm, arctic fox, parakeet, and pig ARE ALL ANIMALS']