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

Playgrounds: Multiplica todos los elementos por dos

22/44

Aportes 226

Preguntas 7

Ordenar por:

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

o inicia sesi贸n.

Esta es la soluci贸n que realice:

def multiply_numbers(numbers):
    # Escribe tu soluci贸n 馃憞
    result = list(map(lambda number: number * 2, numbers))
    return result

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

Perd铆 una vida, y aunque los primeros minutos no entend铆a porque. Quite los corchetes al valor que se retorna. Volv铆 a correr las pruebas y afortunadamente las aprob茅 todas:

def multiply_numbers(numbers):
    # Escribe tu soluci贸n 馃憞
    new_list = list(map(lambda x : x * 2, numbers))
    return new_list

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

Retorne una list comprehension y me ahorre una linea.

def multiply_numbers(numbers):
    return [x for x in list(map(lambda i: i*2, numbers))]

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)
numbers = [1, 2, 3, 4]
response = list(map(lambda x: x*2, numbers))
print(response) 

La libertad que nos da Python para hacer funciones donde queramos es incre铆ble, si quieren, no tienen que hacer nada mas que esto en la linea 3 y con eso, esta solucionado.

return list(map(lambda number: number * 2, numbers))

Siento que esta respuesta es buena por la inmutabilidad

def multiply_numbers(numbers):
    new_list = numbers.copy();
    return list(map(lambda x :x*2,new_list))

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(numbers)
print(response)


no me pasaba las pruebas porque no le quitaba los [] en return

Yo escrib铆 esta soluci贸n mas corta utilizando list comprehension, en mi VS Code funciona pero ac谩 no 馃槮

numbers = [1, 2, 3, 4]
response = [number * 2 for number in numbers]
print(response

def multiply_numbers(numbers):
# Escribe tu soluci贸n 馃憞
return list(map(lambda i: i * 2, numbers))


me tarde un rato por que no sabia si teniamos que hacer solo la lista que ya estaba escrita o tambien los ejemplos, aun que estoy orgulloso es la primera vez que lo hago sin ver los aportes xd

Se puede resolver esto en un linea (3 contando el print y la lista inicial)

numbers = [1, 2, 3, 4]
response = list(map(lambda number: number*2, numbers))
print(response)

El Playground no me permiti贸 realizar la ejecuci贸n 馃檨 pero aqu铆 est谩 mi soluci贸n 馃榿

def multiply_numbers(numbers):
  # Escribe tu soluci贸n 馃憞
  result = list(map(lambda x: x * 2, numbers))
  return result
  
numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)

logrado, se puede hacer el return en una linea pero a mi me gusta siempre guardar en variable 馃槂

def multiply_numbers(numbers):
    # Escribe tu soluci贸n 馃憞
    multipli= list(map(lambda num:num*2,numbers))
    return multipli

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

Yo resolvi asi los 2 ejercicios que venian en la guia.

  • En el ejemplo 1, multiplique la lista por 2.
  • En ejemplo 2, cree una nueva lista, la multiplique por la lista que estaba en la guia ejemplo 2.
#Solucion ejemplo 1
def multiply_numbers_v1(numbers):
    # Escribe tu soluci贸n 馃憞
    list_items = list (map(lambda i: i * 2, numbers))
    return list_items


numbers = [1, 2, 3, 4]
response = multiply_numbers_v1(numbers)
print(response)


#Solucion ejemplo 2
def multiply_numbers_v2(numbers_v1, numbers_v2):
    list_items = list (map(lambda x, y: x * y, numbers_v1 ,numbers_v2))
    return list_items


numbers_v1 = [1, 1, -2, -3]
numbers_v2 = [1, 1, 2, 2]
response = multiply_numbers_v2(numbers_v1, numbers_v2)
print(response)
```python def multiply_numbers(numbers): new_list = list(map(lambda x:x *2, numbers)) return new_list numbers = [1, 2, 3, 4] response = multiply_numbers(numbers) print(response) ```
Mas retos en los cursos
```js def multiply_numbers(numbers): # Escribe tu soluci贸n 馃憞 return list(map(lambda number:number * 2, numbers)) numbers = [1, 2, 3, 4] response = multiply_numbers(numbers) print(response) ```def multiply\_numbers(numbers): # Escribe tu soluci贸n 馃憞 return list(map(lambda number:number \* 2, numbers)) numbers = \[1, 2, 3, 4]response = multiply\_numbers(numbers)print(response)

