Map

MAP( )
La función map () ejecuta una función especifica para cada elemento en un iterable y el elemento se envía a la función como un parámetro.

Sintaxis.

map(function, iterables)

Con esto vamos hacer unos deliciosos tacos, para ello utilizáremos maps()

def ingredientes(a, b):
  return a + " es a " + b

menu = list(map(ingredientes, ('carne', 'maiz', 'aguacate'), ('molida', 'tacos', 'guacamole')))

print(list(menu))

_Producción_
['carne es a molida', 'maiz es a tacos', 'aguacate es a guacamole']

Tambien podemos hacer uso de los slicing:

numbers_1 = [1, 2, 3, 4]
numbers_2 = [5, 6, 7]

print(numbers_1)
print(numbers_2)
result = map(lambda x, y : x + y, numbers_1[::-1], numbers_2)
print(list(result))

Resultado :

[1, 2, 3, 4]
[5, 6, 7]
[9, 9, 9]

Si lo vemos con los slicing seria así:

[4, 3, 2, 1]
[5, 6 ,7]
[9, 9, 9]

He hecho los mismos ejemplos pero con tuplas que son más rápidas y funciona también!

map()

• map()recorre los elementos de una entrada iterable (o iterables) y devuelve un iterador que resulta de aplicar una función de transformación a cada elemento en la entrada iterable original.

• De acuerdo con la documentación , map()toma un objeto de función y un iterable (o múltiples iterables) como argumentos y devuelve un iterador que produce elementos transformados a pedido. La firma de la función se define de la siguiente manera:

map(function, iterable[, iterable1, iterable2,..., iterableN])

• map()se aplica functiona cada elemento en iterableun bucle y devuelve un nuevo iterador que produce elementos transformados bajo demanda. functionpuede ser cualquier función de Python que tome una cantidad de argumentos igual a la cantidad de iterables que pasa a map().

Nota: el primer argumento para map()es un objeto de función , lo que significa que debe pasar una función sin llamarla. Es decir, sin usar un par de paréntesis.

• Este primer argumento de map()es una función de transformación . En otras palabras, es la función que transforma cada elemento original en un elemento nuevo (transformado). Aunque la documentación de Python llama a este argumento function, puede ser cualquier Python al que se pueda llamar. Esto incluye funciones integradas , clases , métodos , lambdafunciones y funciones definidas por el usuario .

Codigo

ingredientes = ['🐏' , '🐓','🐟','🐖']
preparacion = ['🍔','🍗','🍣','🥓']
print(ingredientes)
print(preparacion)
result=list(map(lambda a,b:'Con '+a+' se puede hacer '+b, ingredientes,preparacion))
print(result)

Resultado

['🐏', '🐓', '🐟', '🐖']
['🍔', '🍗', '🍣', '🥓']
['Con 🐏 se puede hacer 🍔', 'Con 🐓 se puede hacer 🍗', 'Con 🐟 se puede hacer 🍣', 'Con 🐖 se puede hacer 🥓']

Bueno, map lo empiezo a comprender, aunque los mismos resultados los conseguí con list comprehensions (sin lambda ni maps). Estudiare mas para ver las grandes diferencias. Dejo el codigo.

numbers_4 = [x*2 for x in numbers]
print(numbers_4)

number_5 = [numbers_1[i] + x for i, x in enumerate(numbers_2)]
print(number_5)

MAP + LAMBDA = GENIAL

Otro ejemplo un poco más claro sin lambdas para entender lo que hace map.

def funcion_cuadrado(x):
    return x**3

vector_lista = [1,2,3,4,5]
resultado = list(map(funcion_cuadrado, vector_lista))
print(resultado)

La función “map” en Python es una función integrada que se utiliza para aplicar una función dada a cada elemento de un iterable (como una lista, tupla o conjunto) y devolver un iterable (generalmente una lista) con los resultados. La sintaxis es la siguiente:

map(función, iterable)

donde “función” es la función a aplicar a cada elemento y “iterable” es el iterable sobre el que se aplicará la función.

