Metaclasses & Class Customization

class Foo:
    pass

print(type(Foo))       # <class 'type'>
print(type(Foo()))     # <class '__main__.Foo'>
print(isinstance(Foo, type))  # True

Common follow-ups: How is type() used both as a function and as the base metaclass?;What's the class hierarchy of type itself?

def greet(self):
    return f'Hello, {self.name}'

Person = type('Person', (object,), {
    '__init__': lambda self, name: setattr(self, 'name', name),
    'greet': greet,
})

p = Person('Alice')
print(p.greet())  # Hello, Alice

Common follow-ups: When would dynamic class creation be preferable to a class statement?;How does this relate to class decorators as an alternative?

class ValidatingMeta(type):
    def __new__(mcs, name, bases, namespace):
        if 'process' not in namespace and bases:
            raise TypeError(f'{name} must implement process()')
        return super().__new__(mcs, name, bases, namespace)

class Base(metaclass=ValidatingMeta):
    def process(self): pass

class Bad(Base):  # raises TypeError: missing process()
    pass

Common follow-ups: Why do most Python developers reach for __init_subclass__ instead of a full metaclass?;How do metaclasses interact with multiple inheritance?

class Plugin:
    registry = []
    def __init_subclass__(cls, **kwargs):
        super().__init_subclass__(**kwargs)
        Plugin.registry.append(cls)

class MyPlugin(Plugin):
    pass

print(Plugin.registry)  # [<class 'MyPlugin'>]

Common follow-ups: What can metaclasses do that __init_subclass__ cannot?;How do class keyword arguments work with __init_subclass__?

class Container:
    def __class_getitem__(cls, item):
        return f'{cls.__name__}[{item.__name__}]'

print(Container[int])  # 'Container[int]'
print(list[int])       # list[int] -- built-in generics support this too

Common follow-ups: How does this differ from typing.Generic's __class_getitem__?;Why was this added in PEP 560?

class OrderedMeta(type):
    @classmethod
    def __prepare__(mcs, name, bases):
        return {}  # could return a custom ordered/tracking mapping

    def __new__(mcs, name, bases, namespace):
        cls = super().__new__(mcs, name, bases, namespace)
        cls._field_order = list(namespace.keys())
        return cls

Common follow-ups: Why is __prepare__ less necessary since Python 3.7 (dicts are ordered)?;What other customizations can __prepare__ enable?

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self): ...

class Circle(Shape):
    def __init__(self, r): self.r = r
    def area(self): return 3.14159 * self.r ** 2

try:
    Shape()  # TypeError: Can't instantiate abstract class
except TypeError as e:
    print(e)

Common follow-ups: How does ABCMeta interact with __init_subclass__?;What's the difference between ABC and Protocol for structural typing?

def add_repr(cls):
    cls.__repr__ = lambda self: f'{cls.__name__}({self.__dict__})'
    return cls

@add_repr
class Point:
    def __init__(self, x, y):
        self.x, self.y = x, y

print(Point(1,2))  # Point({'x': 1, 'y': 2})

Common follow-ups: When would you need a metaclass instead of a simpler class decorator?;Can class decorators and metaclasses be combined?

class MetaA(type): pass
class MetaB(type): pass
class A(metaclass=MetaA): pass
class B(metaclass=MetaB): pass

try:
    class C(A, B): pass  # TypeError: metaclass conflict
except TypeError as e:
    print(e)

Common follow-ups: How do you resolve a metaclass conflict manually?;Why does Python require metaclass compatibility across bases?

class Field:
    def __set_name__(self, owner, name):
        self.name = f'_{name}'
    def __get__(self, obj, objtype=None):
        return getattr(obj, self.name, None)
    def __set__(self, obj, value):
        setattr(obj, self.name, value)

class Model:
    title = Field()  # __set_name__ called automatically with name='title'

Common follow-ups: When was __set_name__ introduced and what problem did it solve (PEP 487)?;How does this interact with __init_subclass__?