Simple is better than complex.

def multiply_numbers(numbers):
    # Escribe tu soluci贸n 馃憞
    
    #return list(map(lambda number: number * 2, numbers)) # unnecessary map usage
    return [i * 2 for i in numbers]
    

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)
Encontr茅 una soluci贸n con menos l铆neas de c贸digo pero el sistema no lo toma como una respuesta correcta: ![](https://static.platzi.com/media/user_upload/image-fbe460f2-6e75-43ca-94cc-384bd513381a.jpg)![]()

def multiply_numbers(lista:list) -> None:
return list(map(lambda number: number*2,lista))

def main():
lista_numeros = [1,2,3,4]
resultado = multiply_numbers(lista_numeros)
print(resultado)

if name==鈥main鈥:
main()

```js def multiply_numbers(numbers): return list(map(lambda number: number*2,numbers)) numbers = [1, 2, 3, 4] response = multiply_numbers(numbers) print(response) ```Mi soluci贸n

Solucion al reto.

def multiply_numbers(numbers):
    # Escribe tu soluci贸n 馃憞
    multiply_numbers = list(map(lambda x: x*2, numbers))
    return multiply_numbers

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)
No entiendo por que no funciona de esta manera:numbers = \[1, 2, 3, 4]response = list(map(lambda x : x\*2, numbers))print(response) ```js numbers = [1, 2, 3, 4] response = list(map(lambda x : x*2, numbers)) print(response) ```

def multiply_numbers(numbers):
# Escribe tu soluci贸n 馃憞馃く
new_list = list(map(lambda number : number * 2, numbers))
return new_list

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

Ac谩 estan dos formas en las cuales pude llegar a la soluci贸n:

#C贸digo 1

multiply_numbers = lambda numbers: list(map(lambda number: number*2,numbers))

numbers = [1, 1, -2, -3]
response = multiply_numbers(numbers)
print(response)

#C贸digo 2
def multiply_numbers(numbers):
    response = list(map(lambda number: number*2,numbers))
    return response

numbers = [1, 1, -2, -3]
response = multiply_numbers(numbers)
print(response)

Me gusta especialmente la segunda opci贸n. A pesar de que el C贸digo 1 est谩 m谩s resumido, la segunda me parece m谩s detallada.

def multiply_numbers(numbers):
    output=list(map(lambda n:n*2,numbers))
    return output

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)
def multiply\_numbers(numbers):聽 聽 # Escribe tu soluci贸n 馃憞 聽 聽 return \[i\*2 for i in numbers] numbers = \[1, 2, 3, 4]response = multiply\_numbers(numbers)print(response)

Es interesante este reto. Cada vez se ve los ejercicios de python mas sencillos. Eso ayuda a mejorar tu capacidad y estar listo para el data science.

