Merge pull request mouredev#5877 from fborjalv/fborjalv-branch

#21 - Python

Author: kontroldev

Roadmap/21 - CALLBACKS/python/fborjalv.py

@@ -0,0 +1,62 @@
+import time
+import random
+import threading
+
+"""
+/*
+ * EJERCICIO:
+ * Explora el concepto de callback en tu lenguaje creando un ejemplo
+ * simple (a tu elección) que muestre su funcionamiento.
+"""
+def saludar(name):
+    print(f"¿Cómo estás? {name}")
+
+def ejecutar_callback(name, callback):
+    print("Este saludo es está ejecutando desde una callback: ")
+    callback(name)
+
+saludar("Borja")
+
+ejecutar_callback("Mouredev", saludar)
+
+
+"""
+ * DIFICULTAD EXTRA (opcional):
+ * Crea un simulador de pedidos de un restaurante utilizando callbacks.
+ * Estará formado por una función que procesa pedidos.
+ * Debe aceptar el nombre del plato, una callback de confirmación, una
+ * de listo y otra de entrega.
+ * - Debe imprimir un confirmación cuando empiece el procesamiento.
+ * - Debe simular un tiempo aleatorio entre 1 a 10 segundos entre
+ *   procesos.
+ * - Debe invocar a cada callback siguiendo un orden de procesado.
+ * - Debe notificar que el plato está listo o ha sido entregado.
+ */
+
+"""
+
+
+def order_process(dish, confirm, ready, delivering):
+    def process():
+        print(f"Hemos recibido su pedido que incluye {dish}")
+        time.sleep(random.randint(1, 10))
+        confirm(dish)
+        ready(dish)
+        delivering(dish)
+    threading.Thread(target=process).start()
+
+def confirm_callback(dish):
+    print(f"Su pedido que incluye {dish} se está procesando")
+    time.sleep(random.randint(1, 10))
+
+def ready_callback(dish):
+    print(f"Su pedido que incluye {dish} está listo. Se entregará en los próximos minutos")
+    time.sleep(random.randint(1, 10))
+
+def deliver_callback(dish):
+    print(f"Su pedido que incluye {dish} ha sido entregado correctamente")
+
+
+order_process("gambas", confirm_callback, ready_callback, deliver_callback)
+order_process("ternera", confirm_callback, ready_callback, deliver_callback)
+order_process("mouse", confirm_callback, ready_callback, deliver_callback)

Roadmap/22 - FUNCIONES DE ORDEN SUPERIOR/python/fborjalv.py

@@ -0,0 +1,118 @@
+
+from functools import reduce
+from datetime import date, datetime
+"""
+* EJERCICIO:
+ * Explora el concepto de funciones de orden superior en tu lenguaje 
+ * creando ejemplos simples (a tu elección) que muestren su funcionamiento.
+
+"""
+# Función como argumento 
+
+def saluda(name, saluda_callback):
+    saluda_callback(name)
+
+def texto(name):
+    print(f"Hola {name}, como estás?")
+
+saluda("Brais", texto)
+
+# Función como retorno 
+
+def concatena_strings(name):
+    def get_last_name(last_name):
+        return name + " " + last_name
+    return get_last_name
+name = concatena_strings("Borja") # devuelve función
+print(name("Lv")) #utlizamos función
+print(concatena_strings("Brais")("Moure")) # pasamos todos los argumentos
+
+
+# Sistema: map(), filter(), sorted(), reduce
+
+my_list = ["Brais", "Borja", "María", "Sonia"]
+
+
+# map
+
+def to_lower(name):
+    return name.lower()
+
+print(list(map(to_lower, my_list))) # aplica la función a todos los elementos de un iterable
+
+
+# filter: 
+
+def filter_by_name(name):
+    return name[0] == "B"
+
+print(list(filter(filter_by_name, my_list)))
+
+
+# sorted
+
+print(sorted(my_list))
+print(sorted(my_list, reverse=True))
+print(sorted(my_list, key=lambda x: x))
+
+# reduce
+
+def reduce_one_line(x, y):
+    return x + " " + y
+
+print(reduce(reduce_one_line, my_list))
+
+"""
+DIFICULTAD EXTRA (opcional):
+ * Dada una lista de estudiantes (con sus nombres, fecha de nacimiento y 
+ * lista de calificaciones), utiliza funciones de orden superior para
+ * realizar las siguientes operaciones de procesamiento y análisis:
+ * - Promedio calificaciones: Obtiene una lista de estudiantes por nombre
+ *   y promedio de sus calificaciones.
+ * - Mejores estudiantes: Obtiene una lista con el nombre de los estudiantes
+ *   que tienen calificaciones con un 9 o más de promedio.
+ * - Nacimiento: Obtiene una lista de estudiantes ordenada desde el más joven.
+ * - Mayor calificación: Obtiene la calificación más alta de entre todas las
+ *   de los alumnos.
+ * - Una calificación debe estar comprendida entre 0 y 10 (admite decimales).
+
+"""
+
+student_list = [
+    {"nombre": "Brais", "fecha_nacimiento": "29-04-1987", "calificaciones": [10, 3, 5, 8]},
+    {"nombre": "Borja", "fecha_nacimiento": "29-04-1992", "calificaciones": [7, 6, 5, 9]},
+    {"nombre": "Sonia", "fecha_nacimiento": "30-05-1999", "calificaciones": [2, 10, 10, 4]},
+    {"nombre": "María", "fecha_nacimiento": "13-01-1985", "calificaciones": [4, 3, 4, 6]},
+]
+
+def calcular_promedio_calificaciones(calificaciones):
+    return(sum(calificaciones)/len(calificaciones))
+
+
+print("Promedio de calificaciones")
+print(list(map(lambda student: {"name": student["nombre"], "grades": calcular_promedio_calificaciones(student["calificaciones"])}, student_list)))
+
+print("Mejores estudiantes")
+
+print(
+    list(
+        map(lambda student: 
+        student["nombre"], 
+        filter(lambda student: calcular_promedio_calificaciones(student["calificaciones"]) >=5, student_list)
+        )
+    )
+)
+
+print("Nacimientos")
+
+def formatear_fechas(dates):
+    return datetime.strptime(dates, "%d-%m-%Y").date()
+
+print(list(map(lambda student:
+                    student["nombre"], 
+                    sorted(student_list, key= lambda student: formatear_fechas(student["fecha_nacimiento"]), reverse=True)
+                    )))
+
+print("Mayor calificación")
+
+print(max(map(lambda student: max(student["calificaciones"]), student_list)))

