Programando closures
Clase 9 de 21 • Curso Profesional de Python
Contenido del curso
Isay Humberto Lucas Hernandez
student•
hace 5 años
Angel Mejia
student•
hace 4 años
Wilder Bravo
student•
hace 4 años
Isay Humberto Lucas Hernandez
Angel Mejia
Wilder Bravo
José Martínez Santana
Pedro Alvarado Garcia
Angel Mejia
Bruno Cornelio
Omar D
Edwin Ferney Vásquez Hernández
Emmanuel Corral Marco
Carlos Rodríguez
Fabricio González Guasque
Daniel Felipe Montenegro
Pedro Alejandro Silva Perez
Adriel Salguero
Ronald Daniel Mozo Chávez
Fabricio Quintas
Alex Junior Rodriguez Huerta
Adriana Villalobos
Cesar Hernández Ramírez
Thomas Eduardo Medina Sánchez
Alejandro Garcia Chirinos
Daniela Castaño
Billy Rustrian Burgos
Silvana Ramos
César Isaac González Naranjo
Mateo Echavarria
David Leonardo Baron Avilan
Juan Pablo Duque Giraldo
fidel angel ochoa
Jose Manuel Rivas Márquez
Pablo Antipan Quiñenao
Yerson Argote
Yair Hernández
CARLOS AUGUSTO RAMIREZ FRANCO
Jesús Alexis Vega López
Hola,
Encontré que se puede hacer el reto usando una función lambda. El resultado sería el siguiente.
Está genial, el único detalle es que si deseas escribir estático la presencia del : en lambda para los argumentos no te deja asignarle un tipo de dato a x en tu ejemplo.
Y cumple con las 3 características del clousure, gracias Isay.
Reto
Genial el uso del tipado estático.
Qué es lo que hace la clase Generic?
Podemos usar lambda functions aquí:
Buen aporte!! Has la división con doble diagonal te retorna la división en enteros
x: x//n
y con eso 🐍
Pero si sería una nested funtion?
reto ampliado:
Pyrhon 3.9
def tabla_multiplicar(x: int) -> int: def multiplicaciones(n: int) -> int: my_tabla = {i: i*x for i in range(0,n)} return my_tabla return multiplicaciones def run(): tabla_del_5 = tabla_multiplicar(5) tabla_del_5_hasta_330 = tabla_del_5(330) cinco_multiplicado_por = tabla_del_5_hasta_330 print(cinco_multiplicado_por[221]) if __name__ == "__main__": run()
La manera más absurda de multiplicar, aunque se puede sacar toda la tabla en un diccionario, lo cual no está mal jeje muy potente esto de las closure, bravísimo curso :)
Fabuloso :D.
Mi aporte saludos
def make_division_by(n): def division(x: int) -> float: assert n > 0, "El valor ingresado en el divisor debe ser mayor a cero" return round(x/n, 2) return division def run(): division_by_3 = make_division_by(3) division_by_5 = make_division_by(5) division_by_18 = make_division_by(18) print(division_by_3(18)) print(division_by_5(100)) print(division_by_18(54)) print(division_by_3(division_by_5(200))) if __name__ == "__main__": run()
Gracias por tu aporte, tal vez lo unico importante a tener en cuenta es que n si puede ser menor que 0; de esa manera la condición del assert podría ser modificada a "n != 0".
Humilde aporte
def make_division_by(n: int): def division(x: int): assert type(x) == int, 'You have to type an int number' return x/n return division def run(): division_by_3 = make_division_by(3) print(int(division_by_3(18))) division_by_5 = make_division_by(5) print(int(division_by_5(100))) division_by_18 = make_division_by(18) print(int(division_by_18(54))) if __name__ == '__main__': run()
Hola a todos, como andan?
Programe e siguiente codigo
<def divisor(number): def dividendo(n): return n//number return number def run(): divided_by_2= divisor(3) divided_by_1point5= divisor(5) divided_by_1000= divisor(18) number= int(input('Please insert your number: ')) divided_by_2(number) divided_by_1point5(number) divided_by_1000(number) print(f'''Your number was {number}. Divided by 3 is: {divided_by_2(10)}, Divided by 5 is: {divided_by_1point5(10)}, Divided by 18 is: {divided_by_1000(10)} ''') if __name__== '__main__': run()>
Probe con el numero 10, y me arroja :
Traceback (most recent call last): File "c:/Users/adrie/Desktop/Cursos/Curso-profesional-python/make_division_by.py", line 27, in <module> run() File "c:/Users/adrie/Desktop/Cursos/Curso-profesional-python/make_division_by.py", line 16, in run divided_by_2(number) TypeError: 'int' object is not callable
No puedo encotnrar el error, alguine podria decirme com ose repara?
Divided by 3 is tienen que llevar guión bajo y con paréntesis no llaves lo correcto = Divided_by_3_is: (divided_by_2(10))
1 año tarde, pero recién estoy haciendo el curso, fijate que estas retornando "number" en vez de la función, lo correcto es en esta parte:
<def divisor(number): def dividendo(n): return n//number return **dividiendo**
devolver "dividiendo" no el número
Mi aporte
def make_division_by(n: int): def division(d: int) -> float: assert n != 0, "No se puede dividir entre cero" return d / n return division def run(): division_by_3 = make_division_by(0) print(division_by_3(18)) division_by_5 = make_division_by(5) print(division_by_5(100)) division_by_18 = make_division_by(18) print(division_by_18(54)) if __name__ == "__main__": run()
Mi ejercicio resuelto. Me gustaría saber cómo optimizar los asserts para acortar líneas.
Para optimizarlos puedes utiliizar el tipado estático, todas esas verificaciones las harás directamente desde las varibales con el tipado estático. Mira:
from typing import Callable def division_by(n: float) -> Callable[[float], float]: def divisor(m: float) -> float: return m / n return divisor
Hola, yo use un try para poner una sola línea en caso de error.
¿Qué es más eficiente para el código? Utilizar closures con varias funciones anidadas y pasar un parámetro en cada una o simplemente pasarle todos los parámetros a una sola funcion y hacerlo todo ahi? ¿Y porqué?
Reto:
def make_division_by(n) -> int: def division_by(x): assert type(x) == int,"Solo poner numeros enteros" return round(x/n) return division_by def run (): division_by_3 = make_division_by(3) print(division_by_3(18)) division_by_5 = make_division_by(5) print(division_by_5(100)) division_by_18 = make_division_by(18) print(division_by_18(54)) if __name__ == "__main__": run()
Reto cumplido:
def make_division_by(n): """This closure returns a functions that returns the division of an x number by n""" # You have to code here! def divided_by(x): assert type(x) == int, "Solo puedes usar numeros" result = x/n return result return divided_by division_by_3 = make_division_by(3) print(division_by_3(18)) # The expected output is 6 division_by_5 = make_division_by(5) print(division_by_5(100)) # The expected output is 20 division_by_18 = make_division_by(18) print(division_by_18(54)) # The expected output is 3
def make_division_by(n): def divisioner(x): assert type(x) == int, "Solo puedes ingresar numeros positivos" return int(x / n) return divisioner def run(): division_by_3 = make_division_by(3) print(division_by_3(18)) division_by_5 = make_division_by(5) print(division_by_5(100)) division_by_18 = make_division_by(18) print(division_by_18(54)) if __name__ == '__main__': run()
Mi código
def divisor(d): def make_division(D): return D/d return make_division def run(): div_5 = divisor(5) print(div_5(50)) if __name__ == '__main__': run()
Este ejercicio se hace prácticamente igual que el ejercicio de la clase pasada donde realizamos
def make_multiplier(x): def multiplier(n): return x * n return multiplier times10 = make_multiplier(10) times4 = make_multiplier(4) print(times10(5)) print(times4(23))
¿Pero esta vez cambiaríamos ese x * n por un x / m?
Al revés, dividimos n / x, pero si, es relativamente similar, si no casi igual al ejercicio anterior, en concreto este reto fue puesto para que estimulemos nuestra lógica de programación, pero que gran observación!!
Hola, me queda una duda, con estos closures se vuelve mas eficiente el programa a si yo ingreso todos los parametros a una sola funcion y hago todos los proceso alli?
tengo la misma duda.
la probe de la siguiente manera cambiando el string por un int
# Hola 3 -> HolaHolaHola # Facundo 2 -> FacundoFacundo #Platzi4 -> PlatziPlatziPlatziPlatzi def make_repeater_of(n): def repeater(string): return string * n assert type(string) == str, "solo puedes pasar cadenas" return repeater def run(): repeat_5 = make_repeater_of(5) print(repeat_5(int(5))) if __name__ == '__main__': run()
peor a la final me deolvio 2 com resultado y no aplico el assert, no que estoy haciendo mal
Hola Jose! Si retornas la funcion antes de assert, no alcanza a tomar esa linea. Esto es porque al retornar, la funcion sencillamente finaliza (Casa que puede ser MUY util en algunos casos) Creo que este es el comportamiento que esperas
def make_repeater_of(n): def repeater(string): assert type(string) == str, "solo puedes pasar cadenas" return string * n return repeater def run(): repeat_5 = make_repeater_of(5) print(repeat_5(int(5))) if __name__ == '__main__': run()
Saludos!
Ya que estamos con el tema de tipado estático en Python y retorno de funciones. Actualmente se puede especificar que el tipo de retorno en Python es una función?, por ejemplo:
def make_repeater_of(n) -> function: def repeater(string) -> str: return string * n return repeater
El código de arriba no funciona por si alguien lo quiere probar.
Alguien sabe que se puede colocar en lugar de ->function?
En este caso se puede usar el tipo Callable. Es necesario importarlo usando from typing import Callable, y se usa con la sintaxis Callable[[Arg1Type, ...], ReturnType], donde Arg1Type, ... son los tipos de los argumentos que recibe función que se retorna, y ReturnType es el tipo que retorna la función que se retorna.
Puedes revisar más detalles en https://docs.python.org/3.9/library/typing.html#callable
mi solucion
def make_division_by(n: int): def division_by(numero: int): assert type(numero) == int, "Solo puedes utilizar numeros enteros" return int(numero / n) return division_by def run(): division_by_3 = make_division_by(3) print(division_by_3(18)) division_by_5 = make_division_by(5) print(division_by_5(100)) division_by_18 = make_division_by(18) print(division_by_18(54)) if __name__ == '__main__': run()
Hola,
La solución al problema planteado por Facundo
def make_division_by(n): def divider(number): assert type(number) == int, "Solo puedes utilizar enteros" return number/n return divider def run(): divide_by_3 = make_division_by(3) print(divide_by_3(18)) divide_by_5 = make_division_by(5) print(divide_by_5(100)) divide_by_18 = make_division_by(18) print(divide_by_18(54)) if __name__ == '__main__': run()