Por ejemplo, podríamos usar “map” para elevar cada elemento de una lista a una potencia específica:

numbers = [1, 2, 3, 4, 5]
squared_numbers = list(map(lambda x: x ** 2, numbers))
print(squared_numbers) # [1, 4, 9, 16, 25]

También se pueden utilizar funciones normales en lugar de funciones lambda

def square(x):
    return x ** 2
squared_numbers = list(map(square, numbers))
print(squared_numbers) # [1, 4, 9, 16, 25]

También se pueden utilizar varios iterables con map, ejemplo:

numbers1 = [1, 2, 3, 4, 5]
numbers2 = [6, 7, 8, 9, 10]
result = list(map(lambda x, y: x * y, numbers1, numbers2))
print(result) # [6, 14, 24, 36, 50]

Es importante tener en cuenta que “map” devuelve un objeto “map” el cual se debe convertir a una estructura de datos deseada (list, tuple, set, etc.) para poder trabajar con ellos.

En resumen, la función “map” en Python es una herramienta útil para aplicar una función dada a cada elemento de un iterable y devolver un iterable con los resultados, es una forma concisa y fácil de realizar operaciones sobre un conjunto de datos.

Muy bien explicado, gracias profe

Hola! 😄 les dejo un tutorial que encontré sobre la función map() , en el explica tanto teoria como practica, en el se ven ejemplos bastante interesanto sobre el uso de esta función.
.
Esepero les sea de ayuda 😄
Link al tutorial

Una de las aplicaciones de la función MAP() es la normalización de data por ejemplo :

# Aplicacion - Normalización de Data
# Apicación - Max-Min scaling
numbers = [14,15,27,35,8,27,17,15,4,22,24]
print(numbers)
max_number = max(numbers)
min_number = min(numbers)
normalizer = list(map(lambda x : round((2*x - max_number - min_number)/(max_number-min_number),2),numbers))
print(normalizer)

Convirtiendo cerdo en hamburguesa, gallo en en presa de pollo, maiz en palomitas y papa en papitas fritas si se entiende la función MAP.

La función map() ejecuta una función específica para cada element de un iterable. El elemento es enviado a la función como un parámetro.

numbers = [1, 2, 3, 4]
numbers_v2 = []
for i in numbers:
  numbers_v2.append(i * 2)

numbers_v3 = list(map(lambda i: i * 2, numbers))

print(numbers)
print(numbers_v2)
print(numbers_v3)

numbers_1 = [1, 2, 3, 4]
numbers_2 = [5, 6, 7]

print(numbers_1)
print(numbers_2)
result = list(map(lambda x, y: x + y, numbers_1, numbers_2))
print(result)

Salida

[1, 2, 3, 4]
[2, 4, 6, 8]
[2, 4, 6, 8]
[1, 2, 3, 4]
[5, 6, 7]
[6, 8, 10]

Nota: Map ejecuta la función hasta el último elemento de la lista mas pequeña.

Comparacion de sintaxis entre los metodos para aplicar transformaciones

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

Transformacion aplicando bucle for

numeros_for = []
for i in numeros:
numeros_for.append(i * 2)
print("Bucle for: ",numeros_for)

Transformacion aplicando bucle for con definicion de COMPREHENSION

numeros_comprhension = [x * 2 for x in numeros]
print("List Comprehensions: ",numeros_comprhension)

Transformacion usando funcion MAP

numeros_map = list(map(lambda x : x * 2, numeros))
print("Funcion MAP: ",numeros_map)

Lista multiplicada por dos imprimiéndosela al revés

numeros_al_reves  = list(map(lambda numero : numero * 2, numeros[::-1]))
print(numeros_al_reves )

Buen día comunidad, les dejo mi aporte, ya que ambas clases me fueron útiles para transformar listas de strings a enteros y viceversa, al estar trabajando con números binarios, les dejo mi ejemplo de uso por si les es útil. Saludos.

