Metaclasses en descriptors zijn geavanceerde Python-functies voor meta-programmeren — het controleren hoe klassen en attribuuttoegang zich gedragen. Ze voeden veel van de "magie" in frameworks (ORM, Pydantic), hoewel je ze zelden rechtstreeks in applicatiecode schrijft.
:
(Dog)
(Dog())
Net zoals een klasse instanties creëert, creëert een metaclass klassen. Door de metaclass aan te passen, kun je klassecreatie onderscheppen en wijzigen:
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
Dit stelt frameworks in staat om automatisch klassen te registreren, definities te valideren of gedrag aan elke subklasse toe te voegen — bijvoorbeeld hoe ORM's klassenattributen in databasekolommen veranderen.
Een descriptor is een object dat __get__/__set__/__delete__ definieert, waarmee wordt gecontroleerd wat er gebeurt wanneer een attribuut wordt gelezen of geschreven:
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 onderscheppen attribuuttoegang — waardoor validatie, berekende attributen en lazy loading mogelijk worden. Sterker nog, @property, @classmethod en @staticmethod zijn allemaal geïmplementeerd als descriptors.
Metaclasses → Django/SQLAlchemy ORM models, ABCs, Pydantic, framework registration
Descriptors → @property, ORM fields, validation libraries, lazy attributes
Metaclasses en descriptors zijn de meta-programmering-machinery achter veel van Python's krachtigste libraries — ORM's die klassedefinities in databaseschema's veranderen, validatieframeworks zoals Pydantic, en zelfs ingebouwde functies zoals @property (een descriptor).
Hoewel de meeste developers ze zelden rechtstreeks schrijven (en dat ook niet zouden moeten doen wanneer eenvoudigere tools beschikbaar zijn), helpt het begrijpen ervan demystifice hoe deze frameworks hun "magie" van klassenniveau-aanpassing en gecontroleerde attribuuttoegang bereiken.
Deze kennis is waardevol voor geavanceerd bibliotheekontwerp, debuggen van frameworkgedrag en diep begrip van Python's objectmodel — het is wat gevorderd niveau onderscheidt van expert-niveau begrip van de taal.