Decoradores en Programación Orientada a Objetos en Python

Resumen

¿Cómo funcionan los decoradores en la programación orientada a objetos?

Los decoradores en Python son un elemento poderoso que añade funcionalidad adicional a métodos o funciones sin modificar su estructura interna. Este concepto es bien conocido en el contexto de funciones, pero su aplicación en la programación orientada a objetos (POO) expande aún más sus posibilidades. Aquí exploramos su uso dentro de clases.

¿Qué es un método estático?

Los métodos estáticos no dependen de la instancia de la clase sino que pertenecen a la clase en sí. Se utiliza el decorador @staticmethod cuando se desea crear un método que no necesita acceder a la clase o modificar sus datos.

class Calculadora:
    @staticmethod
    def suma(a: int, b: int) -> int:
        return a + b

Ventaja: Ideal para operaciones que no requieren acceso a las propiedades o métodos de clase.

¿Qué hace un método de clase?

Un método de clase está vinculado a la clase y no a la instancia. Utiliza el decorador @classmethod, y el primer parámetro siempre es cls, que representa la clase.

class Contador:
    cuenta = 0

    @classmethod
    def incrementar(cls):
        cls.cuenta += 1

Uso común: Modificar el estado de clase común a todas las instancias.

¿Cómo se utiliza el decorador `property`?

El decorador property permite acceder a un método como si fuese un atributo. Esto mejora la encapsulación y mantiene el control sobre cómo se manipula la información interna de la clase.

Ejemplo de clase `Círculo`

class Circulo:
    def __init__(self, radio: float):
        self._radio = radio
    
    @property
    def area(self) -> float:
        return 3.1416 * self._radio ** 2
    
    @property
    def radio(self) -> float:
        return self._radio

    @radio.setter
    def radio(self, valor: float):
        if valor < 0:
            raise ValueError("El radio no puede ser negativo")
        self._radio = valor

¿Por qué usar `property`?

Control del acceso: El acceso a atributos sensibles puede ser controlado sin afectar la interfaz externa.
Flexibilidad: Los atributos pueden ser modificables, lo que permite agregar lógica para validaciones o cálculos al cambiar valores.
Encapsulación: Permite ocultar la lógica de cálculo o validaciones, entregando una interfaz limpia al usuario de la clase.

Reflexiones finales sobre decoradores en POO

Los decoradores como staticmethod, classmethod, y property son herramientas valiosas que enriquecen el diseño de clases en Python. Permiten:

Añadir funcionalidad especial sin modificar el código base.
Mejorar la legibilidad y profesionalidad del código.
Mantener un diseño orientado a objetos disciplinado y eficiente.

¡Ahora depende de ti aplicarlos y descubrir todo su potencial en tus proyectos! Recuerda: ¡Un gran poder conlleva una gran responsabilidad en el código!

Mario Alexander Vargas Celis

student•

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.


from functools import wraps

import datetime



\# Decorador para verificar permisos

def verificar\_permisos(permiso\_necesario):

&#x20;   def decorador\_metodo(func):

&#x20;       @wraps(func)

&#x20;       def envoltura(self, \*args, \*\*kwargs):

&#x20;           if permiso\_necesario not in self.permisos:

&#x20;               raise PermissionError(f"No tienes permisos para realizar esta operación: {permiso\_necesario}")

&#x20;           return func(self, \*args, \*\*kwargs)

&#x20;       return envoltura

&#x20;   return decorador\_metodo



\# Decorador para registrar en log

def registrar\_operacion(func):

&#x20;   @wraps(func)

&#x20;   def envoltura(self, \*args, \*\*kwargs):

&#x20;       resultado = func(self, \*args, \*\*kwargs)

&#x20;       operacion = f"{func.\_\_name\_\_} ejecutado el {datetime.datetime.now()}"

&#x20;       self.historial.append(operacion)

&#x20;       print(f"Registro: {operacion}")

&#x20;       return resultado

&#x20;   return envoltura



\# Clase CuentaBancaria usando decoradores en sus métodos

class CuentaBancaria:

&#x20;   def \_\_init\_\_(self, balance=0):

&#x20;       self.balance = balance