Nota: los ciclos for sólo son para mostrar los tipos de datos en cada lista.

# Lista de strings a int

numbers_str =["1", "1", "0", "0"]
for e in numbers_str:
    print (type(e))
print (numbers_str)

numbers_int= list(map(lambda e: int(e), numbers_str))
for e in numbers_int:
  print (type(e))
print (numbers_int)

#Lista de int a str

numbers_int =[1, 1, 0, 0]
for e in numbers_int:
    print (type(e))
print (numbers_int)

numbers_str= list(map(lambda e: str(e), numbers_int))
for e in numbers_str:
  print (type(e))
print (numbers_str)

# Pasar la lista numbers_str a un int
number_str= "".join(numbers_str)
number_int= int(number_str)
print (type(number_int))
print (number_int)

La función map() en Python es una función integrada que se utiliza para aplicar una función a cada elemento de un iterable (como una lista o un diccionario) y devolver un nuevo iterador para recuperar los resultados123.

La sintaxis de la función map() es la siguiente: map(función, iterable(s)). La función puede ser cualquier función de Python válida que acepte uno o más argumentos. El iterable puede ser cualquier objeto iterable, como una lista o un diccionario.

Por ejemplo, si quisieras aplicar la función len() a cada cadena en una lista, podrías hacerlo de la siguiente manera:

palabras = [“hola”, “mundo”, “python”]
longitudes = map(len, palabras)
print(list(longitudes)) # [4, 5, 6]

def cocinar(ingrediente):
    if  ingrediente == '🐔':
        return '🍗'
    elif ingrediente == '🐮':
        return '🍔'
    elif ingrediente == '🥔':
        return '🍟'
    else:
        return '🍪'
    
# ejecución
ingredientes = ['🐔', '🐮', '🥔']
resultado = map(cocinar, ingredientes)
lista_r = list(resultado)  
print(lista_r)  

# con lambda
ingredientes = ['🐔', '⚽', '🥔']
cocinar_v2 = lambda ingrediente: '🍗' if ingrediente == '🐔' else ('🍔' if ingrediente == '🐮' else ('🍟' if ingrediente == '🥔' else '🍪'))
resultado = map(cocinar_v2, ingredientes)
lista_r = list(resultado)  
print(lista_r)  

En Python, map() es una función incorporada que se utiliza para aplicar una función a cada elemento de una secuencia iterable (como una lista, tupla o conjunto) y devuelve un nuevo iterable con los resultados
.

La sintaxis general de la función map() es la siguiente:

map(función, iterable)

• función: Es la función que se aplicará a cada elemento del iterable.
• iterable: Es la secuencia iterable a la que se aplicará la función.

La función map() toma cada elemento del iterable, lo pasa como argumento a la función proporcionada y devuelve un nuevo iterable con los resultados de aplicar la función a cada elemento.

Aquí tienes un ejemplo para ilustrar cómo usar map():

def cuadrado(x):
    return x ** 2

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

resultado = map(cuadrado, numeros) #[1, 4, 9, 16, 25]

En este ejemplo, se define una función llamada cuadrado() que toma un número como argumento y devuelve su cuadrado. Luego, se crea una lista llamada numeros con algunos números. Al aplicar map(cuadrado, numeros), la función cuadrado() se aplica a cada elemento de la lista numeros, produciendo un nuevo iterable con los cuadrados de los números.

Puedes convertir el resultado en una lista usando list(resultado) si deseas obtener los elementos en forma de lista.

La función map() es útil cuando se desea aplicar una operación o transformación a todos los elementos de un iterable de manera eficiente y concisa.

hablando de funciones e aquí algo interesante de la función principal print y es que tiene un argumento que se llama sep que escrito de la siguiente manera dando varios argumentos los separa de acuerdo a lo que le indiquemos.

MAP: Transformaciones a una lista dada de elementos con el mismo número de elementos, pero transformados.

numbers = [1, 2, 3, 4]
numbers_v2 = []

for i in numbers:
numbers_v2.append(i * 2)

