Merge pull request mouredev#7152 from mrodara/mrodara/main

#21-Python

Author: kontroldev

Roadmap/21 - CALLBACKS/python/mrodara.py

@@ -0,0 +1,66 @@
+### CALLBACKS EN PYTHON
+
+'''
+Un callback es simplemente una función que:
+
+Se pasa como argumento a otra función.
+Es llamada dentro de esa función en un momento determinado.
+'''
+
+# Definimos una función callback
+#def saludo(name: str) -> None:
+#    print(f"Hola {name}")
+#
+## Función principal que usará el callback
+#def procesar_saludo(name: str, my_callback) -> None:
+#    print("Procesando saludo...")
+#    my_callback(name)
+#    print("Saludo procesado.")
+#
+#procesar_saludo("Brais", saludo)
+
+
+### EJERCICIO EXTRA
+import asyncio #Vamos a trabajar con procesos
+from random import randint #Para generar los tiempo aleatorios
+
+# Funciones callback
+async def order_confirmed(plate_name: str) -> None:
+    print(f"La comanda para el plato: {plate_name} está confirmada")
+    await asyncio.sleep(randint(1,10)) # Generamos un tiempo aleatorio entre 1 y 10
+
+async def order_ready(plate_name: str) -> None:
+    print(f"La comanda para el plato: {plate_name} está lista")
+    await asyncio.sleep(randint(1,10)) # Generamos un tiempo aleatorio entre 1 y 10
+
+async def order_delivered(plate_name: str) -> None:
+    print(f"La comanda para el plato: {plate_name} está entregada")
+    await asyncio.sleep(randint(1,10)) # Generamos un tiempo aleatorio entre 1 y 10
+
+# Función principal
+async def procesar_pedido(plate_name: str, cb_confirmed, cb_ready, cb_delivered) -> None:
+    print(f"Procesando pedido de {plate_name}...")
+    #await asyncio.sleep(1)
+    await cb_confirmed(plate_name)
+    #await asyncio.sleep(1)
+    await cb_ready(plate_name)
+    #await asyncio.sleep(1)
+    await cb_delivered(plate_name)
+    #await asyncio.sleep(1)
+    print(f"Pedido de {plate_name} procesado.")
+    
+# Ejecución asíncrona
+async def main() -> None:
+    await asyncio.gather(
+        procesar_pedido("Pizza", order_confirmed, order_ready, order_delivered),
+        procesar_pedido("Hamburguesa", order_confirmed, order_ready, order_delivered),
+        procesar_pedido("Kebap", order_confirmed, order_ready, order_delivered)
+    )
+
+# Ejecutar la función principal
+asyncio.run(main())
+    
+### FIN EJERCICIO EXTRA
+
+### FIN CALLBACKS EN PYTHON
+

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