&#x20;       self.historial = \[]

&#x20;       self.permisos = \['ver\_balance', 'retirar']  # permisos actuales del usuario



&#x20;   @registrar\_operacion

&#x20;   @verificar\_permisos('ver\_balance')

&#x20;   def ver\_balance(self):

&#x20;       print(f"Balance actual: ${self.balance}")

&#x20;       return self.balance



&#x20;   @registrar\_operacion

&#x20;   @verificar\_permisos('retirar')

&#x20;   def retirar(self, cantidad):

&#x20;       if cantidad > self.balance:

&#x20;           raise ValueError("Fondos insuficientes")

&#x20;       self.balance -= cantidad

&#x20;       print(f"Retiro exitoso: ${cantidad}. Nuevo balance: ${self.balance}")

&#x20;       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:

&#x20;   cuenta.permisos.remove('retirar')

&#x20;   cuenta.retirar(100)

except PermissionError as e:

&#x20;   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.

Fidel Ortega Guzman

student•

gracias por la aportacion

Alexis Dorado Muñoz

student•

Gracias por tu aporte!

Giovanni Castro Agustín

student•

creo, que solo lanza ejemplos muy al aire, tan solo no probo el ejemplo de calculadora... solo dejo al aire la idea. Parece que no hay una estructura en los conceptos que explica.

JUAN CAMILO AGUIRRE ROMERO

student•

Ha sido una constante en todo el curso. Diría que un 40-50% me lo ha explicado chatgpt.

Ramón Eliezer Medina Plaza

student•

sí, coincido contigo... tenía que haber explicado que la clase calculadora con @staticmethod sólo sirve ahí como clasificador o etiqueta de funciones como para no perderlas de vista en el código, podía haber añadido otros def de matemática para que quedara claro, esta es la explicación de chatgpt: Porque a veces organizar lógicamente funciones relacionadas dentro de una clase mejora la claridad, sobre todo en proyectos grandes. Es una forma de agrupar funciones coherentes.

Eduardo Pech

student•

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.

Alexis Dorado Muñoz

student•

Gracias por tu aporte!

Manuel Alveiro Prieto Grosso

student•

No termino de entender para qué usar decoradores, por ejemplo, en el ejemplo del área del círculo, por que no sencillamente no se crea un atributo como self.area = (radius**2)*3.1416 y ya, los atributos extienden la funcionalidad sin embargo no veo la razón de usarlos si simplemente se pueden dar esas características y funciones a la clase y ya.

Juan Felipe Benavides

student•

@property Facilita el acceso y la modificación de atributos de manera controlada, permitiendo la validación y el encapsulamiento.

A mi modo de ver, este decorador tiene dos ventajas: 1. Poder convertir el resultado de un método en un atributo y 2. Poder tener este atributo de manera interna y más privada.

Jhon sebastian Garzon cano

student•

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

Eduardo Pech

student•

Un decorador es una función que se ejecuta antes de la función al que se la asignas.

#Ejemplo def tieneDinero():

@tieneDinero def comprar():

Antes de ejecutar comprar el decorador con la función tieneDinero se ejecuta antes y ahi puedes escribir la lógica que desees, el uso más común es de validar y formatear datos, pero lo puedes usar para lo que sea.

JUAN CAMILO AGUIRRE ROMERO

student•

Creo que no es algo que si no se entiende o se usa a la primera esté mal. Por ahora, veo estos decoradores como formas en el que el código está "mejor" escrito. Algo más "profesional", mejor visto para los profesionales

Raul Fernandez

student•

No, no se puede utilizar el decorador @nombre_del_metodo.setter sin haber definido previamente el decorador @property para ese mismo método. El decorador @property convierte el método en un atributo, lo que permite el uso del decorador @setter para modificar su valor. Esto es fundamental en Python para garantizar que se mantenga la consistencia y el control sobre la asignación de valores a los atributos de la clase.

Francisco Diez

student•

Alguien me podría comentar la diferencia entre llamar al atributo self.radius y self._radius?

No entiendo muy bien por qué se coloca el guion previo al nombre del atributo.

Raul Fernandez

student•

Muy buen punto y observación.

