Uso de Decoradores en clases y métodos

En Python, los decoradores no solo se usan en funciones, también se pueden aplicar a clases y métodos para extender o modificar su comportamiento. Los decoradores en clases y métodos son especialmente útiles para aspectos transversales como la validación de permisos, el registro de accesos, el manejo de excepciones y la administración de cachés. Aquí tienes una guía rápida sobre cómo funcionan y un ejemplo detallado: \### Decoradores en Métodos de Clase Los decoradores pueden aplicarse a métodos específicos de una clase, y se comportan según el tipo de método: \- \*\*Métodos de instancia\*\* (los métodos normales que acceden a `self`). \- \*\*Métodos de clase\*\* (aquellos que usan `@classmethod` y acceden a `cls`). \- \*\*Métodos estáticos\*\* (usando `@staticmethod`, no acceden ni a `self` ni a `cls`). Los decoradores en métodos de clase pueden hacer cosas como: 1\. Controlar permisos antes de ejecutar el método. 2\. Hacer un registro (logging) cada vez que se llama al método. 3\. Manejar errores de forma consistente. \### Decoradores en Clases Un decorador en una clase modifica el comportamiento de la clase en su conjunto, normalmente para extenderla o agregarle nuevas funcionalidades. \### Ejemplo de Uso Imaginemos una clase `CuentaBancaria` donde queremos aplicar un decorador para registrar cada vez que se realiza una operación, y otro decorador para comprobar permisos de acceso a ciertas operaciones. ```python from functools import wraps import datetime \# Decorador para verificar permisos def verificar\_permisos(permiso\_necesario): def decorador\_metodo(func): @wraps(func) def envoltura(self, \*args, \*\*kwargs): if permiso\_necesario not in self.permisos: raise PermissionError(f"No tienes permisos para realizar esta operación: {permiso\_necesario}") return func(self, \*args, \*\*kwargs) return envoltura return decorador\_metodo \# Decorador para registrar en log def registrar\_operacion(func): @wraps(func) def envoltura(self, \*args, \*\*kwargs): resultado = func(self, \*args, \*\*kwargs) operacion = f"{func.\_\_name\_\_} ejecutado el {datetime.datetime.now()}" self.historial.append(operacion) print(f"Registro: {operacion}") return resultado return envoltura \# Clase CuentaBancaria usando decoradores en sus métodos class CuentaBancaria: def \_\_init\_\_(self, balance=0): self.balance = balance self.historial = \[] self.permisos = \['ver\_balance', 'retirar'] # permisos actuales del usuario @registrar\_operacion @verificar\_permisos('ver\_balance') def ver\_balance(self): print(f"Balance actual: ${self.balance}") return self.balance @registrar\_operacion @verificar\_permisos('retirar') def retirar(self, cantidad): if cantidad > self.balance: raise ValueError("Fondos insuficientes") self.balance -= cantidad print(f"Retiro exitoso: ${cantidad}. Nuevo balance: ${self.balance}") return self.balance \# Uso de la clase con decoradores cuenta = CuentaBancaria(1000) \# Operaciones cuenta.ver\_balance() cuenta.retirar(200) \# Intento de retiro sin permisos try: cuenta.permisos.remove('retirar') cuenta.retirar(100) except PermissionError as e: print(e) ``` \### Explicación 1\. \*\*`@verificar\_permisos`\*\*: Este decorador toma un parámetro, `permiso\_necesario`, y se asegura de que el usuario tenga el permiso adecuado antes de ejecutar el método. 2\. \*\*`@registrar\_operacion`\*\*: Este decorador registra cada operación realizada, almacenándola en el atributo `historial`. Este patrón es muy poderoso para clases que requieren varias verificaciones y registros en sus métodos, proporcionando una estructura de código limpia y modular.

alguien tiene informacion de los decoradores? no he entendido nada, como funcionan?

En Python, `property` y `setter` son decoradores que permiten gestionar el acceso a los atributos de una clase de forma controlada. - **`property`**: Este decorador permite acceder a un método como si fuera un atributo. Por ejemplo, si tenemos un método que calcula el área de un círculo, al usar `property`, podemos acceder a este método sin paréntesis, como si fuera un atributo. - **`setter`**: Se usa para definir un método que permite modificar el valor de un atributo de forma segura. Por ejemplo, puedes validar que el nuevo valor no sea negativo antes de asignarlo a un atributo. Estos decoradores ayudan a encapsular la lógica de la clase y proporcionan un control más estricto sobre cómo se accede y modifica la información.

Los **decoradores** en programación son herramientas que permiten modificar o extender el comportamiento de funciones, métodos o clases sin cambiar directamente su código. Son muy utilizados en lenguajes como **Python**, donde se implementan como funciones o clases que actúan sobre otras funciones o clases. ### ¿Cómo funcionan los decoradores? Un decorador es una función que toma otra función o clase como entrada, realiza alguna acción (como añadir funcionalidades) y devuelve una nueva función o clase con el comportamiento modificado. ### Ejemplo sencillo en Python ```python def decorador(func): def nueva_funcion(): print("Antes de ejecutar la función original") func() print("Después de ejecutar la función original") return nueva_funcion @decorador def saludo(): print("Hola, mundo!") saludo() ```Salida: Antes de ejecutar la función original Hola, mundo! Después de ejecutar la función original. El decorador `decorador` modifica el comportamiento de la función `saludo`, añadiendo código antes y después de su ejecución.

```js # Decorator with class using static method # it means that the method is not dependent on the instance of the class class Calculator: @staticmethod def add( a, b): """ sum of two numbers """ return a + b # Decorator with class using class method # it means that the method is dependent on the class and not on the instance of the class Counter: """ Counter class """ count = 0 @classmethod def increment(cls): """ increment count """ cls.count += 1 # Counter.increment() # Counter.increment() # print(Counter.count) # Decorator with class using property # it means that the method is dependent on the instance of the class class Circle: """ Circle class """ def __init__(self, radius: float): self._radius = radius @property def area(self): """ calculate area of circle """ return 3.1416 * (self._radius ** 2) @property def radius(self): """ get radius """ return self._radius @radius.setter def radius(self, value): """ set radius """ if value < 0: raise ValueError("Radius cannot be negative") self._radius = value circle = Circle(5) print(circle.area) circle.radius = 10 print(circle.area) del circle.radius print(circle.area) ```""" This module is an example of using decorators with class """ *# Decorator with class using static method# it means that the method is not dependent on the instance of the class*class *Calculator*: @*staticmethod* def *add*( *a*, *b*): """ sum of two numbers """ return *a* + *b* *# Decorator with class using class method# it means that the method is dependent on the class and not on the instance of the*class *Counter*: """ Counter class """ count = 0 @*classmethod* def *increment*(*cls*): """ increment count """ *cls*.count += 1 *# Counter.increment()# Counter.increment()# print(Counter.count)* *# Decorator with class using property# it means that the method is dependent on the instance of the class* class *Circle*: """ Circle class """ def \_\_init\_\_(*self*, *radius*: *float*): *self*.\_radius = *radius* @*property* def *area*(*self*): """ calculate area of circle """ return 3.1416 \* (*self*.\_radius \*\* 2) @*property* def *radius*(*self*): """ get radius """ return *self*.\_radius @radius.setter def *radius*(*self*, *value*): """ set radius """ if *value* < 0: raise *ValueError(*"Radius cannot be negative"*)* *self*.\_radius = *value* circle = *Circle(5)print(circle.area)*circle.radius = 10*print(circle.area)*del circle.radius*print(circle.area)*