Metaclasses e descriptors são funcionalidades avançadas do Python para meta-programming — controlando como classes e o acesso a atributos se comportam. Elas alimentam muito da "magia" em frameworks (ORMs, Pydantic), embora você raramente as escreva diretamente em código de aplicação.
:
(Dog)
(Dog())
Assim como uma classe cria instâncias, uma metaclass cria classes. Personalizando a metaclass, você pode interceptar e modificar a criação de classes:
class Meta(type):
def __new__(mcs, name, bases, namespace):
# runs when a class USING this metaclass is DEFINED
namespace["created_by"] = "Meta" # inject an attribute into every such class
return super().__new__(mcs, name, bases, namespace)
class MyClass(metaclass=Meta):
pass
MyClass.created_by # "Meta" — injected by the metaclass at class-creation time
Isso permite que frameworks registrem automaticamente classes, validem definições ou adicionem comportamento a cada subclasse — por exemplo, como ORMs transformam atributos de classe em colunas de banco de dados.
Um descriptor é um objeto que define __get__/__set__/__delete__, controlando o que acontece quando um atributo é lido ou escrito:
class Positive:
def __set_name__(self, owner, name):
self.name = f"_{name}"
def __get__(self, obj, objtype=None):
return getattr(obj, self.name)
def __set__(self, obj, value):
if value < 0:
raise ValueError("must be positive") # validate on assignment
setattr(obj, self.name, value)
class Account:
balance = Positive() # a descriptor as a class attribute
a = Account()
a.balance = 100 # calls Positive.__set__ → validates
a.balance = -5 # ❌ ValueError
Descriptors interceptam o acesso a atributos — permitindo validação, atributos computados e carregamento lazy. Na verdade, @property, @classmethod e @staticmethod são todos implementados como descriptors.
Metaclasses → Django/SQLAlchemy ORM models, ABCs, Pydantic, framework registration
Descriptors → @property, ORM fields, validation libraries, lazy attributes
Metaclasses e descriptors são a maquinaria de meta-programming por trás de muitas das bibliotecas mais poderosas do Python — ORMs que transformam definições de classe em esquemas de banco de dados, frameworks de validação como Pydantic, e até built-ins como @property (um descriptor).
Embora a maioria dos desenvolvedores raramente as escreva diretamente (e não deva recorrer a elas quando ferramentas mais simples são suficientes), compreendê-las desmistifica como esses frameworks alcançam sua "magia" de customização em nível de classe e acesso controlado a atributos.
Esse conhecimento é valioso para design avançado de bibliotecas, depuração do comportamento de frameworks e compreensão profunda do modelo de objetos do Python — é o que separa a compreensão intermediária da compreensão em nível de especialista da linguagem.