Respuesta:

En Python, es común usar un prefijo como _ en los atributos de instancia para diferenciarlos de los parámetros del constructor. En el ejemplo, radius es el parámetro del método __init__, mientras que self._radius es el atributo que guarda el valor. Esto evita confusiones y permite reconocer fácilmente que _radius es un atributo de la instancia. Esta convención facilita el acceso y la modificación del atributo dentro de la clase sin conflictos con los parámetros pasados al constructor. Espero haber sido claro, sino con mucho gusto trato de explicarlo mejor. Saludos.

Daniel Andres Rojas Paredes

student•

Decoradores predefinidos como el @staticmethod : existe incluso antes de cualquier instancia de la clase, @classmethod: hacen modificacion del estado de la clase

,@propperti : permite que los metodos se comporten como atributos aplicando encapsulamiento

son especialmente

decoradores de biblioteca como: @functools.wraps @lru_cache @contextManager, @dataclass

proporcionan funcionalidades adicionales y optimizaciones

decoradores personalizados pueden usarse para registro validaciones o timers

Carlos Adrián Serrano Samayoa

student•

Decoradores que incluye python: Decoradores para Métodos en Clases

@staticmethodpythonCopiar códigoclass MiClase: @staticmethod def metodo_estatico(): print("Este es un método estático.") MiClase.metodo_estatico()
- Convierte un método en un método estático.
- El método estático no recibe ni self ni cls como argumento.
- Se utiliza para definir funciones relacionadas con la clase, pero que no dependen de una instancia. Ejemplo:
@classmethodpythonCopiar códigoclass MiClase: @classmethod def metodo_clase(cls): print("Este es un método de clase.") MiClase.metodo_clase()
- Convierte un método en un método de clase.
- Recibe cls como primer argumento, que representa la clase (no la instancia).
- Se utiliza cuando se necesita acceder a atributos o métodos de clase. Ejemplo:
@propertypythonCopiar códigoclass MiClase: def __init__(self, valor): self._valor = valor @property def valor(self): return self._valor obj = MiClase(10) print(obj.valor) # Accede al atributo con lógica adicional.
- Convierte un método en un getter para un atributo.
- Se utiliza para acceder a atributos como si fueran propiedades, lo que permite definir lógica adicional al obtener un valor. Ejemplo:
@<property>.setterpythonCopiar códigoclass MiClase: def __init__(self, valor): self._valor = valor @property def valor(self): return self._valor @valor.setter def valor(self, nuevo_valor): self._valor = nuevo_valor obj = MiClase(10) obj.valor = 20 # Cambia el valor con lógica adicional. print(obj.valor)
- Permite definir un setter para un atributo, utilizado para establecer valores con lógica adicional. Ejemplo:
@<property>.deleterpythonCopiar códigoclass MiClase: def __init__(self, valor): self._valor = valor @property def valor(self): return self._valor @valor.deleter def valor(self): del self._valor obj = MiClase(10) del obj.valor # Lógica al eliminar.
- Permite definir un deleter para un atributo, utilizado para eliminar valores con lógica adicional. Ejemplo:

Decoradores para Corrutinas y Generadores

@asyncio.coroutine (obsoleto en Python 3.10)
- Usado para definir funciones generadoras asíncronas en versiones anteriores de Python.
- Reemplazado por async def.
@contextlib.contextmanagerpythonCopiar códigofrom contextlib import contextmanager

@contextmanager def ejemplo_contexto(): print("Entrando al contexto") yield print("Saliendo del contexto")

with ejemplo_contexto(): print("Dentro del contexto")
- Convierte una función en un administrador de contexto (usado con with).
- Simplifica la creación de administradores de contexto personalizados. Ejemplo:

Decoradores para el Módulo functools

@functools.lru_cachepythonCopiar códigofrom functools import lru_cache

@lru_cache(maxsize=3) def calcular(valor): print(f"Calculando para {valor}") return valor ** 2

print(calcular(2)) print(calcular(2)) # Usa el valor en caché.
- Implementa un caché para almacenar resultados de funciones.
- Optimiza el rendimiento evitando cálculos repetitivos. Ejemplo:
@functools.wrapspythonCopiar códigofrom functools import wraps