Roadmap/23 - SINGLETON/python/fborjalv.py

@@ -0,0 +1,82 @@
+
+"""
+/*
+ * EJERCICIO:
+ * Explora el patrón de diseño "singleton" y muestra cómo crearlo
+ * con un ejemplo genérico.
+ *
+"""
+
+class Singleton():
+    
+    _instance = None
+
+    def __new__(cls):
+        if not cls._instance:
+            cls._instance = super(Singleton, cls).__new__(cls)
+        return cls._instance
+
+class SonSingleton(Singleton):
+    pass
+
+my_singleton1 = Singleton()
+my_singleton2 = Singleton()
+my_singleton3 = SonSingleton()
+print(my_singleton1)
+print(my_singleton2)
+print(my_singleton3)
+
+"""
+
+ * DIFICULTAD EXTRA (opcional):
+ * Utiliza el patrón de diseño "singleton" para representar una clase que
+ * haga referencia a la sesión de usuario de una aplicación ficticia.
+ * La sesión debe permitir asignar un usuario (id, username, nombre y email),
+ * recuperar los datos del usuario y borrar los datos de la sesión.
+ */
+
+"""
+
+class UserSession: 
+
+    id = None
+    username = None
+    nombre = None
+    email = None
+    _instance = None
+
+    def __new__(cls):
+        if not cls._instance:
+            cls._instance = super(UserSession, cls).__new__(cls)
+        return cls._instance
+
+    def new_user(self, id, username, nombre, email):
+        self.id = id
+        self.username = username
+        self.nombre = nombre
+        self.email = email
+    def show_data_user(self):
+        print(f"{self.id , self.username, self.nombre, self.email}")
+
+    def clean_data(self):
+        self.id = None
+        self.username = None
+        self.nombre = None
+        self.email = None
+        
+
+
+
+session1 = UserSession()
+session2 = UserSession()
+print(session1)
+print(session2)
+
+session3 = UserSession()
+session3.new_user(1, "fborjalv", "Borja", "xxxxx@gmail.com")
+session3.show_data_user()
+session3.clean_data()
+
+session4 = UserSession()
+session4.show_data_user()
+

Roadmap/24 - DECORADORES/python/fborjalv.py

@@ -0,0 +1,56 @@
+"""
+/*
+ * EJERCICIO:
+ * Explora el concepto de "decorador" y muestra cómo crearlo
+ * con un ejemplo genérico.
+
+"""
+
+def decorator_operations(function):
+    def show_name(*args):
+        print(f"Estás utilizando la función {function.__name__}:")
+        return function(*args)
+    return show_name
+
+
+@decorator_operations
+def sumar(a, b):
+    print(f"{a} + {b} = {a+b}") 
+
+def resta(a, b):
+    print(f"{a} - {b} = {a-b}")  
+
+def multiplica(a, b):
+    print(f"{a} x {b} = {a*b}") 
+
+sumar(2, 4)
+resta(2, 4)
+multiplica(2, 4)
+
+"""
+ *
+ * DIFICULTAD EXTRA (opcional):
+ * Crea un decorador que sea capaz de contabilizar cuántas veces
+ * se ha llamado a una función y aplícalo a una función de tu elección.
+ */
+
+"""
+
+
+def func_counter(function):
+    
+    def counter(*args):
+        counter.call_counter +=1
+        print(f"La función {function.__name__} se ha ejecutado {counter.call_counter} veces")
+        return function(*args)
+    counter.call_counter = 0
+    return counter
+
+
+@func_counter
+def saludo(name):
+    print(f"Hola, {name} ¿Cómo estás?")
+
+
+for name in ["Brais", "Borja", "Sonia"]:
+    saludo(name)