Comprendre la fonction Map. python

Question

map(function, iterable, ...)

Appliquer la fonction à chaque élément de l'objet iterable et retourne la liste des résultats. Si un complément d'objet iterable les arguments sont passés, la fonction doit prendre que de nombreux arguments et les éléments de tous les iterables en parallèle. Si un objet iterable est plus courte que l'autre est supposé être étendu avec Aucun des éléments. Si la fonction n'est, la fonction identité est supposé; s'il y a plusieurs arguments, map() retourne une liste de tuples contenant les éléments correspondants de tous les iterables (une sorte de transposition de l'opération). L'objet iterable arguments peut être une séquence ou tout objet itérable; le résultat est toujours une liste.

quel est le rôle de cette pièce de théâtre en faire un produit Cartésien?

content = map(tuple, array)

quel est l'effet de mettre un tuple n'importe où dans il avoir?

J'ai aussi remarqué que sans la carte de la fonction de la sortie est " abc "et, avec elle, de ses "a,b,c'

Je veux bien comprendre cette fonction. La référence des définitions est aussi comprendre. Trop de fantaisie peluches.

Answer 1

map n'est pas particulièrement pythonic. Je vous conseille d'utiliser interprétations de la liste à la place:

map(f, iterable)

est essentiellement équivalent à:

[f(x) for x in iterable]

map sur son propre ne peut pas faire un produit Cartésien, car la longueur de sa liste de sortie est toujours la même que sa liste d'entrée. Vous pouvez trivialement faire un produit Cartésien d'une liste de compréhension:

[(a, b) for a in iterable_a for b in iterable_b]

La syntaxe est un peu déroutant -- c'est en gros l'équivalent de:

list = []
for a in iterable_a:
    for b in iterable_b:
        list.append((a, b))

Answer 2

map ne se rapportent pas à un produit Cartésien à tous, bien que j'imagine que quelqu'un de bien versé dans la programmation fonctionnelle pourrait venir avec quelques impossible de comprendre la façon de générer un seul à l'aide de map.

map est équivalent à (dans Py3; dans Py2 il génère une liste et retourne à la place de yielding, mais est le même):

def map(func, iterable):
    for i in iterable:
        yield func(i)

Bien que Python convention d'habitude préfère les interprétations de la liste (ou générateur d'expressions) pour obtenir le même résultat qu'un appel à l' map, en particulier si vous utilisez une expression lambda comme premier argument:

[func(i) for i in iterable]

Comme un exemple de ce que vous avez demandé dans les commentaires sur la question - "transformer une chaîne en un tableau", par "tableau", vous voulez probablement soit un tuple ou une liste (deux d'entre eux se comportent un peu comme des tableaux à partir d'autres langues) -

 >>> a = "hello, world"
 >>> list(a)
['h', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd']
>>> tuple(a)
('h', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd')

Une utilisation de l' map ici si vous commencez avec une liste de chaînes de caractères au lieu d'une seule chaîne - map peut listify chacun d'entre eux individuellement:

>>> a = ["foo", "bar", "baz"]
>>> list(map(list, a))
[['f', 'o', 'o'], ['b', 'a', 'r'], ['b', 'a', 'z']]

Notez que map(list, a) est équivalent à Py2, mais dans Py3 vous avez besoin de l' list appeler si vous voulez faire autre chose que de le nourrir en for boucle. Mais aussi noter encore qu'une compréhension de liste est généralement préférée:

>>> [list(b) for b in a]
[['f', 'o', 'o'], ['b', 'a', 'r'], ['b', 'a', 'z']]

Answer 3

map crée une nouvelle liste par application d'une fonction à chaque élément de la source:

xs = [1, 2, 3]

# all of those are equivalent - the output is [2, 4, 6]
# 1. map
ys = map(lambda x: x * 2, xs)
# 2. list comprehension
ys = [x * 2 for x in xs]
# 3. explicit loop
ys = []
for x in xs:
    ys.append(x * 2)

n-ary map est équivalent à la compression d'entrée iterables ensemble, puis en appliquant la transformation de la fonction sur chaque élément de cet intermédiaire zippée liste. C'est pas un produit Cartésien:

xs = [1, 2, 3]
ys = [2, 4, 6]

def f(x, y):
    return (x * 2, y // 2)

# output: [(2, 1), (4, 2), (6, 3)]
# 1. map
zs = map(f, xs, ys)
# 2. list comp
zs = [f(x, y) for x, y in zip(xs, ys)]
# 3. explicit loop
zs = []
for x, y in zip(xs, ys):
    zs.append(f(x, y))

J'ai utilisé zip ici, mais map comportement diffère en fait un peu quand iterables ne sont pas de la même taille - comme indiqué dans la documentation, il s'étend iterables contiennent None.

Answer 4

En simplifiant un peu, vous pouvez l'imaginer map() de faire quelque chose comme ceci:

def mymap(func, lst):
    result = []
    for e in lst:
        result.append(func(e))
    return result

Comme vous pouvez le voir, il prend une fonction et une liste et retourne une nouvelle liste avec le résultat de l'application de la fonction de chacun des éléments dans la liste d'entrée. J'ai dit "simplifier un peu", parce qu'en réalité, map() peut traiter plus d'un objet iterable:

Si un complément d'objet iterable les arguments sont passés, la fonction doit prendre que de nombreux arguments et les éléments de tous les iterables en parallèle. Si un objet iterable est plus courte que l'autre est supposé être étendu avec Aucun des éléments.

Pour la deuxième partie de la question: Quel est le rôle de cette pièce de théâtre en faire un produit Cartésien? eh bien, map() pourrait être utilisé pour générer le produit cartésien d'une liste comme ceci:

lst = [1, 2, 3, 4, 5]

from operator import add
reduce(add, map(lambda i: map(lambda j: (i, j), lst), lst))

... Mais pour dire la vérité, à l'aide de product() est beaucoup plus simple et naturel pour résoudre le problème:

from itertools import product
list(product(lst, lst))

De toute façon, le résultat est le produit cartésien de l' lst tel que défini ci-dessus:

[(1, 1), (1, 2), (1, 3), (1, 4), (1, 5),
 (2, 1), (2, 2), (2, 3), (2, 4), (2, 5),
 (3, 1), (3, 2), (3, 3), (3, 4), (3, 5),
 (4, 1), (4, 2), (4, 3), (4, 4), (4, 5),
 (5, 1), (5, 2), (5, 3), (5, 4), (5, 5)]