def mi_decorador(func): @wraps(func) def wrapper(*args, **kwargs): print("Antes de la función") return func(*args, **kwargs) return wrapper

@mi_decorador def saludar(): """Función para saludar.""" print("¡Hola!") print(saludar.__doc__)
- Conserva el nombre y la documentación de una función al ser decorada.
- Útil para crear decoradores personalizados. Ejemplo:
@functools.partial *(No es un decorador en sí, pero relacionado)*pythonCopiar códigofrom functools import partial

def multiplicar(a, b): return a * b

por_dos = partial(multiplicar, b=2) print(por_dos(4)) # Multiplica 4 * 2
- Crea una nueva función fijando algunos de los argumentos de otra función. Ejemplo:

Decoradores para Pruebas

@unittest.skippythonCopiar códigoimport unittest

class MiPrueba(unittest.TestCase): @unittest.skip("Motivo de omisión") def test_saltar(self): self.fail("No debería ejecutarse.")
- Omite una prueba en un caso de prueba de unittest. Ejemplo:
@unittest.expectedFailurepythonCopiar códigoimport unittest

class MiPrueba(unittest.TestCase): @unittest.expectedFailure def test_fallo_esperado(self): self.assertEqual(1, 0)
- Marca una prueba como esperada a fallar. Ejemplo:

Decoradores Misceláneos

@dataclasses.dataclasspythonCopiar códigofrom dataclasses import dataclass

@dataclass class Persona: nombre: str edad: int

p = Persona("Carlos", 25) print(p)
- Convierte una clase en una data class, agregando automáticamente métodos como __init__, __repr__, y __eq__. Ejemplo:
@typing.overloadpythonCopiar códigofrom typing import overload

@overload def sumar(a: int, b: int) -> int: ... @overload def sumar(a: str, b: str) -> str: ...

def sumar(a, b): return a + b
- Especifica diferentes firmas de funciones para sobrecarga de funciones (solo para propósitos de tipado).

Agustín Alberto Leiva

student•

Los modificadores utilizados en el contexto de decoradores en Programación Orientada a Objetos en Python son:

@staticmethod: Se utiliza para definir un método que no accede a la instancia o clase.
@classmethod: Permite modificar la clase o acceder a atributos de clase, en vez de a la instancia.
@property: Facilita acceder a un método como si fuera un atributo, permitiendo también la creación de setters.

Estos decoradores ayudan a estructurar el código y a mantener buenas prácticas en programación orientada a objetos.

Luis Quiroz Prada

student•

Debes usar el decorador @staticmethod en Python. Este decorador se aplica a un método que no requiere acceso a la instancia (self) ni a la clase (cls). Los métodos estáticos son útiles para agrupar funciones relacionadas con la clase, pero que no necesitan acceder a sus atributos ni modificar su estado.

FABIAN PEREZ

student•

Esto ya se podría considerar como avanzado?

Platzi

student•

La clase prepara para escribir código Pythonico y profesional, es momento de dar un paso más y enfrentar desafíos más complejos.

Jhon Freddy Tavera Blandon

student•

