Comprensión de la función de mapa

map no se relaciona con un producto cartesiano en absoluto, aunque imagino que alguien bien versado en programación funcional podría llegar a alguna forma imposible de entender de generar uno usando map.

map en Python 3 es equivalente a esto:

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

Y la única diferencia en Python 2 es que construirá una lista completa de resultados para devolver todos a la vez en lugar de yielding.

Aunque la convención Python generalmente prefiere las comprensiones de lista (o expresiones generadoras) para lograr el mismo resultado que una llamada a map, particularmente si está utilizando una expresión lambda como primer argumento:

[func(i) for i in iterable]

Como ejemplo de lo que pidió en los comentarios sobre la pregunta - "convertir una cadena en un array", por 'array' probablemente desee una tupla o una lista (ambos se comportan un poco como los arrays de otros lenguajes) -

 >>> 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')

Un uso de map aquí sería si comienzas con una lista de cadenas en lugar de una single string - map puede listificar todos ellos individualmente:

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

Tenga en cuenta que map(list, a) es equivalente en Python 2, pero en Python 3 necesita la llamada list si desea hacer otra cosa que alimentarla en un bucle for (o una función de procesamiento como sum que solo necesita un iterable, y no una secuencia). Pero también tenga en cuenta de nuevo que una comprensión de la lista se prefiere generalmente:

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

map crea una nueva lista aplicando una función a cada elemento de la fuente:

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 es equivalente a comprimir iterables de entrada juntos y luego aplicar la función de transformación en cada elemento de esa lista comprimida intermedia. Es no un producto Cartesiano:

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

He usado zip aquí, pero map el comportamiento en realidad difiere ligeramente cuando las iterables no son del mismo tamaño - como se indica en su documentación, extiende las iterables para contener None.

Simplificando un poco, puedes imaginar map() haciendo algo como esto:

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

Como puede ver, toma una función y una lista, y devuelve una nueva lista con el resultado de aplicar la función a cada uno de los elementos de la lista de entrada. Dije "simplificando un poco" porque en realidad map() puede procesar más de un iterable:

Si se pasan argumentos iterables adicionales, la función debe tomar esos muchos argumentos y se aplica a los elementos de todos iterables en paralelo. Si un iterable es más corto que otro, se supone que se extiende sin elementos.

Para la segunda parte de la pregunta: ¿Qué papel juega esto en la fabricación de un producto cartesiano? bueno, map() se podría usar para generar el producto cartesiano de una lista como esta:

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

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

... Pero a decir verdad, usando product() es una forma mucho más simple y natural de resolver el problema:

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

De cualquier manera, el resultado es el producto cartesiano de lst según la definición anterior:

[(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)]

Espero que esto ayude a alguien que es nuevo en programación y python:

La función map() está ahí para aplicar el mismo procedimiento a cada item en un iterable data structure, como lists, generators, strings, y otras cosas.

, veamos un ejemplo: map() puede iterate sobre cada item en a list y aplicar un function para cada item, de return (dar vuelta) la new list.

Piensa que tienes un function que toma un número(integer), agrega 1 a ese número y lo devuelve.

def add_one(num):
  new_num = num + 1
  return new_num

También tienes un list de números(integers)

my_list = [1,3,6,7,8,10]

Si quieres increment cada número (integer) en el list, puedes hacer lo siguiente:

map(add_one, my_list)

Nota: Como mínimo map() necesita dos arguments. Primero un function nombre y segundo algo como un list.

Resultado del ejemplo anterior, map() le devolverá esto:

[2, 4, 7, 8, 9, 11]

Veamos algunas otras cosas interesantes que map() puede hacer. map() puede tomar múltiples iterables(lists, strings, etc) y pasar un element de cada list (I estoy usando list como ejemplo) a un function como un argument.

Tenemos las siguientes listas:

list_one = [1, 2, 3, 4, 5]
list_two = [11, 12, 13, 14, 15]
list_three = [21, 22, 23, 24, 25]

map() puede hacer un new list que contiene la adición de elementos en un index específico (posición).

Ahora recuerda map(), necesita un function.

def add_from_three_lists(num1, num2, num3):
    total_num = num1 + num2 + num3
    return total_num

Ahora vamos a usar map() función

map(add_from_three_lists, list_one, List_two, list_three)

Y obtendrás:

[33, 36, 39, 42, 45]

RECUERDA:
En Python2 map(), será iterate (pasar por los elementos de la lists) de acuerdo con el más largo list, y pase NoneType a la función para el lists más corto, por lo que su function debe buscar NoneType y manejarlos, de lo contrario obtendrá errors. En python 3 map() solo irá de acuerdo con el más corto list. Además, en Python 3, map() devuelve un iterador, no una lista.