numbers_v3 = list(map(lambda i : i * 2, numbers)) #El map se convierte a lista

print(numbers)
print(numbers_v2)
print(numbers_v3)

numbers_1 = [1, 2, 3, 4]
numbers_2 = [5, 6, 7] #Limite de la lista más pequeña
print(numbers_1)
print(numbers_2)
result = list(map(lambda x, y : x + y, numbers_1, numbers_2))
print(result)

Super bien explicado Nico! sos el mejor

Me gustó mucho la analogía de la transformación de un array de animales a comida, bastante gráfico.

map, se usa para transformar elementos

numbers = [1, 2, 3, 4]
numbersV2 = []
for i in numbers:
    numbersV2.append(i * 2)
print(numbersV2)

‘’‘con map y lambda’’’

numbersV3 = list(map(lambda i : i * 2, numbers))
print(numbersV3)

‘’‘iterando dos listas con map’’’

numbers1 = [1, 2, 3, 4]
numbers2 = [5, 6, 7, 8]
result = map(lambda x,y : x + y, numbers1, numbers2)
print(list(result))

genial…!

map es una función de orden superior que toma una función y un iterable (como una lista) como argumentos y aplica la función a cada elemento del iterable, devolviendo un nuevo iterable (generalmente una lista) que contiene los resultados.

La sintaxis general de la función map es la siguiente:

map(funcion, iterable)

• funcion: Es la función que se aplicará a cada elemento del iterable.
• iterable: Es la secuencia de elementos a los que se les aplicará la función.

A menudo, se utiliza junto con funciones lambda para realizar operaciones simples en cada elemento del iterable. Aquí hay un ejemplo básico usando map y una función lambda para elevar al cuadrado cada elemento de una lista:

numeros = [1, 2, 3, 4, 5]
cuadrados = map(lambda x: x**2, numeros)

# Convertir el resultado a una lista para visualización (en Python 3, map devuelve un iterador)
cuadrados_lista = list(cuadrados)
print(cuadrados_lista)  # Salida: [1, 4, 9, 16, 25]

En este ejemplo, la función lambda lambda x: x**2 se aplica a cada elemento de la lista numeros, generando así una nueva lista con los cuadrados de los números originales.

Es importante tener en cuenta que, en Python 3, map devuelve un objeto iterable, por lo que comúnmente se convierte a lista para ver los resultados. En Python 2, map devuelve directamente una lista.

La función map es útil cuando deseas aplicar una operación a cada elemento de una lista u otro iterable sin tener que usar bucles explícitos. Sin embargo, en algunos casos, el uso de listas de comprensión o funciones generadoras también puede ser una alternativa válida y puede mejorar la legibilidad del código en comparación con el uso de map.

Me gusto esta forma de aprender los ejercicios usando el lambda. Es algo interesante y me permite mejorar mis habilidades como programador.

Mis notas =>

#MAP

# https://www.w3schools.com/python/ref_func_map.asp

# MAP: Transformación a una lista dada de elementos

'''
Ejemplo:

Elementos ->      ['🐏', '🐓', '🐟', '🐖']
Transformación -> ['🍔', '🍗', '🍣', '🥓']
Retorno ->        ['Con 🐏 se puede hacer 🍔', 'Con 🐓 se puede hacer 🍗', 'Con 🐟 se puede hacer 🍣', 'Con 🐖 se puede hacer 🥓']
'''

numbers = [1, 2, 3, 4]
numbers_v2 = []
for i in numbers:
  numbers_v2.append(i * 2)

numbers_v3 = list(map(lambda i: i * 2, numbers)) #Uso del Map

print(numbers)
print(numbers_v2)
print(numbers_v3)

numbers_1 = [1, 2, 3, 4]
numbers_2 = [5, 6, 7]

print(numbers_1)
print(numbers_2)
result = list(map(lambda x, y: x + y, numbers_1, numbers_2)) #Transformando elementos en una lista
print(result)

✅

