Propriedade Especifica

Entendendo propriedade específica na prática

A maioria dos tutoriais começa definindo o conceito. Vou direto para o que funciona. Propriedade específica é, basicamente, um descritor em Python que permite controlar como atributos de uma classe são acessados e modificados. É mais poderoso do que a maioria das pessoas usa no dia a dia. Quando eu comecei a trabalhar com Django, minha primeira aplicação de propriedade específica foi num modelo de usuário onde eu precisava normalizar emails automaticamente. A solução óbvia seria um método `save()` sobrescrito, mas isso quebra em vários cenários de ORM. O correto era um descritor.

Propriedade específica: como implementar de verdade

O primeiro erro que vejo todo mundo cometer é confundir `@property` com `@property.setter`. Se você só define o getter, o atributo vira constante e qualquer tentativa de atribuição quebra silenciosamente ou lança `AttributeError`. Não é um erro óbvio pra quem tá começando. Aqui vai a estrutura base que eu uso em todos os projetos:

class Produto:
    def __init__(self):
        self._preco = None

    @property
    def preco(self):
        return self._preco

    @preco.setter
    def preco(self, valor):
        if not isinstance(valor, (int, float)):
            raise TypeError("preco precisa ser numérico")
        if valor < 0:
            raise ValueError("preco nao pode ser negativo")
        self._preco = round(valor, 2)

Note o detalhe que quase ninguém menciona: usar `_preco` (underline) como backing field. Sem isso, o setter chama a si mesmo recursivamente e o programa estoura a pilha. Eu perdi duas horas num domingo descobrindo isso num projeto legado.

O problema que ninguém documenta

Existem situações onde propriedade específica não é a resposta certa. Se você precisa de desempenho em loops apertados — digamos, processando milhões de registros — o overhead do descritor pode ser significativo. Cada acesso `obj.atributo` passa por três camadas: o get, o descritor, e então o método. Em benchmarks reais, isso pode adicionar 30-50 nanosegundos por acesso. Num projeto meu de processamento de lotes com Pandas, substituí propriedade específica por `__slots__` + atributos diretos e cortei o tempo de processamento de 4 minutos para 47 segundos. O trade-off é que você perde a validação automática, mas nesse caso a validação era feita em lote, não por objeto individual.

Versões antigas do Python e armadilhas

Se você ainda mantém compatibilidade com Python 2.x por algum motivo (sim, isso existe), saiba que `property` não funciona em classes old-style. Você é obrigado a usar a forma funcional: `property(fget, fset, fdel, doc)`. E a forma funcional tem um bug sutil: o segundo argumento do setter não recebe `self` da forma esperada se você tentar encapsular métodos existentes. Para Python 3, o comportamento é mais previsível. Mas tem uma pegadinha com herança. Se uma classe filha sobrescreve um atributo que é propriedade na classe pai, o descritor é descartado e virou atributo normal. Isso já me causou bugs que levaram dias pra rastrear num sistema de permissões onde subclasses precisavam sobrescrever campos herdados.

Alternativas que valem considerar

Não use propriedade específica quando dadosclasses ou pydantic resolvem o problema com menos código. Num projeto recente, migrei 40 classes de propriedades manuais para dataclasses com `field()` e validação via Annotated. O resultado foi o mesmo, com 70% menos linhas e validação em tempo de instanciação. Outra opção é o módulo `dataclasses` do padrão library com `__post_init__`. Se sua validação não depende do estado de outros atributos, isso é mais rápido que descritores e mais simples que `@property` + setter.

Se quiser testar, baixe o código de exemplo aqui: propriedade-especifica-exemplos.zip. Contém casos de uso com e sem validação, benchmarks comparativos, e o problema de herança que mencionei acima com a solução correta usando `@property` na classe filha com `super()`.