Utilice este metodo: ![](https://static.platzi.com/media/user_upload/image-8c243b1e-458f-4257-ac05-028fbfba2fad.jpg)
`def multiply_numbers(numbers):聽 聽 ` `return list(map(lambda number: number*2, numbers))` `numbers = [1, 2, 3, 4]` `response = multiply_numbers(numbers)` `print(response)`
numbers = \[1, 2, 3, 4] response = list(map(lambda i: i\*2, numbers)) print(response)
Hola a todos Comparto la soluci贸n realizada ![]()def multiply\_numbers(numbers):聽 聽 # Escribe tu soluci贸n 馃憞聽 聽 """聽 聽 multiply =\[]聽 聽 for i in numbers:聽 聽 聽 聽 multiply.append(i\*2)聽 聽 return multiply聽 聽 """聽 聽 multiply = list(map(lambda x: x\*2,numbers))聽 聽 return multiply numbers = \[1, 2, 3, 4]response = multiply\_numbers(numbers)print(response)```js def multiply_numbers(numbers): # Escribe tu soluci贸n 馃憞 """ multiply =[] for i in numbers: multiply.append(i*2) return multiply """ multiply = list(map(lambda x: x*2,numbers)) return multiply numbers = [1, 2, 3, 4] response = multiply_numbers(numbers) print(response) ```
```js def multiply_numbers(numbers): resultado=list(map(lambda x:x*2, numbers)) return resultado ```def multiply\_numbers(numbers):聽 聽 resultado=list(map(lambda x:x\*2, numbers))聽 聽 return resultado
![](https://static.platzi.com/media/user_upload/image-4a8b46c9-4f87-4ace-99de-601e15524492.jpg)

reto

def multiply_numbers(numbers):
    # Escribe tu soluci贸n 馃憞
    num = list(map(lambda i : i * 2, numbers))
    return num
    

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)
def multiply\_numbers(numbers):聽 聽 # Escribe tu soluci贸n 馃憞聽 聽 return list(map(lambda i : i \* 2, numbers)) numbers = \[1, 2, 3, 4]response = multiply\_numbers(numbers)print(response)
def multiply\_numbers(numbers): \# Escribe tu soluci贸n 馃憞 return list(map(lambda i : i \* 2, numbers)) numbers = \[1, 2, 3, 4] response = multiply\_numbers(numbers) print(response)
\

![]()def multiply\_numbers(numbers):\

\

# Escribe tu soluci贸n 馃憞\

\

聽 聽 return list(map(lambda i : i \* 2, numbers))\

\

numbers = \[1, 2, 3, 4]response = multiply\_numbers(numbers)print(response)\

![]()
def multiply\_numbers(numbers):聽 return list(map(lambda i: i\*2, numbers)) numbers = \[1, 2, 3, 4] response = multiply\_numbers(numbers)print(response)
```js def multiply_numbers(numbers): # Escribe tu soluci贸n 馃憞 return list(map(lambda n: n * 2, numbers)) numbers = [1, 2, -3, -4] response = multiply_numbers(numbers) print(response) ```

Paso 1: Definir la funci贸n multiply_numbers(numbers).

  • En este paso, estamos creando una funci贸n llamada multiply_numbers que acepta una lista de n煤meros como entrada. La funci贸n a煤n no hace nada, solo estamos diciendo que vamos a escribir el c贸digo que realizar谩 una tarea espec铆fica.
pythonCopy code
def multiply_numbers(numbers):
    # Escribe tu soluci贸n 馃憞
    return []

Paso 2: Definir la lista de n煤meros.

  • Creamos una lista llamada numbers que contiene algunos n煤meros, en este caso [1, 2, 3, 4]. Esta es la lista que queremos multiplicar por 2.
pythonCopy code
numbers = [1, 2, 3, 4]

Paso 3: Llamar a la funci贸n multiply_numbers(numbers) con la lista de n煤meros como argumento.

  • En este paso, estamos llamando a la funci贸n multiply_numbers() que definimos en el Paso 1. Le estamos pasando la lista de n煤meros [1, 2, 3, 4] como argumento. Esto significa que la funci贸n recibir谩 esta lista y realizar谩 alguna operaci贸n en ella.
pythonCopy code
response = multiply_numbers(numbers)

Paso 4: Definir la funci贸n lambda dentro de map().

  • Dentro de la funci贸n multiply_numbers(), estamos utilizando la funci贸n map() para realizar una operaci贸n en cada n煤mero de la lista. La funci贸n map() toma dos argumentos: una funci贸n y una lista (o iterable).
pythonCopy code
multiplied_numbers = list(map(lambda x: x * 2, numbers))

  • La parte lambda x: x * 2 es una funci贸n peque帽a y an贸nima (sin nombre) llamada una funci贸n lambda. Lo que hace es tomar un n煤mero x y multiplicarlo por 2. As铆 que, por ejemplo, si x es 3, la funci贸n lambda devuelve 6.

Paso 5: Convertir el resultado en una lista.

  • El resultado de map() no es una lista directamente, es un tipo especial de objeto llamado map. Queremos tener los resultados en una lista, por lo que utilizamos list() para convertir ese objeto map en una lista real.
pythonCopy code
multiplied_numbers = list(map(lambda x: x * 2, numbers))

Paso 6: Retornar la lista resultante.

  • Finalmente, retornamos la lista resultante que contiene los n煤meros multiplicados por 2.
pythonCopy code
return multiplied_numbers

Paso 7: Imprimir la lista resultante.

  • Despu茅s de llamar a la funci贸n multiply_numbers(), tenemos la lista resultante almacenada en la variable response. Ahora, imprimimos esta lista en la pantalla.
pythonCopy code
print(response)

def multiply_numbers(numbers):
    # Utiliza map() con una funci贸n lambda para multiplicar cada n煤mero por 2
    multiplied_numbers = list(map(lambda x: x * 2, numbers))
    
    return multiplied_numbers

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)
![](https://static.platzi.com/media/user_upload/Screenshot%202023-09-27%20at%2001.48.48-e5d3c908-fc22-4cda-a3d3-4ce59af4a3f3.jpg)
he aqui mi solucion \<def multiply\_numbers(numbers):聽 聽 return list(map(lambda x: x \* 2,numbers)) numbers = \[1, 2, 3, 4]response = multiply\_numbers(numbers)print(response)>

mi respuesta a este reto:

def multiply_numbers(numbers):
result = list(map(lambda i: i * 2, numbers))
return result

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

producto = list(map(lambda x : x*2, numbers))

def multiply_numbers(number):
product = [number *2 for number in numbers]
return product

Me perd铆a mucho porque no sabia que la funci贸n lambda deb铆a ir en la funcion multiply_numbers().
Mi soluci贸n 鈫撯啌鈫

.
.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.

def multiply_numbers(numbers):
    result = list(map(lambda i: i * 2, numbers))
    return result

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

Con la primera clase de MAPS y entendiendo bien que hace RESULT se puede hacer solo a帽adiendo una l铆nea de c贸digo.

def multiply_numbers(numbers):
    # Escribe tu soluci贸n 馃憞
    return list(map(lambda i: i * 2, numbers))

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

RETO
Si conservamos los [ ] al retornar la funci贸n tendriamos como resultado como se observa en la imagen.

No es necesario incoporarlos ya que de por si la funcion list() retorna una lista.

def multiply_numbers(numbers):
    # Escribe tu soluci贸n 馃憞
    return list(map(lambda x: x * 2, numbers))

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

ef multiplay_numbers(numbers):
result =list(map(lambda a: a * 5, numbers))
return result

numbers = [1, 2, 3, 4]
response = multiplay_numbers(numbers)
print(response)
mi copia le soy honesto me falta mucho a pesar de mi empe帽o me aferro mi teta es a prender

def multiply_numbers(numbers):
# Escribe tu soluci贸n 馃憞
multiply = list(map(lambda x : x*2, numbers))
return multiply

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

def multiply_numbers(numbers):
# Escribe tu soluci贸n 馃憞
return list(map(lambda x: x * 2, numbers))
numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

def multiply_numbers(numbers):
    
    return list(map(lambda i:i*2,numbers))
numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)```

Mi soluci贸n:

def multiplicaciones (numero):
return list(map(lambda x: x *2, numero))
numero = [-1,-1,-3,-4]
resultados = multiplicaciones(numero)
print(resultados)

Esta es mi solucion con lambda y con funcion definida

#Con Funcion definida
def multiply_numbers(numbers):
    return numbers * 2

numbers = [1, 2, 3, 4]
response = list(map(multiply_numbers,numbers))
print(response)

#Con lambda

numbers = [1, 2, 3, 4]
response = list(map(lambda nm : nm * 2,numbers))
print(response)

def multiply_numbers(numbers):
multiplied_numbers = list(map(lambda num: num * 2, numbers))
return multiplied_numbers

numbers = [2, 4, 5, 6, 8]
response = multiply_numbers(numbers)
print(response)

Solo hay que utilizar map y la lambda function como return dentro de la funci贸n, recuerden que se trata de aplicar map y lambda function.

def multiply_numbers(numbers):
    # Escribe tu soluci贸n 馃憞
#utilizo map para modificar la lista original
#utilizo una funcion lambda para duplicar cada iteraci贸n
    return list(map(lambda x: x * 2, numbers))

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

no pasa las pruebas pero funciona ING Portilla

def multiply_numbers(numbers):
# Escribe tu soluci贸n 馃憞
return []

numbers = [1, 2, 3, 4]
response = list(map ( lambda element: element*2, numbers))
print(response)

Esta es mi soluci贸n:

def multiply_numbers(numbers):
    # Escribe tu soluci贸n 馃憞
    return list(map(lambda number: number * 2, numbers))

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

MI soluci贸n:

def multiply_numbers(numbers):
    new_num = numbers.copy()
    new_num = list(map(lambda num: num*2, new_num))
    return new_num

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

Todo en el mismo return! Algo que aprend铆 de Kaggle xd

def multiply_numbers(numbers):
    # Escribe tu soluci贸n 馃憞
    return list(map(lambda i: i * 2, numbers))

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

Mi soluci贸n

def multiply_numbers(numbers):
    # Escribe tu soluci贸n 馃憞
    hola = [element * 2 for element in numbers]
    return hola

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)
def multiply_numbers(numbers): 
    # Escribe tu soluci贸n 馃憞
    return list(map(lambda i : i*2, numbers))

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)```