numeros = [1,2,3,4,5]
numeros_v2 = []
for i in numeros:
numeros_v2.append(i*2)

numeros_v3 = list(map(lambda i: i *2, numeros))

print (numeros)
print(numeros_v2)
print(numeros_v3)

lista = [2,3,4,5]
lista2 = [6,7,8,9]

print(lista)
print(lista2)

resultado = list(map(lambda x , y : x + y , lista , lista2))
print(resultado)

otras formas curiosas de obtener el mismo resultado XD

numbers = [5, 6, 7, 8]
numbers_2 = []
for i in numbers:
    numbers_2.append(i * 2)

print(f'Lista de números {numbers}\n')

print(numbers_2)

##########################

numbers_3 = list(map(lambda i: i * 2, numbers))

print(numbers_3)

##########################

def mapa_V1(x):
    numbers = list(map(lambda i: i * 2, x))
    return numbers


print(mapa_V1(numbers))

##########################

def mapa_V2(x): return list(map(lambda i: i * 2, x))


print(mapa_V2([5, 6, 7, 8])) # los argumentos se deben introducir en formato [lista] si no se cuenta con una variable predefinida.

En python, la función .map(), permite aplicar funciones a elementos iterables, es decir, elementos que se pueden recorrer usando ciclos.

Por ejemplo:

El programa de abajo saca el cuadrado de un número mediante una función, y los números son definidos por una lista. Con .map(), observamos que se puede aplicar la función a cada elemento de los iterables (es decir, de los números de la lista)…

def cuadrado(numero):
 return numero * numero

lista = [1,2,3,4,5]
resultado = map(cuadrado, lista)

lista_resultado = list(resultado)
print(lista_resultado)

A partir de una lista de elementos, al pasarlos por una función, estos se van a transformar.

Lo importante del MAP es saber que vas a obtener el mismo número de elementos que tenías pero transformados.

A este nivel siento que estoy estudiando JavaScript jajajaja

Esto me ahorrará muchos for

Con este ejercicio me está quedando más claro la función lambda.

def doblar(numero):
    return numero*2

numeros = [2, 5, 10, 23, 50, 33]

map(doblar, numeros)

<map at 0x212eb6e0748>
Fácilmente podemos transformar este iterable en una lista:


list(map(doblar, numeros))

[4, 10, 20, 46, 100, 66]
Y podemos simplificarlo con una función lambda para substituir la llamada de una función definida:


list( map(lambda x: x*2, numeros) )

[4, 10, 20, 46, 100, 66]

Hice un ejemplo con países y capitales:

capital = ['Sucre', 'Lima', 'Bogotá', 'Santiago']
pais = ['Bolivia', 'Perú', 'Colombia', 'Chile']

print(capital)
print(pais)

result_1 = list(map(lambda x, y: 'La capital de ' + y + ' es ' + x, capital, pais))

print(result_1)

El resultado es:

[‘Sucre’, ‘Lima’, ‘Bogotá’, ‘Santiago’]
[‘Bolivia’, ‘Perú’, ‘Colombia’, ‘Chile’]
[‘La capital de Bolivia es Sucre’, ‘La capital de Perú es Lima’, ‘La capital de Colombia es Bogotá’, ‘La capital de Chile es Santiago’]

Mas claro, con los ejemplos, entender que va a devolver la de menor rango porque no tiene con quien transformar. Buena explicación, sencilla.

Documentation de Built-in Functions:

https://docs.python.org/3.10/library/functions.html

https://www.w3schools.com/python/python_ref_functions.asp

Comparto el código que escribí siguiendo esta clase:

numbers = [i for i in range(5,24,2)]
print(numbers)
numbers2 = [numbers[9]-i for i in numbers]
print(numbers2)
numbers3 = list(map(lambda i:numbers[9]-i,numbers))
print(numbers3)

# punto medio

v1 = (-1,2)
v2 = (5,12,6)
punto_medio = tuple(map(lambda x,y: (x+y)/2, v1, v2))
print(v1)
print(v2)
print(punto_medio)