```js

def decorador_clase(cls): cls.autor = "Ingeniero de Datos" return cls

@decorador_clase class Informe: pass

print(Informe.autor)

Jose Jhonatan Choque Araujo

student•

Me parece algo complejo de entender, pero lo poco que comprendí es que los decoradores funcionan como una función que se realiza antes de realizar la función original.

Lo tomo como si en el ordenador cuando nosotros queremos eliminar algún archivo nos salta una ventana de alerta para preguntarnos si estamos seguros.

En este caso la función original seria la de eliminar el archivo y el decorador como la ventana emergente de alerta.

Me podrían confirmar si estoy en lo cierto o me estoy equivocando por favor.

FREDDY ANDRES LEMUS BARRERA

student•

¿Qué decorador se utiliza para métodos que no acceden a la información de la clase?
- A) @classmethod
- B) @staticmethod (Correcta)
- C) @property
- D) @decorador
¿Cuál de los siguientes decoradores permite modificar atributos de la clase?
- A) @staticmethod
- B) @classmethod (Correcta)
- C) @property
- D) @decorador
¿Qué decorador se utiliza para acceder a métodos como si fueran atributos?
- A) @staticmethod
- B) @classmethod
- C) @property (Correcta)
- D) @decorador
En el contexto de la clase Calculadora, ¿qué tipo de datos recibe el método sumar?
- A) Flotantes
- B) Cadenas
- C) Enteros (Correcta)
- D) Listas
¿Qué error se levanta cuando se intenta asignar un valor negativo al radio en la clase Círculo?
- A) ValueError (Correcta)
- B) TypeError
- C) AttributeError
- D) IndexError
¿Qué método se utiliza para incrementar un contador en la clase Contador?
- A) increment
- B) add
- C) count (Correcta)
- D) sum
¿Cómo se define el decorador para un método de clase?
- A) @staticmethod
- B) @classmethod (Correcta)
- C) @property
- D) @decorador
¿Qué valor retorna el método área en la clase Círculo?
- A) El radio
- B) 3.14 * radio^2 (Correcta)
- C) Un número entero
- D) Un string
¿Qué función cumple el decorador @property en un método setter?
- A) Modifica un atributo (Correcta)
- B) Solo devuelve un valor
- C) Define un método estático
- D) No tiene función
¿Qué se puede concluir sobre el uso de decoradores en Python?
- A) Son opcionales
- B) Ayudan a extender funcionalidades (Correcta)
- C) Son obsoletos
- D) Solo se usan con funciones

Johan Humberto Castillo rios

student•

quede muy perdido en esta clase!!! creo que la metodologia de esta clase o la de toda la seccion de decoradores puede mejorarse porque hay muchos vacios y deja mucho hueco solo lo explica superficialmente y creo que es tema algo complejo

Clemente Cosetl Pérez

student•

Si es bastante complejo, y creo que si lo explicara más a fondo la clse se alargaria mucho o incluso podria tomar varias clases, por eso me parece que solo te sueltan el tema para que lo conoscas y luego tu lo profundices por tu cuenta

Jesús David Fontalvo Mendoza

student•

Analogía para los que sepan algo de SQL y quieran entender como funciona @radius.setter ⇒

Un @<nombre_propiedad>.setter se comporta de manera muy similar a un trigger en una base de datos. Un trigger es un bloque de código que se ejecuta automáticamente en respuesta a ciertos eventos (como la inserción, actualización o eliminación de datos).

De la misma manera, el método decorado con @<nombre_propiedad>.setter se "dispara" o se ejecuta automáticamente cuando se intenta asignar un valor al atributo correspondiente de un objeto de la clase.

Y al igual que los triggers en bases de datos pueden realizar diversas acciones (verificar la integridad de los datos, actualizar otras tablas, registrar eventos, etc.), el setter en Python puede contener cualquier lógica que necesites ejecutar en el momento en que se modifica el valor del atributo:

Verificar: Como en el ejemplo del radio positivo.
Transformar: Como capitalizar un nombre o eliminar espacios.
Actualizar otros atributos: Como recalcular el área de un rectángulo.
Registrar (logging): Dejar constancia de la modificación.
Emitir eventos: Notificar a otras partes del sistema sobre el cambio.
Incluso "eliminar" (aunque esto sería menos común y más conceptual, podrías, por ejemplo, establecer una bandera interna o realizar otra acción en respuesta a un valor específico).

En resumen:

El @<nombre_propiedad>.setter actúa como un mecanismo de interceptación o un trigger que se activa cuando se intenta cambiar el valor de un atributo específico, permitiéndote ejecutar código personalizado en ese momento.

Jesús David Fontalvo Mendoza

student•

¿Qué hace @property?

@property es un decorador incorporado en Python que se utiliza para definir un método de clase que se accede como si fuera un atributo. Proporciona una forma elegante de implementar el acceso controlado a los atributos de una instancia, permitiendo ejecutar código (como cálculos o validaciones) cuando se intenta obtener el valor de un "atributo".

¿Para qué sirve @property?

Encapsulación y Control de Acceso: Permite ocultar la implementación interna de un atributo (como _radius) y proporcionar una interfaz controlada para obtener su valor (radius). Facilita la modificación interna sin romper el código que la utiliza.
Cálculo Dinámico de Atributos: Define "atributos" cuyo valor se calcula dinámicamente cada vez que se accede a ellos (como area).
Validación al Obtener: Permite incluir lógica de validación o transformación antes de devolver el valor (no usado en este ejemplo).
Transición Fluida de Atributo a Método: Permite convertir un atributo simple en un método (con cálculo) sin cambiar la forma de acceso en el resto del código (objeto.atributo).

class Circle:
    # Creamos un circulo que va a tener su respectiva radio
    def __init__(self, radius: float):
        self._radius = radius

    @property
    def area(self) -> float:
        return 3.1416 * (self._radius **2)

    @property
    def radius(self) -> float:
        return self._radius

# Creamos un circulo para probar
circle = Circle(5)

print(circle.area)
```**En tu código:**

