Le metaclassi e i descriptor sono funzionalità Python avanzate per la meta-programmazione — controllano come si comportano le classi e come funziona l'accesso agli attributi. Alimentano gran parte della "magia" nei framework (ORM, Pydantic), anche se raramente le scrivi direttamente nel codice dell'applicazione.
:
(Dog)
(Dog())
Come una classe crea istanze, una metaclasse crea classi. Personalizzando la metaclasse, puoi intercettare e modificare la creazione della classe:
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
Ciò consente ai framework di registrare automaticamente le classi, convalidare le definizioni o aggiungere comportamenti a ogni sottoclasse — ad esempio come gli ORM trasformano gli attributi della classe in colonne del database.
Un descriptor è un oggetto che definisce __get__/__set__/__delete__, controllando cosa accade quando un attributo viene letto o scritto:
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
I descriptor intercettano l'accesso agli attributi — abilitando validazione, attributi calcolati e lazy loading. Infatti, @property, @classmethod e @staticmethod sono tutti implementati come descriptor.
Metaclasses → Django/SQLAlchemy ORM models, ABCs, Pydantic, framework registration
Descriptors → @property, ORM fields, validation libraries, lazy attributes
Le metaclassi e i descriptor sono il macchinario di meta-programmazione dietro molte delle librerie Python più potenti — gli ORM che trasformano le definizioni delle classi in schemi di database, framework di validazione come Pydantic, e persino built-in come @property (descriptor).
Sebbene la maggior parte degli sviluppatori raramente li scriva direttamente (e non dovrebbe ricorrervi quando sono disponibili strumenti più semplici), comprenderli demistifica come questi framework raggiungono la loro "magia" della personalizzazione a livello di classe e dell'accesso controllato agli attributi.
Questa conoscenza è preziosa per il design avanzato di librerie, il debugging del comportamento del framework e la profonda comprensione del modello di oggetti di Python — è ciò che separa la comprensione a livello intermedio da quella a livello esperto del linguaggio.