Introducci贸n

1

El Zen de Python

Conjuntos

2

Sets

3

Modificando conjuntos

4

Operaciones con conjuntos

5

Playgrounds: Elimina elementos duplicados usando conjuntos

Comprehensions

6

List Comprehension

7

Dictionary Comprehension

8

Dictionary Comprehension: condition

9

Playgrounds: Crea una lista usando List Comprehension

10

Lists vs. Tuples vs. Sets

Funciones

11

Funciones

12

Funciones: return

13

Par谩metros por defecto y m煤ltiples returns

14

El scope

15

Refactor game

16

Playgrounds: Tienda de Tecnolog铆a

17

Funciones an贸nimas: lambda

18

Higher order function: una funci贸n dentro de otra funci贸n

19

Map

20

Map con diccionarios

21

Reto: map con inmutabilidad

22

Playgrounds: Multiplica todos los elementos por dos

23

Filter

24

Playgrounds: Retorna solo palabras de 4 letras y m谩s

25

Reduce

M贸dulos

26

M贸dulos

27

Mis propios m贸dulos

28

M贸dulos como scripts: __name__ y __main__

29

Paquetes

30

Playgrounds: Calcular la suma de todas las compras

Manipulaci贸n de archivos y errores

31

Iterables

32

Errores en Python

33

Manejo de excepciones

34

Playgrounds: Captura la excepci贸n: ZeroDivisionError

35

Leer un archivo de texto

36

Escribir en un archivo

37

Leer un CSV

38

Playgrounds: Lee un CSV para calcular el total de gastos

Gr谩ficas en Python

39

Creando una gr谩fica

40

Reto: graficando la poblaci贸n de un pa铆s

41

Reto: graficando la poblaci贸n mundial

Pr贸ximos pasos

42

隆Conoce otros proyectos de este curso!

43

Reconoce tu proceso y certif铆cate

44

Toma el Curso de PIP y Entornos Virtuales con Python

No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Map

19/44
Recursos

Aportes 72

Preguntas 11

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

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

La verdad es que ver est谩s funciones de esta forma, me resulto m谩s c贸modo.

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

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]

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 .

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)

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 馃']

MAP + LAMBDA = GENIAL

Muy bien explicado, gracias profe

La funci贸n 鈥渕ap鈥 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 鈥渇unci贸n鈥 es la funci贸n a aplicar a cada elemento y 鈥渋terable鈥 es el iterable sobre el que se aplicar谩 la funci贸n.

Por ejemplo, podr铆amos usar 鈥渕ap鈥 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 鈥渕ap鈥 devuelve un objeto 鈥渕ap鈥 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 鈥渕ap鈥 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.

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)

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.

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)

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)

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 = [鈥渉ola鈥, 鈥渕undo鈥, 鈥減ython鈥漖
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.

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.

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.

Excelente clase, todo muy bien explicado. Cada dia creciendo mas en este increible camino de la programaci贸n. :D

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:

[鈥楽ucre鈥, 鈥楲ima鈥, 鈥楤ogot谩鈥, 鈥楽antiago鈥橾
[鈥楤olivia鈥, 鈥楶er煤鈥, 鈥楥olombia鈥, 鈥楥hile鈥橾
[鈥楲a capital de Bolivia es Sucre鈥, 鈥楲a capital de Per煤 es Lima鈥, 鈥楲a capital de Colombia es Bogot谩鈥, 鈥楲a 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.

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=[鈥榓pple鈥, 鈥榖anana鈥, 鈥榗herry鈥橾
a2 =[鈥榦range鈥, 鈥榣emon鈥, 鈥榩ineapple鈥橾

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,(鈥榓pple鈥, 鈥榖anana鈥, 鈥榗herry鈥),(鈥榦range鈥, 鈥榣emon鈥, 鈥榩ineapple鈥)))
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