.
.
.
Listo! 馃悕馃憣馃徏
.
.
.
.
.

def multiply_numbers(numbers):
    return list(map(lambda x: x*2, numbers))

def multiply_numbers(numbers):
# Escribe tu soluci贸n 馃憞
return list(map(lambda x: x * 2, numbers))

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

# Multiplica todos los elementos por dos

# Que bonito se siente el haber hecho esto s贸lo y a la primera en menos de 2 min =D

def duplicados(lista_numeros): # definimos una funcion llamada duplicados con su parametro lista_numeros
  resultado = list(map(lambda num: num*2, lista_numeros)) # creamos la variable resultado la cual contiene la funcion map que esta misma contiene una funncion lambda que multiplicara por 2 casa numero de la lista_numeros y tambien usamos list para poderimprimirlos como lista
  return resultado # recordemos que si no ponemos list en antes de la fuincion map lo podemos poner aqui antes de resultado para que no nos imprima un valor iterable

# en la solucion lo ponen despues del return solo que ahi ya no creas la variable resultado

# return list(map(lambda num: num*2, lista_numeros))

lista_numeros = [1,2,3,4,5,6] 

respuesta = duplicados(lista_numeros)
print(respuesta) # [2, 4, 6, 8, 10, 12]


.
.
.
.
.
.
.

