Metaclasses and descriptors are advanced Python features for meta-programming — controlling how classes and attribute access behave. They power much of the "magic" in frameworks (ORMs, Pydantic), though you rarely write them directly in application code.
:
(Dog)
(Dog())
Just as a class creates instances, a metaclass creates classes. By customizing the metaclass, you can intercept and modify class creation:
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
This lets frameworks automatically register classes, validate definitions, or add behavior to every subclass — e.g. how ORMs turn class attributes into database columns.
A descriptor is an object that defines __get__/__set__/__delete__, controlling what happens when an attribute is read or written:
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 intercept attribute access — enabling validation, computed attributes, and lazy loading. In fact, @property, @classmethod, and @staticmethod are all implemented as descriptors.
Metaclasses → Django/SQLAlchemy ORM models, ABCs, Pydantic, framework registration
Descriptors → @property, ORM fields, validation libraries, lazy attributes
Metaclasses and descriptors are the meta-programming machinery behind much of Python's most powerful libraries — ORMs that turn class definitions into database schemas, validation frameworks like Pydantic, and even built-ins like @property (a descriptor).
While most developers rarely write them directly (and shouldn't reach for them when simpler tools suffice), understanding them demystifies how these frameworks achieve their "magic" of class-level customization and controlled attribute access.
This knowledge is valuable for advanced library design, debugging framework behavior, and deeply understanding Python's object model — it's what separates intermediate from expert-level understanding of the language.