Merge pull request mouredev#4236 from Aldroide/main

Modificación al ejercicio #21, ejercicios  #22, #23 y #24

Author: Roswell468

Roadmap/21 - CALLBACKS/python/Aldroide.py

@@ -5,18 +5,19 @@
 
 import random
 import time
+import threading
 
 
-def saludar(nombre):
-    print(f"Hola {nombre}")
+def saludar(nombre, callback):
+    print("Ejecutando saludo...")
+    callback(nombre)
 
 
-def EntradaUsuario(callback):
-    nombre = input("Ingresa tu nombre: ")
-    callback(nombre)
+def EntradaUsuario(nombre):
+    print(f"Hola, {nombre}!")
 
 
-EntradaUsuario(saludar)
+saludar("aldo", EntradaUsuario)
 
 """DIFICULTAD EXTRA (opcional):
     Crea un simulador de pedidos de un restaurante utilizando callbacks.
@@ -30,36 +31,34 @@ def EntradaUsuario(callback):
 
 
 # Definir las funciones callback
-
-def confirm(dish):
+def order_process(dish, confirm_callback, ready_callback, delivered_callback):
+    def process():
+        confirm_callback(dish)
+        # Simula el tiempo de preparación
+        prep_time = random.randint(1, 10)
+        time.sleep(prep_time)
+        ready_callback(dish)
+        # Simula el tiempo de entrega
+        delivery_time = random.randint(1, 10)
+        time.sleep(delivery_time)
+        delivered_callback(dish)
+    threading.Thread(target=process).start()
+
+
+def confirm(dish: str):
     print(f"Pedido confirmado: {dish}")
 
 
-def ready(dish):
+def ready(dish: str):
     print(f"Plato listo: {dish}")
 
 
-def deliver(dish):
+def delivered(dish: str):
     print(f"Pedido entregado: {dish}")
 
 # Función que procesa los pedidos
 
 
-def process(dish, confirm, ready, deliver):
-    # Confirmar el pedido
-    confirm(dish)
-
-    # Simula el tiempo de preparación
-    prep_time = random.randint(1, 10)
-    time.sleep(prep_time)
-    ready(dish)
-
-    # Simula el tiempo de entrega
-    delivery_time = random.randint(1, 10)
-    time.sleep(delivery_time)
-    deliver(dish)
-
-
 # Simular el procesamiento de un pedido
 dish = input("¿Que desea ordenar? ")
-process(dish, confirm, ready, deliver)
+order_process("Limon", confirm, ready, delivered)

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

@@ -0,0 +1,121 @@
+from functools import reduce
+from datetime import datetime
+
+"""
+    Explora el concepto de funciones de orden superior en tu lenguaje 
+    creando ejemplos simples (a tu elección) que muestren su funcionamiento.
+"""
+# funcion como argumento
+
+
+def apply_func(func, x):
+    return func(x)
+
+
+x = apply_func(len, "Aldroide")
+print(x)
+
+# retorno de funcion
+
+
+def apply_mult(n):
+    def mult(x):
+        return x*n
+    return (mult)
+
+
+x = apply_mult(2)
+
+mult = apply_mult(2)
+print(mult(5))
+
+# Sistema
+numbers = [1, 3, 4, 2, 5]
+
+# map
+
+
+def apply_double(n):
+    return n*2
+
+
+print(list(map(apply_double, numbers)))
+
+
+# filter
+def is_even(n):
+    return n % 2 == 0
+
+
+print(list(filter(is_even, numbers)))
+
+# sorted()
+print(sorted(numbers))
+print(sorted(numbers, reverse=True))
+print(sorted(numbers, key=lambda x: -x))
+
+# reduce()
+
+
+def sum_values(x, y):
+    return x + y
+
+
+print(reduce(sum_values, numbers))
+
+
+"""
+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
+            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).
+"""
+
+students = [
+    {"name": "Aldroide", "birthdate": "29-04-1983",
+        "grades": [9.5, 8.5, 9.9, 10]},
+    {"name": "Richard", "birthdate": "04-08-1983", "grades": [7.5, 9.5, 7, 6]},
+    {"name": "Emmanuel", "birthdate": "15-12-2000",
+        "grades": [6, 8.5, 9.5, 8.2]},
+    {"name": "Samira", "birthdate": "25-01-1980", "grades": [10, 9, 9.7, 9.9]}
+]
+
+
+def average(grades):
+    return sum(grades)/len(grades)
+
+
+# Promedio
+print(
+    list(map(lambda student: {
+        "name": student["name"],
+        "average": average(student["grades"])}, students)
+    )
+)
+
+
+# Mejores
+print(
+    list(map(lambda student:
+            student["name"],
+            filter(lambda student: average(student["grades"]) >= 9, students)
+            )
+        )
+)
+
+# Fecha de naciemiento ordenada
+print(sorted(students, key=lambda student: datetime.strptime(
+    student["birthdate"], "%d-%m-%Y"), reverse=True))
+
+
+# Califiación más alta
+
+print(max(map(lambda student: max(student["grades"]), students)))

Roadmap/23 - SINGLETON/python/Aldroide.py

@@ -0,0 +1,76 @@
+"""
+    Explora el concepto de funciones de orden superior en tu lenguaje 
+    creando ejemplos simples (a tu elección) que muestren su funcionamiento.
+"""
+
+
+class Singleton():
+    _instance = None
+
+    def __new__(cls):
+        if not cls._instance:
+            cls._instance = super(Singleton, cls).__new__(cls)
+        return cls._instance
+
+
+singleton1 = Singleton()
+print(singleton1)
+singleton2 = Singleton()
+print(singleton2)
+
+"""
+    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).
+
+"""
+
+
+class UserSession():
+    _instance = None
+
+    id = int
+    username = str
+    name = str
+    email = str
+
+    def __new__(cls):
+        if not cls._instance:
+            cls._instance = super(UserSession, cls).__new__(cls)
+        return cls._instance
+
+    def set_user(self, id, name, username, email):
+        self.id = id
+        self.username = username
+        self.name = name
+        self.email = email
+
+    def get_user(self):
+        return f"{self.id},{self.username},{self.name},{self.email}"
+
+    def clear_user(self):
+        self.id = None
+        self.username = None
+        self.name = None
+        self.email = None
+
+
+session1 = UserSession()
+print(session1.get_user())
+session1.set_user(1, "aldroide", "Aldo AC", "aldroidegmail.com")
+print(session1.get_user())
+
+session2 = UserSession()
+print(session2.get_user())
+
+session3 = UserSession()
+session3.clear_user()
+print(session3.get_user())

Roadmap/24 - DECORADORES/python/Aldroide.py

@@ -0,0 +1,57 @@
+""" 
+    Ejercicio
+    Explora el concepto de "decorador" y muestra cómo crearlo con un ejemplo genérico
+"""
+
+
+def mi_decorador(func):
+    def funcion_(a, b):
+        print("Antes de llamar a la función")
+        resultado = func(a, b)
+        print("Se llamo la función")
+        return resultado
+    return funcion_
+
+
+@mi_decorador
+def suma(a, b):
+    print("Entró a funcion suma")
+    return a+b
+
+
+@mi_decorador
+def resta(a, b):
+    print("Entró a función resta")
+    return a-b
+
+
+r = suma(4, 5)
+print(r)
+r = resta(5, 3)
+print(r)
+
+
+"""
+    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 count_call(func):
+    def new_func():
+        new_func.contador += 1
+        print(
+            f"La función '{func.__name__}' ha sido llamada {new_func.contador} veces")
+        return func
+    new_func.contador = 0
+    return new_func
+
+
+@count_call
+def my_func():
+    print("Ejecutanto la funcion")
+
+
+my_func()
+my_func()
+my_func()