Um tipo de decoradores são os getters e setters de propriedades. Esses decoradores permitem acesso controlado a variáveis ​​em instâncias de classe.

Getters e setters de propriedades são projetados especificamente para o controle de atributos em programação orientada a objetos. Eles são diferentes dos decoradores de funções porque são usados ​​para atributos de classe (confira minha postagem sobre decoradores de funções aqui).

Tanto os decoradores de funções quanto os decoradores de getter e setter de propriedade modificam o código com código reutilizável e usam a sintaxe '@'. Ambos alteram a funcionalidade do código.

Ok, vamos entrar no assunto.

Getters e setters de propriedades são aplicados a métodos dentro de uma classe para definir vários comportamentos. Um setter define o atributo para um valor, e um getter pega um atributo de uma classe. O atributo é set primeiro.

Vamos dar uma olhada em um exemplo e depois detalharemos:

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

Vamos analisar um pouco deste código:

Os sublinhados antes de alguns dos atributos (condição, tamanho) indicam ao desenvolvedor que eles são privados; eles são específicos para cada instância da classe Shoe (cada sapato, em minúsculas).

Você pode notar que a condição e o tamanho são instanciados de maneira diferente. self._condition = "New" significa que cada instância (ou objeto) da classe shoe é instanciada com uma condição "New". O mesmo é feito para o atributo size, mas não é escrito como self._size = 9 para que acione a validação da propriedade setter, pois size precisa ser um número inteiro (este é um processo chamado validação). Estamos definindo a condição de cada objeto de sapato individual diretamente, em vez de executá-lo por meio dos métodos setter e getter de propriedades.

O método cobble não precisa de decorador porque ele simplesmente executa uma ação, não obtendo/definindo um atributo de cada objeto sapato.

Vamos fazer uma alteração final em nosso código. Por exemplo, e se quisermos garantir que o atributo size não possa ser alterado posteriormente? Afinal, um sapato não muda muito de tamanho, não é mesmo?

Podemos usar a função hasattr() para realizar uma verificação em cada objeto de sapato. Possui um atributo privado de tamanho, indicado pela presença de '_size'? Nesse caso, não pode ser alterado. Aqui está o 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")

Configuradores e getters de propriedades são um pouco desafiadores de entender, mas uma vez compreendidos, você estará codificando Python como um profissional!

Fontes:

Material escolar Flatiron