def multiply_numbers(numbers):
    new = list(map(lambda i: i * 2, numbers))
    return new

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

Aqu铆 la mi soluci贸n, estos ejercicios son muy buenos para repasar las clases

def multiply_numbers(numbers):
    # Escribe tu soluci贸n 馃憞
    return list(map(lambda number: number * 2, numbers))

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

Para los que se preguntan del ejemplo 2 del enunciado, se trata de un error de tipeo, todas las pruebas del playground verifican que la lista este multiplicada por 2

def multiply_numbers(numbers):
    # Escribe tu soluci贸n 馃憞
    result = list(map(lambda i : i*2,numbers))
    return result

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)
def multiply_numbers(numbers):
    return list(map(lambda x: x * 2, numbers))

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

Esta fue mi solucion ,me costo un poco entenderla pero nada fuera de lo comun

<def multiply_numbers(numbers):
    # Escribe tu soluci贸n 馃憞
    result_1=list(map(lambda x:x*2,numbers))
    return result_1

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)> 

Soluci贸n:

def multiply_numbers(numbers):
    # Escribe tu soluci贸n 馃憞
    return list(map(lambda x : x*2, numbers))

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

aqui hice una version super optimizada de la respuesta 馃槃

multiply_numbers = lambda num: list(map(lambda dat: dat*2, num))

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)
def multiply_numbers(numbers):
    # Escribe tu soluci贸n 馃憞
    juan=list(map(lambda x:x*2,numbers))
    return juan

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

