Metaclasses et descriptors sont des fonctionnalités avancées de Python pour la meta-programmation — contrôler le comportement des classes et l'accès aux attributs. Ils alimentent beaucoup de la "magie" dans les frameworks (ORMs, Pydantic), bien que vous les écriviez rarement directement dans le code de l'application.
:
(Dog)
(Dog())
Comme une classe crée des instances, une métaclasse crée des classes. En personnalisant la métaclasse, vous pouvez intercepter et modifier la création de 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
Cela permet aux frameworks d'enregistrer automatiquement les classes, de valider les définitions ou d'ajouter du comportement à chaque sous-classe — par exemple, comment les ORMs transforment les attributs de classe en colonnes de base de données.
Un descripteur est un objet qui définit __get__/__set__/__delete__, contrôlant ce qui se passe lorsqu'un attribut est lu ou écrit :
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
Les descripteurs interceptent l'accès aux attributs — permettent la validation, les attributs calculés et le chargement différé. En fait, @property, @classmethod et @staticmethod sont tous implémentés en tant que descripteurs.
Metaclasses → Django/SQLAlchemy ORM models, ABCs, Pydantic, framework registration
Descriptors → @property, ORM fields, validation libraries, lazy attributes
Les métaclasses et les descripteurs sont les machines de meta-programmation derrière beaucoup des bibliothèques les plus puissantes de Python — les ORMs qui transforment les définitions de classe en schémas de base de données, les frameworks de validation comme Pydantic, et même les éléments intégrés comme @property (un descripteur).
Bien que la plupart des développeurs les écrivent rarement directement (et ne devraient pas y recourir lorsque des outils plus simples sont disponibles), les comprendre démystifie comment ces frameworks réalisent leur "magie" de personnalisation au niveau de la classe et d'accès contrôlé aux attributs.
Cette connaissance est précieuse pour la conception avancée de bibliothèques, le débogage du comportement des frameworks et une compréhension approfondie du modèle objet de Python — c'est ce qui sépare une compréhension intermédiaire d'une compréhension au niveau d'expert du langage.