* `__init__(self, radius: float)`: Inicializa el círculo con el radio en `_radius`.
* `@property def area(self) -> float:`: Define el método `area` accesible como `circle.area`, calculando el área dinámicamente.
* `@property def radius(self) -> float:`: Define el método `radius` accesible como `circle.radius`, devolviendo el valor de `_radius`.

**Salida de** `print(circle.area)`**:**

78.53981633974483


**En resumen:**

Has utilizado `@property` para crear un "atributo calculado" (`area`) y un acceso controlado a un atributo (`radius`), mejorando la encapsulación y flexibilidad de la clase `Circle`.

Jesús David Fontalvo Mendoza

student•

¿Qué hace @classmethod?

@classmethod es un decorador en Python que transforma un método de una clase para que reciba la clase misma como primer argumento, en lugar de la instancia de la clase (como sucede con los métodos regulares que reciben self). Por convención, este primer parámetro se llama cls.

¿Para qué sirve @classmethod?

Acceder y modificar atributos de clase: Permite a los métodos interactuar directamente con los atributos que pertenecen a la clase en sí, y que son compartidos por todas las instancias de esa clase. Esto es útil para mantener un estado global relacionado con la clase.
Llamar a otros métodos de clase o estáticos: Un método de clase puede invocar otros métodos definidos dentro de la misma clase, utilizando cls para referirse a la clase.
Implementar constructores alternativos: @classmethod se utiliza a menudo para definir métodos que crean instancias de la clase de una manera diferente a la proporcionada por el método __init__. Esto permite ofrecer formas más claras o específicas de instanciar la clase basadas en diferentes tipos de entrada.

Ejemplo Práctico: Crear instancias desde diferentes formatos de datos