Para practicar hice un ejercicio con ra铆z cuadrada:

def raiz_cuadrada(numbers):
  result = list(map(lambda number: number ** (1/2), numbers))
  return result

numbers = [1, 9, 25, 49, 81]
response = raiz_cuadrada(numbers)
print(response)

Me encantan los playgrounds

No m qued贸 muy claro para que sirve la funci贸n multiply_numbers(). Yo la omit铆 y cargu茅 la map function directamente en la definici贸n de la variable response. Al imprimirla y ejecutar me funciona bien, as铆:

numbers = [1, 2, 3, 4]
response = list(map(lambda i:i*2, numbers))
print(response)

Pero al correr las pruebas me arrojaba error. Entonces me di cuenta de que se me exig铆a usar la funci贸n multiply_numbers() e hice esto:

def multiply_numbers(numbers):
    return list(map(lambda i:i*2, numbers))

numbers = [1, 2, 3, 4]
response = list(map(lambda i:i*2, numbers))
print(response)

La defin铆 pero ni siquiera la llame y ah铆 s铆 me acept贸 la respuesta .________.

def multiply_numbers(numbers):
    # Escribe tu soluci贸n 馃憞
    valorespor2 = list(map(lambda numbers:numbers*2,numbers))
    return valorespor2

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

.
.
.
.
.
.

def multiply_numbers(numbers):
    # Escribe tu soluci贸n 馃憞
    return list(map(lambda item:item*2,numbers))

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

Versi贸n cort铆sima 馃槅

multiply_numbers = lambda n: list(map(lambda x : x * 2, n))

interesante lo de ahorrarse una local variable, de todas maneras, funciona. Aunque no lo sent铆 como reto, pues el profe pr谩cticamente habia dado la soluci贸n, pero ch茅vere sirve para practicar el concepto.

asi salio -----> def multiply_numbers(numbers):
new_value = list(map(lambda iterable: iterable * 2 ,numbers))
return new_value

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

def multiply_numbers(numbers):
    # Escribe tu soluci贸n 馃憞
    operateNumbers = list(map(lambda numbers: numbers * 2, numbers))
    return operateNumbers

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)
def multiply_numbers(numbers):
    # Escribe tu soluci贸n 馃憞
    arreglo= list(map(lambda x: x*2, numbers))
    return arreglo

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)
def multiply_numbers(numbers):
    return list(map(lambda x: x * 2, numbers))
    
numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

numeros=[1,2,3,4,5]
numero_2=list(map(lambda i:i*2,numeros))
print(numero_2)

Ac谩 la respuesta

Me tard茅 un poco, estuvo genial este ejercicio

def multiply_numbers(numbers):
    # Escribe tu soluci贸n 馃憞
    return [x for x in list(map(lambda i:i*2, numbers))]

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

_solo me gu铆e del archivo 鈥14_map.py鈥

def multiply_numbers(numbers):
    # Escribe tu soluci贸n 馃憞
    return [x for x in list(map(lambda i: i*2, numbers))]

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

Buenas noches, aqui mi solucion, tomando en cuenta lo dicho en clase de no alterar la variable original, sino crear una copia apartir de ello usando el Map

def multiply_numbers(numbers):
    # Escribe tu soluci贸n 馃憞
    new_list = numbers.copy()
    result= list(map(lambda i:i*2,numbers))
    return result

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

La solucion tambien se puede emplear sin definir la funcion que pone , puede ser asi

numbers = [1, 2, 3, 4]
response = list(map(lambda x: x*2, numbers))
print(response)

usas menos codigo que con metodos primitivos

def multiply_numbers(numbers):
    # Escribe tu soluci贸n 馃憞
    mult = list(map(lambda x: x * 2,numbers))
    return mult

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)
def multiply_numbers(numbers):
    # Escribe tu soluci贸n 馃憞
    return list(map(lambda x: x * 2, numbers))
    
numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

xD

response = list(map(lambda x: x*2, [x for x in range(1,5)]))
print(response)
undefined