@@ -0,0 +1,124 @@
+### FUNCIONES DE ORDEN SUPERIOR EN PYTHON
+
+'''
+Una función de orden superior es aquella que:
+ Acepta una función como argumento.
+ Devuelve otra función como resultado.
+ O ambas cosas.
+'''
+
+# Ejemplo de función que acepta otra como argumento:
+def calculator(x: float, y: float, operation) -> float:
+    return operation(x, y)
+
+def sum(a: float, b: float) -> float:
+    return a + b
+
+def product(a: float, b: float) -> float:
+    return a * b
+
+print(calculator(10,20, sum)) # Salida 30
+print(calculator(10,20, product)) # Salida 200
+
+# Ejemplo devolviendo otra función como resultado (lambda):
+def new_calculator(operation):
+    if operation.lower() == "sum":
+        return lambda a, b: a + b
+    elif operation.lower() == "product":
+        return lambda a, b: a * b
+    else:
+        return lambda a, b: None
+
+my_sum = new_calculator("sum")
+my_product = new_calculator("product")
+
+print(my_sum(5,5)) # Salida 10
+print(my_product(5,5)) # Salida 25
+
+# Python ofrece varias funciones de orden superior predefinidas, como map, filter, y reduce.
+
+my_list = [i for i in range(1,11)]
+
+square = map(lambda x: x**2, my_list)
+print(list(square))
+
+pairs = filter(lambda x: x%2 == 0, my_list)
+
+print(list(pairs))
+
+# Para reduce necesitamos importar functools
+from functools import reduce
+
+sum = reduce(lambda x, y: x + y, my_list)
+print(sum) # Salida 55
+
+### EJERCICIO EXTRA
+students = [
+    {
+        "name": "Manuel Rodriguez",
+        "birth_date": "2002-05-14",
+        "grades": [8.5, 7.0, 9.0, 6.5]
+    },
+    {
+        "name": "Lucia Perez",
+        "birth_date": "2003-11-22",
+        "grades": [7.5, 9.0, 8.0, 9.5]
+    },
+    {
+        "name": "Pedro Sanchez",
+        "birth_date": "2001-08-05",
+        "grades": [6.0, 5.5, 7.0, 6.5]
+    },
+    {
+        "name": "Ana Fernandez",
+        "birth_date": "2004-01-30",
+        "grades": [9.0, 8.5, 9.5, 10.0]
+    },
+    {
+        "name": "Carlos Garcia",
+        "birth_date": "2002-07-19",
+        "grades": [7.0, 7.5, 6.0, 8.0]
+    }
+]
+
+# Promedio de calificaciones:
+def analysis(iterable: list, operation):
+    return operation(iterable)
+
+def avg(iterable: list) ->list:
+    
+    avg_students = []
+    
+    for element in iterable:
+        avg = 0
+        for grade in element["grades"]:
+            avg += grade
+        avg /= len(element["grades"])
+        
+        avg_students.append({
+            "name": element["name"],
+            "avg": avg
+        })
+        
+    return avg_students
+
+avg_students = analysis(students, avg)
+
+print(list(avg_students))
+
+# Aprovechamos la lista avg_students para obtener los mejores estudiantes, en este caso usaremos filter
+best_students = filter(lambda x: x['avg'] >=9 and x['avg']<=10, avg_students)
+print(list(best_students))
+
+# Lista de estudiantes ordenada por fecha de nacimiento
+students_by_birthday = sorted(students, key=lambda p: p['birth_date'])
+print(list(students_by_birthday))
+
+# Obtención de la nota más alta de entre todas las obtenidas por los estudiantes
+max_grade = reduce(lambda x,y: max(x,y), [grade for student in students for grade in student["grades"]])
+print(max_grade)
+
+### FIN EJERCICIO EXTRA
+
+
+### FIN FUNCIONES DE ORDEN SUPERIOR EN PYTHON

Roadmap/23 - SINGLETON/python/mrodara.py