numbers = [1, 2, 3, 4]
numbers_v2 = []
for i in numbers:
  numbers_v2.append(i * 2)

numbers_v3 = list(map(lambda i: i * 2, numbers))

print(numbers)
print(numbers_v2)
print(numbers_v3)

# lambda crea funciones con menos lineas de codigo
numbers_1 = [1, 2, 3, 4]
numbers_2 = [5, 6, 7]
# map transforma elementos de listas
result = list(map(lambda x,y: x + y, numbers_1, numbers_2))
print(result)

map(function,iterable)  ## en function se colocaría el lambda

Dentro del lambda se crea la funcion que nos arrojaría el output deseado,

def increment(x):
    return x + 1
increment_v2 = lambda x : x + 1 #Esto entrega el mismo output

Recordar que el primer x indica la variable/argumento y el segundo x indica el retorno de valor (operación)

Por lo que entiendo, map es una hof para listas

Aplicando map para completar mi nombre:

List1 = ['Jh','Sebas','Ale','Aus']
List2 = ['on','tian','gria','echa']
CompleteName = list(map(lambda x,y:x+y, List1,List2))
print(CompleteName)

# ['Jhon', 'Sebastian', 'Alegria', 'Ausecha']

Se prueba con funciones iteradores y map

<code>
numbers = [1, 2,3,4]
numbers_v2 = []

for i in numbers:
    numbers_v2.append(i * 2)
print(numbers)
print(numbers_v2)
# utilizacion de Map
numbers_v3 = list(map(lambda iterador: iterador * 2, numbers))
print(numbers_v3)

# suma de listas con funciones
def sum_list(x, y):
    list1 = []
    for iterable in range(len(x)): 
        list1.append(y[iterable] + x[iterable])
    return list1
result = sum_list(numbers, numbers_v2)
print(result)

lista_map1 = list(map(lambda x, y: x + y, numbers, numbers_v2))
print(lista_map1)

# suma de listas con map
numbers_1 = [1, 2, 3, 4]
numbers_2 = [5, 6, 7]
print(numbers_1)
print(numbers_2)
list_map = list(map(lambda x , y: x + y, numbers_1, numbers_2))
print(list_map)

def cuadrado(x):
    return x ** 2

numeros = [1, 2, 3, 4, 5]
cuadrados = map(cuadrado, numeros)
print(list(cuadrados))  # Output: [1, 4, 9, 16, 25]

En este ejemplo, hemos definido una función cuadrado que eleva al cuadrado su argumento. Luego, hemos creado una lista de números del 1 al 5. Finalmente, hemos aplicado la función cuadrado a cada elemento de la lista utilizando la función map.

El resultado de la llamada a map se guarda en un objeto map, que podemos convertir en una lista usando la función list. En este caso, el resultado es una lista que contiene los cuadrados de los números originales.

Entonces…

• Map es una función que toma una función y un iterable (como una lista) como argumentos y devuelve un nuevo iterable con la función aplicada a cada elemento del iterable original.
• Map se utiliza para aplicar una función a cada elemento de una lista y devuelve una nueva lista con los resultados.

Ejemplo de MAP() con lambda

numbers = [1, 2, 3, 4]
numbers_v3 = list(map(lambda i: i * 4, numbers))
print('v0.3', numbers_v3)

Respuesta: v0.3 [4, 8, 12, 16]

Primero, se define una lista de números llamada numbers con los valores [1, 2, 3, 4]. Luego, se utiliza la función map() para aplicar una función lambda que multiplica cada número por 4 a cada elemento de la lista numbers. La función lambda se define como lambda i: i * 4, donde i es el parámetro que representa cada elemento de la lista numbers. La función lambda multiplica el valor de i por 4 y devuelve el resultado.

El resultado de la función map() se convierte a una lista utilizando la función list(), y se asigna a la variable numbers_v3. En este caso, numbers_v3 es una nueva lista que contiene los valores [4, 8, 12, 16], que son los valores originales de numbers multiplicados por 4.