Imagina una clase En este ejemplo:Empleado con un constructor estándar que recibe nombre y salario. Podríamos usar un @classmethod para crear instancias de Empleado a partir de una cadena de texto con formato específico:```js class Empleado: num_empleados = 0 # Atributo de clase para contar empleados

def __init__(self, nombre, salario):
    self.nombre = nombre
    self.salario = salario
    Empleado.num_empleados += 1

def mostrar_empleado(self):
    print(f"Nombre: {self.nombre}, Salario: ${self.salario}")

@classmethod
def desde_cadena(cls, empleado_str):
    """
    Método de clase para crear un objeto Empleado desde una cadena con formato 'nombre-salario'.
    """
    nombre, salario = empleado_str.split('-')
    return cls(nombre, float(salario))  # Llama al constructor de la clase (cls)

@classmethod
def obtener_conteo_empleados(cls):
    """
    Método de clase para obtener el número total de empleados creados.
    """
    return cls.num_empleados

Crear empleados usando el constructor estándar

emp1 = Empleado("Ana", 50000) emp2 = Empleado("Carlos", 60000)

Crear un empleado usando el método de clase 'desde_cadena'

emp3 = Empleado.desde_cadena("Diana-55000") emp3.mostrar_empleado() # Salida: Nombre: Diana, Salario: $55000.0

Obtener el número total de empleados usando el método de clase

conteo = Empleado.obtener_conteo_empleados() print(f"Número total de empleados: {conteo}") # Salida: Número total de empleados: 3


* `desde_cadena` es un `@classmethod` que toma una cadena, la解析a y utiliza `cls(nombre, float(salario))` para crear y retornar una nueva instancia de la clase `Empleado`.
* `obtener_conteo_empleados` es otro `@classmethod` que accede al atributo de clase `num_empleados` para devolver el conteo total.

**Resumen de** `@classmethod`**:**

* Es un decorador que define un método de clase.
* El método recibe la **clase misma (**`cls`**)** como primer argumento.
* Se utiliza para operar en atributos de clase, llamar a otros métodos de clase y proporcionar constructores alternativos.
* Se llama directamente en la clase (`Clase.metodo_de_clase()`) o en una instancia (`instancia.metodo_de_clase()`), aunque su primer argumento siempre será la clase.

FABIAN PEREZ

student•

No entendí nada en esta clase jajaja :(

Jesús David Fontalvo Mendoza

student•

Espero te ayude ⇒

¿Qué hace @staticmethod?

@staticmethod es un decorador en Python que se utiliza para definir un método dentro de una clase que no depende del estado específico de una instancia de esa clase. En otras palabras, un método estático:

No recibe automáticamente el argumento self (que representa la instancia de la clase).
No tiene acceso directo a los atributos de la instancia (como self.nombre, self.valor, etc.).
Se comporta como una función regular, pero está lógicamente agrupada dentro de la clase porque está relacionada con el concepto de la clase.

¿Para qué sirve @staticmethod?

El uso de @staticmethod tiene varios propósitos:

Agrupación lógica: Permite organizar funciones que están relacionadas conceptualmente con la clase dentro de la propia definición de la clase. Esto hace que el código sea más organizado y fácil de encontrar. En tu ejemplo, la función add es una operación lógica que pertenece al concepto de una Calculadora.
Independencia de la instancia: Indica claramente que la función no necesita acceder ni modificar el estado de ningún objeto específico de la clase Calculadora. Su funcionamiento se basa únicamente en los argumentos que se le pasan.
Conveniencia de llamada: Se puede llamar al método estático tanto desde la clase misma como desde una instancia de la clase:Pythonresultado1 = Calculadora.add(5, 3) # Llamada desde la clase calculadora = Calculadora() resultado2 = calculadora.add(2, 7) # Llamada desde una instancia print(resultado1) # Salida: 8 print(resultado2) # Salida: 9

Aclarando la idea del curso

Se declara como estático cuando la lógica de la función no requiere información específica de un objeto de la clase.

Piensa en ello de esta manera: si una función dentro de una clase puede realizar su tarea utilizando solo los datos que se le proporcionan como argumentos, sin necesidad de saber nada sobre un objeto Calculadora en particular (sus atributos), entonces tiene sentido declararla como @staticmethod.

En tu ejemplo específico:

La función add(a: int, b: int) -> int simplemente toma dos números enteros (a y b) y devuelve su suma. No necesita saber si existe una instancia particular de Calculadora, ni acceder a ningún atributo de esa instancia. Su lógica es puramente matemática y autocontenida. Por lo tanto, declararla como @staticmethod es apropiado porque:

La operación de suma está lógicamente relacionada con el concepto de una calculadora.
No depende del estado de una instancia específica de Calculadora.

En resumen:

@staticmethod se utiliza para definir métodos dentro de una clase que se comportan como funciones regulares pero están agrupadas lógicamente con la clase. Estos métodos no reciben el argumento self y no tienen acceso directo a los atributos de la instancia. Se usan cuando la funcionalidad del método está relacionada con la clase pero no requiere trabajar con un objeto específico de esa clase. La clave está en la independencia del estado de la instancia.

Decoradores en Programación Orientada a Objetos en Python

¿Cómo funcionan los decoradores en la programación orientada a objetos?

¿Qué es un método estático?

¿Qué hace un método de clase?

¿Cómo se utiliza el decorador property?

Ejemplo de clase Círculo

¿Por qué usar property?

Reflexiones finales sobre decoradores en POO

¿Cómo se utiliza el decorador `property`?

Ejemplo de clase `Círculo`

¿Por qué usar `property`?