@@ -0,0 +1,112 @@
+#### PATRONES DE DISEÑO: SINGLETON
+
+'''
+El patrón Singleton es un patrón de diseño que asegura que una clase tenga una única instancia en todo el programa 
+y proporciona un punto de acceso global a esa instancia. Es útil en casos como la gestión de configuraciones, 
+recursos compartidos (como conexiones a bases de datos) o registros de logs.
+
+Python ofrece varias formas de implementar este patrón, la más sencilla es usando variables de clase
+'''
+
+# Implementación básica: usando variables de clase
+class Configuration:
+    _instance = None # Variable de clase para almacenar la única instancia
+    
+    # Método para controla la construcción de la instancia
+    def __new__(cls, *args, **kwargs):
+        if not cls._instance:
+            cls._instance = super().__new__(cls, *args, **kwargs) #Nueva instancia usando clase base
+            cls._instance.settings = {} #Creamos un diccionario para almacenar nuestra configuración
+        
+        return cls._instance # Devolvemos la instáncia única (nueva o ya creada)
+    
+    def set(self, key, value):
+        self.settings[key] = value
+    
+    def get(self, key):
+        return self.settings.get(key, None)        
+
+# Uso de singleton
+config1 = Configuration()
+config2 = Configuration()
+
+config1.set("db_host", "192.168.20.10")
+config1.set("db_name", "my_db")
+config1.set("db_user", "user_db")
+config1.set("port", 3306)
+
+print(config1.get("db_host")) # 192.168.20.10
+print(config2.get("db_host"))
+
+print(config1 is config2)
+
+### EJERCICIO EXTRA
+class Session():
+    __instance = None
+    
+    def __new__(cls, *args, **kwargs):
+        if not cls.__instance:
+            cls.__instance = super().__new__(cls, *args, **kwargs)
+            cls.__instance.username = None
+            cls.__instance.session_id = None
+            cls.__instance.name = None
+            cls.__instance.email = None
+        
+        return cls.__instance
+    
+    def set_username(self, username):
+        self.username = username
+    
+    def set_session_id(self, session_id):
+        self.session_id = session_id
+    
+    def set_name(self, name):
+        self.name = name
+    
+    def set_email(self, email):
+        self.email = email
+    
+    def get_username(self):
+        return self.username
+    
+    def get_session_id(self):
+        return self.session_id
+    
+    def get_name(self):
+        return self.name
+    
+    def get_email(self):
+        return self.email
+    
+    def end_session(self):
+        self.username = None
+        self.session_id = None
+        self.name = None
+        self.email = None
+        Session.__instance = None
+        
+        print("Sesión finalizada, con éxito...")
+    
+session1 = Session()    
+session2 = Session()
+
+session1.set_name('Manu')
+session1.set_session_id(1)
+session1.set_username("mrodara")
+session1.set_email("[email protected]")
+
+print(session2.get_name())
+print(session2.get_username())
+print(session2.get_session_id())
+print(session2.get_email())
+
+session2.end_session()
+
+print(session1.get_name())
+print(session1.get_username())
+print(session1.get_session_id())
+print(session1.get_email())
+    
+### FIN EJERCICIO EXTRA
+
+#### FIN PATRONES DE DISEÑO: SINGLETON

Roadmap/24 - DECORADORES/python/mrodara.py

@@ -0,0 +1,71 @@
+#### PATRONES DE DISEÑO: DECORADORES
+
+'''
+El Patrón Decorador es un patrón estructural que permite añadir funcionalidades a un objeto dinámicamente sin modificar su estructura original. 
+Es especialmente útil cuando necesitas extender las capacidades de una clase de manera flexible y reutilizable.
+
+En Python, este concepto también está integrado en el lenguaje a través de la sintaxis de decoradores, 
+que simplifica el uso del patrón.
+'''
+
+# Ejemplo básico con una función decoradora
+def decorador(funcion):
+    def wrapper(*args, **kwargs):
+        print("Antes de ejecutar la función")
+        result = funcion(*args, **kwargs)
+        print("Después de ejecutar la función")
+        
+        return result
+    
+    return wrapper
+
+@decorador
+def saludo(name):
+    print(f'Hola {name}, estás siendo saludado desde un decorador')
+    
+saludo("Manuel")
+
+# En lugar de funciones también se pueden usar decoradores con Clases
+class DecoradorClase():
+    def __init__(self, function):
+        self.function = function
+    
+    def __call__(self, *args, **kwargs):
+        print("Antes de ejecutar la función")
+        result = self.function(*args, **kwargs)
+        print("Después de ejecutar la función")
+        
+        return result
+
+@DecoradorClase
+def saludo(name: str):
+    print(f'Hola {name}, ahora el decorador es de clase')
+
+saludo("Otra vez Manuel")
+
+### EJERCICIO EXTRA
+class DecoradorContador():
+    
+    count = 0
+    
+    def __init__(self, function):
+        self.function = function
+        
+    def __call__(self, *args, **kwds):
+        result = self.function(*args, **kwds)
+        self.count += 1
+        print(f'La función se ha ejecutado {self.count} veces')
+        return result
+
+@DecoradorContador    
+def saludo(name: str):
+    print(f'Hola {name}')
+
+names = ['Antonio', 'Rita', 'Gabriel']
+
+for name in names:
+    saludo(name)
+
+
+### FIN EJERCICIO EXTRA
+#### FIN PATRONES DE DISEÑO: DECORADORES