a1=[‘apple’, ‘banana’, ‘cherry’]
a2 =[‘orange’, ‘lemon’, ‘pineapple’]

x3 = list(map(lambda x,y:x + y,a1,a2))
print(x3)

#En una sola línea de código sería
x4 = list(map(lambda x,y:x + y,(‘apple’, ‘banana’, ‘cherry’),(‘orange’, ‘lemon’, ‘pineapple’)))
print(x4)

numbers_v4 = [number * 2 for number in numbers]
print(numbers_v4)

Wow que chévere, una manera más simple de transformar datos de una lista haciendo uso de las lambda functions! Vamos poco a poco creando las mismas soluciones con menos líneas de código! Genial!

# Map
'''
Vamos a utilizar los conceptos de Higher Order Function y Lambda Functions en funciones directamente construidas por Python.
Una de esas muy importante es la funcion Map:
Sun funcion principal es hacer transformaciones a una lista dada de elementos, retornando siempre el mismo numero de elementos de la lista original.
'''

numbers = [1, 2, 3, 4]
numbers_v2 = []
for i in numbers:
  numbers_v2.append(i * 2)

# Usando Map
numbers_v3 = list(map(lambda i: i * 2, numbers))

print(numbers)
print(numbers_v2)
print(numbers_v3)

# Iterando y transformando dos listas de diferentes dimensiones con map
numbers_1 = [1, 2, 3, 4]
numbers_2 = [5, 6, 7]

# Retorna una lista con la dimension de la lista mas pequeña
result = list(map(lambda x, y: x + y, numbers_1, numbers_2))
print(numbers_1)
print(numbers_2)
print(result)

Mi aporte

me gusta mas la sintaxis de map en javascript

Una explicacion con codigo:

list(map(funcion transformadora (donde por cada elemento , se hará alguna operación o algún cambio,elemento que queremos iterar 1, elemento que queremos iterar 2...))

El list se utiliza para transformar porque el map devuelve un iterable así que se transforma de iterable a lista.

numbers = [5,2,8]
numbers2 = [4,8,9]

result = list(map(lambda x,y : x * y , numbers,numbers2))

print(result)

En este caso tenemos las dos listas del mismo size, pero si fuera uno mayor que otro, la iteracion sera igual a la lista con menos elementos.

#Map
'''
Vamos a utilziar conceptos de High order function
y landa function en funciones directamente
construidas por Python. Una de estas es la funcion Map

Funcion principal:
    - Hacer transformaciones dada una lista con elementos
 
 Ejemplo:
 tenemos una lista [vaca,pollo,carnero]
 lo pasamos por una funcion cook()
 la lista se transforma [vaca cocinado, pollo frito, sopa]   
'''
#Transformando sin map
numeros=[1,2,3,4]
numberos_v2=[]
for i in numeros:
    numberos_v2.append(i*2)
print(numeros)
print(numberos_v2)

#Transformando con map
numbers_v3=list(map(lambda i:i*2,numeros))
print(numbers_v3)

#Trabajando con 2 listas con map
numeros_1=[1,2,3,4]
numeros_2=[5,6,7]
print(numeros_1)
print(numeros_2)

resultado=map(lambda x,y:x+y,numeros_1,numeros_2)
print(list(resultado))

Práctica en clase

numbers = [6, 7, 8, 9]
numbers_2 = []
for i in numbers:
  numbers_2.append(i * 4)

numbers_3 = list(map(lambda i : i * 4, numbers))

print(numbers)
print(numbers_2)
print(numbers_3)

num_1 = [1, 2, 3, 4]
num_2 = [5, 6, 7, 8]

print(num_1)
print(num_2)
result = list(map(lambda x, y: x * y, num_1, num_2))
print(result)

  ESTE ES MI RESULTADO EN CONSOLA 

<me gusta la manzana en   me gusta la pera en    me gusta el mango en 
jugo  fruta Helado 
me gusta la manzana en jugo   me gusta la pera en  fruta  me gusta el mango en Helado > 

<fruts = ["me gusta la manzana en" + " ", " me gusta la pera en " + " ", " me gusta el mango en "]
fruts_2 = ["jugo ","fruta", "Helado "]

print(*fruts)
print(*fruts_2)
result =list( map(lambda x, y: x + y, fruts, fruts_2))
print(*result)

Nota: si le ponemos un * en el print y luego la variable se ve mas limpio > 

)

