Un tipo de decoradores son los que obtienen y definen propiedades. Estos decoradores permiten el acceso controlado a variables en instancias de clase.

Los captadores y definidores de propiedades están diseñados específicamente para el control de atributos en la programación orientada a objetos. Estos se diferencian de los decoradores de funciones en que se usan para atributos de clase (consulte mi publicación sobre decoradores de funciones aquí).

Tanto los decoradores de funciones como los decoradores de captadores y definidores de propiedades modifican el código con código reutilizable y usan la sintaxis '@'. Ambos cambian la funcionalidad del código.

Bien, entremos en ello.

Los captadores y definidores de propiedades se aplican a métodos dentro de una clase para definir varios comportamientos. Un setter establece el atributo en un valor, y un getter toma un atributo de una clase. El atributo se establece primero.

Echemos un vistazo a un ejemplo y luego lo desglosaremos:

class Shoe:
    def __init__(self, brand = "Adidas", size = 9):
        self.brand = brand
        self.size = size
        self._condition = "New"

    @property
    def size(self):
        """The size property"""
        return self._size

    @size.setter
    def size(self, size):
        """size must be an integer"""
        if isinstance(size, int):
            self._size = size
        else:
            print("size must be an integer")

    def cobble(self):
        """Repairs the shoe and sets the condition to 'New'."""
        self.condition = "New"
        print("Your shoe is as good as new!")

    @property
    def condition(self):
        """The condition property"""
        return self._condition

    @condition.setter
    def condition(self, condition):
        self._condition = condition

Repasemos parte de este código:

Los guiones bajos antes de algunos de los atributos (condición, tamaño) indican al desarrollador que son privados; son específicos de cada instancia de la clase Zapato (cada zapato, minúsculas).

Es posible que notes que la condición y el tamaño se crean instancias de manera diferente. self._condition = "Nuevo" significa que cada instancia (u objeto) de la clase de zapato se crea una instancia con una condición de "Nuevo". Se hace lo mismo con el atributo de tamaño, pero no está escrito como self._size = 9 para que active la validación de la propiedad del definidor, porque el tamaño debe ser un número entero (este es un proceso llamado validación). Estamos configurando la condición de cada objeto de zapato individual directamente, en lugar de ejecutarlo a través de los métodos de establecimiento y obtención de propiedades.

El método cobble no necesita un decorador porque simplemente realiza una acción, no obtiene/establece un atributo de cada objeto de zapato.

Hagamos un cambio final en nuestro código. Por ejemplo, ¿qué sucede si queremos asegurarnos de que el atributo de tamaño no se pueda cambiar más adelante? Al fin y al cabo, un zapato no cambia realmente de talla, ¿verdad?

Podemos usar la función hasattr() para realizar una verificación en cada objeto de zapato. ¿Tiene un atributo privado de tamaño, indicado por la presencia de '_size'? Si es así, no se puede cambiar. Aquí está el código implementado:

 @size.setter
    def size(self, size):
        """size must be an integer and can't be changed once set"""
        if hasattr(self, '_size'):
            raise AttributeError("Can't change size once set")
        if isinstance(size, int):
            self._size = size
        else:
            raise ValueError("size must be an integer")

Los definidores y captadores de propiedades son un poco difíciles de entender, pero una vez entendidos, ¡codificarás Python como un profesional!

Fuentes:

Material escolar Flatiron