Crea tu propio método map

def my_map(list, func):
  # Tu código aquí 👈
  return [func(x) for x in list]

def my_map(list, func):
  new_list = []
  for item in list:
    new_list.append(func(item))
  
  return new_list

response = my_map([1, 2, 3, 4], lambda num: num * 2)
print(response)

se veía más complicada 🙆‍♂️ pero gracias hace que quede mas claro el concepto.

def my_map(lista, func):
  # Tu código aquí 👈
  ejecutar = list(map(func, lista))
  print(ejecutar)

Esto quedo muy pequeño.

def my_map(list, func):
  return [func(item) for item in list]
  pass

🛡️🛡️Escudo anti-spoilers🛡️🛡️

Mi solución al reto:

#!/bin/env python3.8
def my_map(list, func):
  return [func(i) for i in list]

solución

def my_map(lista, func):
  return(list(map(func, lista)))

if __name__ == '__main__':
  response = my_map([1, 2, 3, 4], lambda num: num * 2)
  print(response) #Output: [2, 4, 6, 8]

  response = my_map([
    {"name": "michi", "age": 2},
    {"name": "firulais", "age": 6}],
    lambda pet: pet["name"])
  print(response) # ["michi", "firulais"]

Mi solución:
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

def my_map(list, func):
  # Tu código aquí 👈
  return [func(element) for element in list]
  pass

.
.
.
.
.
.
.
.
.
.

Mi código:

def my_map(list, func):
  new_list = []
  for element in list:
    new_list.append(func(element))
  return new_list

def my_map(list, func):
  """Function emular map funciton"""
  return [func(element) for element in list]

if __name__ == '__main__':
  """Start function"""
#  response = my_map([1, 2, 3, 4], lambda num: num * 2)
  response = my_map([
{"name": "michi", "age": 2},
{"name": "firulais", "age": 6}],
lambda pet: pet["name"])
  print(response)

LIsto!
#Lista = [1, 2, 3, 4]
#Funcion = lambda num: num * 2
Lista = [{“name”: “michi”, “age”: 2}, {“name”: “firulais”, “age”: 6}]
Funcion = lambda pet: pet[“name”]
def Map(Lista,Funcion):
print([Funcion(Item) for Item in Lista])
Map(Lista,Funcion)

Solución 😄.
.

.
.
.
.

def my_map(list, func):
  return [func(item) for item in list]

def my_map(list, func):
  return [func(element) for element in list]

def my_map(list, func):
  
    return [func(element) for element in list]

.
.
.
.
.
.
.
.

def map_german(lista, func): # recibimos una lista y una fincion como parametros
  lista_nueva = [] # aqui se almacenaran los elementos que iremos iterando
  for elemento in lista:
    lista_nueva.append(func(elemento)) # recordemos que con append() podemoa agregar elementos a una nueva lista
  return lista_nueva # retornamos todo el ciclo

respuesta = map_german([1,2,3,4,34,12,32], lambda num: num*2) #aqui nuestra funcion nos da 2 argumentos el primero es una lista de numeros y el segundo es una funcion lambda en la cual el parametro num, se multiplicara por 2 y ese valor se almacenara en la lista nueva

print(respuesta) # [2, 4, 6, 8, 68, 24, 64]

respuesta2 = map_german([
{"name": "michi", "age": 2},
{"name": "firulais", "age": 6},
{"name": "rocky", "age": 5},
{"name": "brownie", "age": 3},
{"name": "bebe", "age": 4}],
lambda pet: pet["name"]) # aca nuestra lista sera un diccionario, y la parametro de func sera una lambda que nos dara el nombre de la mascota (valor) con la clave "name" y esto al ejecutarlo en el ciclo se almacenara en la nueva lista
print(respuesta2) # ['michi', 'firulais', 'rocky', 'brownie', 'bebe']

Esto de las HOC tiene su utilidad, yo lo utilizo muy rara vez pero permite hacer mejorar a las funciones ya establecidas.

.
.

def my_map(list, func):
  return [func(i) for i in list]

.
.
.
.
.

def my_map(list, func):
  return [func(x) for x in list]

Aqui les dejo mi solución, fue un ejercicio sencillo:

def my_map(newlist, func):
  return list(func(element) for element in newlist)

.
.
.
.
.
.
.
.
.
.
.
…
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
…
.
.
.
.
.
.
.
.

def my_map(list, func):
  # Tu código aquí 👈
  return [func(elem) for elem in list]

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.

def my_map(list, func):
  return [func(i) for i in list]

result = my_map([1, 2, 3, 4], lambda num: num * 2)
print(result)
print('\n')
# Output: [2, 4, 6, 8]

result_1 = my_map([
{"name": "michi", "age": 2},
{"name": "firulais", "age": 6}],
lambda pet: pet["name"])
print(result_1)
print('\n')
# Output: ["michi", "firulais"]

Muy simple pero ahora si no se me ocurrió la solución, tuve que ver las respuestas

Mi resultado
.
.
.
.
.
.
.
.
.
.
.
.
.
.

def my_map(list, func):
  return [func(i) for i in list]

.
.
.
Listo! 🐍👌🏼
.
.
.
.
.

def my_map(list, func):

  return [func(i) for i in list]

Dejo mi aporte (2 soluciones), una con list comprehension y otra con la vieja conafiable (bucle)

def my_map(list, fun):
  return [fun(i) for i in list]

def my_map(list, fun):
  out = []
  for i in list:
    out.append(fun(i))
  return out

def my_map(list, func):
    return [func(x) for x in list]
    pass 

Aqui mi solucion:
.
.
.
.
.
.
.
.

def my_map(list, func):
  # Tu código aquí 👈
  return [func(item) for item in list]

Mi solución 💻 🐍

.
.
.
.
Mi solución es a una línea aplicando list comprehension para simplificar la solución

def my_map(list, func):
  return [ func(item) for item in list ]
```

o
o
o
o
o
o
o

def my_map(lista, funcion):
  lista_salida = [funcion(x) for x in lista]
  return lista_salida

print(my_map([1, 2, 3, 4], lambda num: num * 2))
print(my_map([
{"name": "michi", "age": 2},
{"name": "firulais", "age": 6}],
lambda pet: pet["name"])) 

my solución
*
*
*
*
*
*
*
*
*
*

def my_map(list, func):
  # Tu código aquí 👈
  return [func(item) for item in list]

.
.
.

def my_map(list, func):
  return [*map(func,list)]

Esta alternativa me corrio nien en VCode, pero aqui no paso las pruebas, la verdad no se porque. Me parece mejor elaborada, aplicando lo aprendido

.
.
.
.
.

.
.
.
.
.

def my_map(list, func):
  return [func(element) for element in list]

*
*
*
*
*

def my_map(list, func):
    new_list = [func(elem) for elem in list]
    return new_list

.
.

def my_map(list, func):
   new_list = []
   for element in list:
      new_list.append(func(element))
   
   return new_list