Con esa explicación si que entendí muy bien 😄

Para el primer ejemplo también se podia crear así :

numbers_v4 = [i * 2 for i in numbers]

inclusive es más corto.

numbers = [5, 10, 15, 20, 25]
numbers_double_values = list(map(lambda number: number * 2, numbers))

print(numbers_double_values)

numbers_1 = [1,2,3,4]
numbers_2 = [5,6,7]

print(numbers_1)
print(numbers_2)

result = list(map(lambda x, y: x + y, numbers_1, numbers_2))
print(result) # [6,8,10] el último elemento no fue tomado en cuenta

Hace tiempo hice un vídeo donde muestro que hay mejores métodos que usar un bucle for en JS, les puede ayudar a repasar:
¡Deja de usar FOR con Arrays en JavaScript! Mejor usa estos métodos 😎

En la práctica son muy pocas veces que utilizamos funciones como Map, Filter or Reduce, ya que todo esto lo podemos hacer con list comprehesions (y mucho más…)

Python List Comprehensions vs. Map/List/Filter Functions

numbers = [1, 2, 3, 4]
numbers_v2 = []
for i in numbers:
  numbers_v2.append(i*2)

numbers_v3 =list(map(lambda i: i * 2, numbers))

print(numbers)
print(numbers_v2)
print(numbers_v3)

numbers_1 = [1, 2, 3, 4]
numbers_2 = [5, 6, 7]

print(numbers_1)
print(numbers_2)
result = list(map(lambda x, y:x + y, numbers_1, numbers_2))
print(result)

Map

#------------- map ------------------

# multiplicar por 2 elementos de una lista
numbers = [1, 2, 3, 4]
numbers2 = []

for i in numbers:
  numbers2.append(i*2)
  
print(numbers2)
--> [2, 4, 6, 8]

# multiplicar por 2 elementos de una lista con map
numbers3 = list(map(lambda i: i*2, numbers))
print(numbers3)
--> [2, 4, 6, 8]

# iterar dos listas y aplicar una transformacion con map
numbers_1 = [3, 4, 5, 6]
numbers_2 = [7, 8, 9]

result = list(map(lambda x, y: x + y, numbers_1, numbers_2))
print(result)
--> [10, 12, 14]

👏👏👏

#Chanche dates in list

list_a=[1,2,3,5,8,13]
list_b=[3,1,4,1,5,9]
result=[]


for i in list_a:
    result.append(i*2)

print(result)


# simplified

resultado= list(map(lambda X: X*2 ,list_b))
print (resultado)


resultado_2= list(map(lambda x,y: x+y, list_a,list_b))
print(resultado_2)

Así podemos interactuar con 2 listas!

Estos códigos hacen que cada vez me enamore más de Python:

numbers = [1,2,3,4,5,6,7]
numbers_v2 = []

for i in numbers:
  numbers_v2.append(i * 2)

numbers_v3 = list(map(lambda i : i * 2, numbers))

print(numbers)
print(numbers_v2)
print(numbers_v3)
print('*' * 10)

numbers_1 = [1,2,3,4]
numbers_2 = [5,6,7]

print(numbers_1)
print(numbers_2)

result = list(map(lambda x, y: x + y, numbers_1, numbers_2))
print(result)
print('*' * 10)

La función map hace que se cumpla el zen de python. Con estás funciones (lambda y map),que vienen integrado en python, la codificación puede ser más sencilla, clara y organizada.

Excelente, cada vez todo se vuelve más simple y más práctico