Python 后端开发技术博客专栏 | 第 07 篇元类与类的创建过程 -- Python 最深层的魔法

难度等级： 专家
适合读者： 有 Python 基础的开发者，准备面试的中高级工程师
前置知识： 第 03 篇《面向对象编程进阶》、第 06 篇《描述符与属性管理》

导读

Python 中有一句经典格言："一切皆对象"。整数是对象，字符串是对象，函数是对象 -- 但类本身也是对象 。既然类是对象，那么创建类的"东西"是什么？答案是元类（Metaclass）。

当你写 class Foo: pass 时，Python 在幕后做了远比你想象中复杂的事情：它收集类体中定义的所有属性和方法，调用元类来创建类对象，再把类对象绑定到 Foo 这个名字上。默认的元类是 type -- 没错，就是你用来检查类型的那个 type()。

元类在日常开发中并不常见，但它是 Python 对象模型的基石，也是很多框架的核心实现机制：

Django ORM ：class User(models.Model) 背后是 ModelBase 元类自动收集字段、注册模型
SQLAlchemy ：DeclarativeBase 通过元类将类属性映射为数据库列
Pydantic ：BaseModel 的元类负责解析类型标注、生成校验器
abc.ABC ：抽象基类通过 ABCMeta 元类强制子类实现抽象方法

本文将从类的创建过程出发，系统讲解元类的工作原理、典型应用模式，以及 __init_subclass__、类装饰器等更轻量的替代方案。最后我们会讲解 abc.ABCMeta 和 typing.Protocol 在接口约束中的实战用法。

学习目标

读完本文后，你将能够：

理解 type 的双重身份（类型检查 + 元类），掌握 type(name, bases, namespace) 动态创建类的完整流程
理解类创建过程中 __prepare__、__new__、__init__ 的调用顺序与职责
掌握元类的传播规则，能在面试中解释 metaclass= 参数的工作机制
能用元类实现单例模式、API 路由注册、字段收集等典型应用
理解 __init_subclass__ 作为元类轻量替代的适用场景
在元类、类装饰器、__init_subclass__ 之间做出合理选型
掌握 abc.ABCMeta 和 typing.Protocol 的使用差异

一、类的创建过程

1.1 type 的双重身份

type 在 Python 中有两个完全不同的用途：

python 复制代码

# 用途 1：检查对象的类型（传入一个参数）
print(type(42))        # <class 'int'>
print(type("hello"))   # <class 'str'>
print(type([1, 2]))    # <class 'list'>

# 用途 2：创建新的类（传入三个参数）
# type(name, bases, namespace) -> 新的类对象
MyClass = type("MyClass", (object,), {"x": 42, "greet": lambda self: "hello"})
obj = MyClass()
print(obj.x)        # 42
print(obj.greet())   # hello
print(type(obj))     # <class '__main__.MyClass'>

关键洞察 ：type 既是一个类（所有类的默认元类），又是一个可调用对象（用来创建类）。在 CPython 中，type 的类型是它自己 -- type(type) is type。

python 复制代码

# type 的自引用关系
print(type(int))       # <class 'type'> -- int 的类型是 type
print(type(type))      # <class 'type'> -- type 的类型也是 type
print(type(object))    # <class 'type'> -- object 的类型也是 type

# 但 type 继承自 object
print(type.__bases__)  # (<class 'object'>,)

# 这构成了一个"鸡生蛋"的关系：
# type 是 object 的类型（type(object) is type）
# object 是 type 的基类（type.__bases__ == (object,))
# 这个循环是在 CPython 启动时通过 C 代码直接建立的

1.2 class 语句的执行过程

当 Python 执行一个 class 语句时，实际经历了以下步骤：

python 复制代码

# 以下两种写法在语义上是等价的：

# 写法 1：class 语句
class Dog:
    species = "Canis familiaris"

    def __init__(self, name: str):
        self.name = name

    def bark(self) -> str:
        return f"{self.name} says woof!"


# 写法 2：手动调用 type()
def dog_init(self, name: str):
    self.name = name

def dog_bark(self) -> str:
    return f"{self.name} says woof!"

Dog2 = type("Dog2", (object,), {
    "species": "Canis familiaris",
    "__init__": dog_init,
    "bark": dog_bark,
})

# 验证行为一致
d1 = Dog("Rex")
d2 = Dog2("Rex")
print(d1.bark())  # Rex says woof!
print(d2.bark())  # Rex says woof!
print(d1.species == d2.species)  # True

class 语句的完整执行流程（面试核心考点）：

复制代码

1. 确定元类（metaclass）
   - 如果显式指定了 metaclass=，使用它
   - 如果有基类，使用基类的元类
   - 否则使用默认的 type

2. 调用 metaclass.__prepare__(name, bases, **kwargs)
   - 返回一个映射对象作为类的命名空间（默认是普通 dict）

3. 在命名空间中执行类体代码
   - 类体中的赋值、def、装饰器等都写入这个命名空间

4. 调用 metaclass(name, bases, namespace, **kwargs)
   - 即 metaclass.__new__(mcs, name, bases, namespace)
   - 再 metaclass.__init__(cls, name, bases, namespace)
   - 返回类对象

1.3 `prepare`：自定义类的命名空间

__prepare__ 是元类的类方法，它在执行类体代码之前被调用，返回一个映射对象作为命名空间。默认返回普通 dict，但你可以返回 OrderedDict 或自定义映射来实现特殊行为。

python 复制代码

from collections import OrderedDict


class OrderedMeta(type):
    """记录属性定义顺序的元类"""

    @classmethod
    def __prepare__(mcs, name, bases, **kwargs):
        return OrderedDict()

    def __new__(mcs, name, bases, namespace, **kwargs):
        cls = super().__new__(mcs, name, bases, dict(namespace))
        # 保存属性定义顺序（过滤掉 dunder 属性）
        cls._field_order = [
            key for key in namespace.keys()
            if not key.startswith("_")
        ]
        return cls


class Config(metaclass=OrderedMeta):
    host = "localhost"
    port = 5432
    database = "mydb"
    username = "admin"
    password = "secret"


print(Config._field_order)
# ['host', 'port', 'database', 'username', 'password']
# 注意：Python 3.7+ 的 dict 已经保持插入顺序，
# 所以这个例子主要是展示 __prepare__ 的机制

实际应用场景 ：在 Python 3.6 之前，dict 不保证顺序，__prepare__ 对于需要保留字段定义顺序的 ORM 框架至关重要。虽然 Python 3.7+ 的 dict 已经有序，但 __prepare__ 仍然有用 -- 你可以返回一个"检测重复定义"的映射，或者一个"记录所有访问"的映射。

python 复制代码

class NoDuplicateDict(dict):
    """禁止重复定义属性的命名空间"""

    def __setitem__(self, key, value):
        if key in self and not key.startswith("_"):
            raise TypeError(f"Duplicate definition of '{key}'")
        super().__setitem__(key, value)


class StrictMeta(type):
    @classmethod
    def __prepare__(mcs, name, bases, **kwargs):
        return NoDuplicateDict()

    def __new__(mcs, name, bases, namespace, **kwargs):
        return super().__new__(mcs, name, bases, dict(namespace))


# 正常使用
class GoodConfig(metaclass=StrictMeta):
    host = "localhost"
    port = 5432

print(GoodConfig.host)  # localhost

# 重复定义会报错
try:
    class BadConfig(metaclass=StrictMeta):
        host = "localhost"
        host = "10.0.0.1"  # 重复定义！
except TypeError as e:
    print(f"Caught: {e}")  # Caught: Duplicate definition of 'host'

二、元类（Metaclass）

2.1 自定义元类

元类是 type 的子类，通过覆写 __new__ 和 __init__ 来控制类的创建过程：

python 复制代码

class MetaWithLogging(type):
    """记录所有类创建过程的元类"""

    _registry: dict = {}

    def __new__(mcs, name, bases, namespace, **kwargs):
        """控制类对象的创建"""
        cls = super().__new__(mcs, name, bases, namespace)
        # 注册到全局注册表
        mcs._registry[name] = cls
        return cls

    def __init__(cls, name, bases, namespace, **kwargs):
        """类对象创建后的初始化"""
        super().__init__(name, bases, namespace)


class Animal(metaclass=MetaWithLogging):
    pass

class Dog(Animal):  # 元类自动继承给子类
    pass

class Cat(Animal):
    pass

print(MetaWithLogging._registry)
# {'Animal': <class 'Animal'>, 'Dog': <class 'Dog'>, 'Cat': <class 'Cat'>}

2.2 metaclass= 的传播规则

当一个类指定了 metaclass=，它的所有子类都会继承这个元类。如果子类指定了不同的元类，Python 会检查元类兼容性：

python 复制代码

class MetaA(type):
    pass

class MetaB(type):
    pass

class A(metaclass=MetaA):
    pass

class B(metaclass=MetaB):
    pass

# 元类冲突！MetaA 和 MetaB 没有继承关系
try:
    class C(A, B):  # A 的元类是 MetaA，B 的元类是 MetaB
        pass
except TypeError as e:
    print(f"Metaclass conflict: {e}")
    # metaclass conflict: the metaclass of a derived class must be a
    # (non-strict) subclass of the metaclasses of all its bases

# 解决方案：创建一个同时继承两个元类的元类
class MetaC(MetaA, MetaB):
    pass

class C(A, B, metaclass=MetaC):
    pass
print(type(C))  # <class '__main__.MetaC'>

传播规则总结：

如果显式指定 metaclass=，使用指定的元类
如果没有指定，从基类中找到"最具体的"元类（即所有基类的元类中，是其他元类的子类的那个）
如果基类的元类之间不存在继承关系，抛出 TypeError

2.3 元类典型应用：单例模式

python 复制代码

class SingletonMeta(type):
    """单例元类：确保每个类只有一个实例"""

    _instances: dict = {}

    def __call__(cls, *args, **kwargs):
        """拦截实例创建（即 MyClass() 的调用）"""
        if cls not in cls._instances:
            # 调用父类（type）的 __call__ 来真正创建实例
            instance = super().__call__(*args, **kwargs)
            cls._instances[cls] = instance
        return cls._instances[cls]


class DatabaseConnection(metaclass=SingletonMeta):
    def __init__(self, host: str = "localhost", port: int = 5432):
        self.host = host
        self.port = port

    def __repr__(self) -> str:
        return f"DatabaseConnection({self.host}:{self.port})"


# 无论创建多少次，返回的都是同一个实例
conn1 = DatabaseConnection("10.0.0.1", 5432)
conn2 = DatabaseConnection("10.0.0.2", 3306)  # 参数被忽略，返回已有实例

print(conn1 is conn2)  # True
print(conn1)           # DatabaseConnection(10.0.0.1:5432)
print(id(conn1) == id(conn2))  # True

原理解析 ：当你写 DatabaseConnection() 时，Python 实际上调用的是 type(DatabaseConnection).__call__(DatabaseConnection)，即元类的 __call__。通过覆写元类的 __call__，我们可以拦截实例的创建过程。

2.4 元类典型应用：API 路由注册

python 复制代码

class PluginRegistry(type):
    """插件/路由自动注册元类"""

    _plugins: dict = {}

    def __new__(mcs, name, bases, namespace, **kwargs):
        cls = super().__new__(mcs, name, bases, namespace)
        # 跳过基类本身的注册
        if bases:  # 只注册子类
            # 从类属性或类名推断注册名
            register_name = namespace.get("name", name.lower())
            mcs._plugins[register_name] = cls
        return cls

    @classmethod
    def get_plugin(mcs, name: str):
        return mcs._plugins.get(name)

    @classmethod
    def list_plugins(mcs):
        return dict(mcs._plugins)


class Handler(metaclass=PluginRegistry):
    """处理器基类"""
    def handle(self, data: dict) -> dict:
        raise NotImplementedError


class JSONHandler(Handler):
    name = "json"
    def handle(self, data: dict) -> dict:
        return {"format": "json", "data": data}


class XMLHandler(Handler):
    name = "xml"
    def handle(self, data: dict) -> dict:
        return {"format": "xml", "data": data}


class CSVHandler(Handler):
    name = "csv"
    def handle(self, data: dict) -> dict:
        return {"format": "csv", "data": data}


# 自动注册，无需手动维护列表
print(PluginRegistry.list_plugins())
# {'json': <class 'JSONHandler'>, 'xml': <class 'XMLHandler'>, 'csv': <class 'CSVHandler'>}

# 根据名称获取处理器
handler_cls = PluginRegistry.get_plugin("json")
handler = handler_cls()
print(handler.handle({"key": "value"}))
# {'format': 'json', 'data': {'key': 'value'}}

2.5 元类典型应用：字段收集（ORM 模式）

python 复制代码

class ModelMeta(type):
    """ORM 模型元类：自动收集 Field 定义"""

    def __new__(mcs, name, bases, namespace, **kwargs):
        # 收集所有字段
        fields = {}
        for key, value in namespace.items():
            if isinstance(value, FieldBase):
                fields[key] = value
                value.name = key

        # 创建类
        cls = super().__new__(mcs, name, bases, namespace)
        cls._meta_fields = fields
        cls._table_name = namespace.get("__tablename__", name.lower())
        return cls


class FieldBase:
    """字段基类"""
    def __init__(self, field_type: str, required: bool = True):
        self.field_type = field_type
        self.required = required
        self.name = ""

    def __repr__(self):
        return f"{self.__class__.__name__}(name={self.name!r}, type={self.field_type!r})"


class StringField(FieldBase):
    def __init__(self, max_length: int = 255, **kwargs):
        super().__init__("VARCHAR", **kwargs)
        self.max_length = max_length


class IntField(FieldBase):
    def __init__(self, **kwargs):
        super().__init__("INTEGER", **kwargs)


class BaseModel(metaclass=ModelMeta):
    """所有模型的基类"""

    def __init__(self, **kwargs):
        for name, field in self.__class__._meta_fields.items():
            if name in kwargs:
                setattr(self, name, kwargs[name])
            elif field.required:
                raise ValueError(f"Missing required field: {name}")

    @classmethod
    def describe(cls) -> str:
        lines = [f"Table: {cls._table_name}"]
        for name, field in cls._meta_fields.items():
            req = "NOT NULL" if field.required else "NULL"
            lines.append(f"  {name}: {field.field_type} {req}")
        return "\n".join(lines)


class User(BaseModel):
    __tablename__ = "users"
    name = StringField(max_length=50)
    email = StringField(max_length=100, required=False)
    age = IntField()


class Article(BaseModel):
    __tablename__ = "articles"
    title = StringField(max_length=200)
    content = StringField(max_length=65535)
    author_id = IntField()


# 自动收集字段
print(User.describe())
# Table: users
#   name: VARCHAR NOT NULL
#   email: VARCHAR NULL
#   age: INTEGER NOT NULL

print()
print(Article.describe())
# Table: articles
#   title: VARCHAR NOT NULL
#   content: VARCHAR NOT NULL
#   author_id: INTEGER NOT NULL

# 创建实例
u = User(name="Alice", age=30)
print(u.name, u.age)  # Alice 30

三、`__init_subclass__` -- 元类的轻量替代

3.1 基本用法

Python 3.6 引入的 __init_subclass__ 提供了一种无需编写元类就能拦截子类创建的方式。对于大多数"在子类创建时做点什么"的场景，它比元类简单得多：

python 复制代码

class PluginBase:
    """使用 __init_subclass__ 实现插件注册"""

    _registry: dict = {}

    def __init_subclass__(cls, *, plugin_name: str = "", **kwargs):
        """每当有子类被创建时自动调用"""
        super().__init_subclass__(**kwargs)
        name = plugin_name or cls.__name__.lower()
        cls._registry[name] = cls
        cls._plugin_name = name

    @classmethod
    def get_plugin(cls, name: str):
        return cls._registry.get(name)

    @classmethod
    def list_plugins(cls):
        return dict(cls._registry)


class JSONPlugin(PluginBase, plugin_name="json"):
    def process(self, data):
        return {"format": "json", "data": data}


class XMLPlugin(PluginBase, plugin_name="xml"):
    def process(self, data):
        return {"format": "xml", "data": data}


class DefaultPlugin(PluginBase):  # 不传 plugin_name，使用类名
    def process(self, data):
        return {"format": "default", "data": data}


print(PluginBase.list_plugins())
# {'json': <class 'JSONPlugin'>, 'xml': <class 'XMLPlugin'>, 'defaultplugin': <class 'DefaultPlugin'>}

# 使用
handler = PluginBase.get_plugin("json")()
print(handler.process({"key": "value"}))
# {'format': 'json', 'data': {'key': 'value'}}

3.2 `__init_subclass__` 的高级用法

python 复制代码

class Serializable:
    """强制子类定义 version 属性和 serialize 方法"""

    def __init_subclass__(cls, **kwargs):
        super().__init_subclass__(**kwargs)
        # 检查必须的类属性
        if not hasattr(cls, "version"):
            raise TypeError(f"{cls.__name__} must define a 'version' class attribute")
        # 检查必须的方法
        if not callable(getattr(cls, "serialize", None)):
            raise TypeError(f"{cls.__name__} must implement 'serialize' method")


class UserData(Serializable):
    version = "1.0"

    def serialize(self) -> dict:
        return {"version": self.version}


# 正常创建
ud = UserData()
print(ud.serialize())  # {'version': '1.0'}

# 缺少 version 会报错
try:
    class BadData(Serializable):
        def serialize(self) -> dict:
            return {}
except TypeError as e:
    print(f"Caught: {e}")  # Caught: BadData must define a 'version' class attribute

3.3 `__init_subclass__` vs 元类

特性	`__init_subclass__`	元类
引入版本	Python 3.6	Python 2
复杂度	低（普通方法）	高（需要理解 type）
能力范围	在子类创建后做处理	完全控制类创建过程
能否自定义命名空间	否	是（`__prepare__`）
能否修改类的创建方式	有限	完全可以
可组合性	好（多继承时自动链式调用）	差（元类冲突）
适用场景	注册、校验、设置默认值	ORM、单例、深度定制

选型建议：

如果只需要"在子类创建时做点什么"（注册、校验、注入属性），优先用 __init_subclass__
如果需要控制类的命名空间（__prepare__）或拦截实例化过程（__call__），使用元类
如果你不确定，先尝试 __init_subclass__。Python 核心开发者 Nick Coghlan 曾说："如果你能用 __init_subclass__ 解决问题，就不要用元类"

四、类装饰器 vs 元类

4.1 类装饰器的实现模式

类装饰器是另一种在类创建后修改类的方式。它比元类更简单、更直观：

python 复制代码

import functools
import time
from typing import Any


def singleton(cls):
    """单例类装饰器"""
    instances: dict = {}

    @functools.wraps(cls, updated=[])
    class Wrapper(cls):
        def __new__(wrapper_cls, *args, **kwargs):
            if cls not in instances:
                instance = super().__new__(wrapper_cls)
                instances[cls] = instance
                instance._initialized = False
            return instances[cls]

        def __init__(self, *args, **kwargs):
            if not self._initialized:
                super().__init__(*args, **kwargs)
                self._initialized = True

    return Wrapper


@singleton
class AppConfig:
    def __init__(self, debug: bool = False):
        self.debug = debug

c1 = AppConfig(debug=True)
c2 = AppConfig(debug=False)
print(c1 is c2)    # True
print(c1.debug)    # True（第一次创建时的值，第二次调用不会覆盖）


def add_repr(cls):
    """自动生成 __repr__ 的类装饰器"""
    # 收集 __init__ 的参数名
    import inspect
    init_sig = inspect.signature(cls.__init__)
    param_names = [
        p.name for p in init_sig.parameters.values()
        if p.name != "self"
    ]

    def __repr__(self):
        params = ", ".join(
            f"{name}={getattr(self, name, '?')!r}" for name in param_names
        )
        return f"{cls.__name__}({params})"

    cls.__repr__ = __repr__
    return cls


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

print(Point(1.0, 2.0))  # Point(x=1.0, y=2.0)


def register(registry: dict):
    """参数化的注册类装饰器"""
    def decorator(cls):
        name = getattr(cls, "name", cls.__name__.lower())
        registry[name] = cls
        return cls
    return decorator


HANDLERS: dict = {}

@register(HANDLERS)
class EmailHandler:
    name = "email"
    def send(self, msg: str) -> str:
        return f"Email: {msg}"


@register(HANDLERS)
class SMSHandler:
    name = "sms"
    def send(self, msg: str) -> str:
        return f"SMS: {msg}"


print(HANDLERS)  # {'email': <class 'EmailHandler'>, 'sms': <class 'SMSHandler'>}
handler = HANDLERS["email"]()
print(handler.send("hello"))  # Email: hello

4.2 类装饰器 vs 元类 vs `__init_subclass__` 选型

python 复制代码

# ==========================================
# 对比：三种方式实现"验证子类必须有 name 属性"
# ==========================================

# 方式 1：元类（最强大，最复杂）
class ValidatedMeta(type):
    def __new__(mcs, name, bases, namespace, **kwargs):
        cls = super().__new__(mcs, name, bases, namespace)
        if bases and "name" not in namespace:
            raise TypeError(f"{name} must define 'name'")
        return cls

# 方式 2：__init_subclass__（推荐）
class ValidatedBase:
    def __init_subclass__(cls, **kwargs):
        super().__init_subclass__(**kwargs)
        if not hasattr(cls, "name"):
            raise TypeError(f"{cls.__name__} must define 'name'")

# 方式 3：类装饰器（最简单，但需要显式使用）
def require_name(cls):
    if not hasattr(cls, "name"):
        raise TypeError(f"{cls.__name__} must define 'name'")
    return cls

完整选型指南：

场景	推荐方案	理由
注册子类到全局注册表	`__init_subclass__`	自动对所有子类生效，无需显式标记
验证子类的结构	`__init_subclass__`	简单直观，Python 3.6+ 推荐方式
单例模式	元类 or 类装饰器	元类可拦截 `__call__`，装饰器更简单
自定义类命名空间	元类	只有元类有 `__prepare__`
ORM 字段收集	元类	需要深度控制类创建过程
添加方法/属性	类装饰器	最简单直观，显式标记
混合多个基类的约束	`__init_subclass__`	避免元类冲突

五、`abc.ABCMeta` 与抽象基类

5.1 抽象基类（ABC）

abc 模块通过 ABCMeta 元类提供了抽象基类的支持。抽象基类定义了一组接口约束，强制子类实现特定方法：

python 复制代码

from abc import ABC, abstractmethod


class Repository(ABC):
    """数据仓库抽象基类"""

    @abstractmethod
    def get(self, id: int) -> dict:
        """获取单条记录"""
        ...

    @abstractmethod
    def list_all(self) -> list:
        """获取所有记录"""
        ...

    @abstractmethod
    def save(self, entity: dict) -> None:
        """保存记录"""
        ...

    def exists(self, id: int) -> bool:
        """非抽象方法：提供默认实现"""
        try:
            self.get(id)
            return True
        except KeyError:
            return False


# 不能实例化抽象类
try:
    repo = Repository()
except TypeError as e:
    print(f"Cannot instantiate: {e}")
    # Can't instantiate abstract class Repository with abstract methods get, list_all, save


# 必须实现所有抽象方法
class MemoryRepository(Repository):
    def __init__(self):
        self._store: dict = {}
        self._next_id = 1

    def get(self, id: int) -> dict:
        if id not in self._store:
            raise KeyError(f"Entity {id} not found")
        return self._store[id]

    def list_all(self) -> list:
        return list(self._store.values())

    def save(self, entity: dict) -> None:
        if "id" not in entity:
            entity["id"] = self._next_id
            self._next_id += 1
        self._store[entity["id"]] = entity


# 可以实例化，因为实现了所有抽象方法
repo = MemoryRepository()
repo.save({"name": "Alice"})
repo.save({"name": "Bob"})
print(repo.list_all())          # [{'name': 'Alice', 'id': 1}, {'name': 'Bob', 'id': 2}]
print(repo.exists(1))           # True（使用基类的默认实现）
print(repo.exists(999))         # False


# 如果子类没有实现所有抽象方法，也不能实例化
class IncompleteRepo(Repository):
    def get(self, id: int) -> dict:
        return {}
    # 缺少 list_all 和 save

try:
    incomplete = IncompleteRepo()
except TypeError as e:
    print(f"Incomplete: {e}")
    # Can't instantiate abstract class IncompleteRepo with abstract methods list_all, save

5.2 抽象属性

python 复制代码

from abc import ABC, abstractmethod


class Shape(ABC):

    @property
    @abstractmethod
    def area(self) -> float:
        """子类必须实现 area 属性"""
        ...

    @property
    @abstractmethod
    def perimeter(self) -> float:
        """子类必须实现 perimeter 属性"""
        ...

    def describe(self) -> str:
        return f"{self.__class__.__name__}: area={self.area:.2f}, perimeter={self.perimeter:.2f}"


class Rectangle(Shape):
    def __init__(self, width: float, height: float):
        self._width = width
        self._height = height

    @property
    def area(self) -> float:
        return self._width * self._height

    @property
    def perimeter(self) -> float:
        return 2 * (self._width + self._height)


rect = Rectangle(3, 4)
print(rect.describe())   # Rectangle: area=12.00, perimeter=14.00
print(rect.area)          # 12.0
print(rect.perimeter)     # 14.0

5.3 虚拟子类注册（register）

ABC 支持通过 register 方法将第三方类注册为"虚拟子类"，使其通过 isinstance 检查，但不需要实际继承：

python 复制代码

from abc import ABC, abstractmethod


class Renderable(ABC):
    @abstractmethod
    def render(self) -> str:
        ...


# 方式 1：正常继承
class HTMLWidget(Renderable):
    def render(self) -> str:
        return "<div>Widget</div>"


# 方式 2：虚拟子类注册（无需继承）
class ThirdPartyWidget:
    """第三方库的类，我们无法修改它"""
    def render(self) -> str:
        return "<span>Third Party</span>"


# 注册为 Renderable 的虚拟子类
Renderable.register(ThirdPartyWidget)

# isinstance 检查通过
print(isinstance(HTMLWidget(), Renderable))        # True（真正的子类）
print(isinstance(ThirdPartyWidget(), Renderable))  # True（虚拟子类）

# 注意：register 不会检查是否实现了抽象方法！
class BadWidget:
    pass

Renderable.register(BadWidget)
print(isinstance(BadWidget(), Renderable))  # True -- 但 BadWidget 没有 render 方法！
# 这是 register 的局限：它只是"声称"一个关系，不做任何验证

六、Protocol 与结构化子类型

6.1 从名义子类型到结构化子类型

Python 的类型系统支持两种子类型关系：

名义子类型（Nominal Subtyping） ：通过继承建立，class Dog(Animal) 使 Dog 成为 Animal 的子类型
结构化子类型（Structural Subtyping）：通过结构匹配，只要一个对象实现了必要的方法，就被视为某个类型的子类型

typing.Protocol（Python 3.8+）就是结构化子类型的实现：

python 复制代码

from typing import Protocol, runtime_checkable, List


@runtime_checkable
class Sortable(Protocol):
    """任何有 __lt__ 方法的对象都是 Sortable"""
    def __lt__(self, other) -> bool: ...


@runtime_checkable
class HasName(Protocol):
    """任何有 name 属性的对象都符合 HasName"""
    name: str


@runtime_checkable
class Closeable(Protocol):
    """任何有 close 方法的对象都是 Closeable"""
    def close(self) -> None: ...


# 不需要继承 Protocol，只要结构匹配即可
class DatabaseConn:
    def __init__(self, host: str):
        self.name = f"DB:{host}"

    def close(self) -> None:
        print(f"Closing {self.name}")


class FileHandle:
    def __init__(self, path: str):
        self.name = path

    def close(self) -> None:
        print(f"Closing file {self.name}")


# runtime_checkable 允许 isinstance 检查
conn = DatabaseConn("localhost")
fh = FileHandle("/tmp/data.txt")

print(isinstance(conn, Closeable))  # True
print(isinstance(fh, Closeable))    # True
print(isinstance(conn, HasName))    # True
print(isinstance("hello", HasName)) # False -- str 没有 name 属性


def close_all(resources: List[Closeable]) -> None:
    """关闭所有资源 -- 只要有 close 方法就行"""
    for r in resources:
        r.close()

close_all([conn, fh])
# Closing DB:localhost
# Closing file /tmp/data.txt

6.2 Protocol vs ABC 选型

python 复制代码

from abc import ABC, abstractmethod
from typing import Protocol, runtime_checkable


# ABC 方式：需要显式继承
class LoggerABC(ABC):
    @abstractmethod
    def log(self, message: str) -> None: ...

class FileLoggerABC(LoggerABC):  # 必须显式继承
    def log(self, message: str) -> None:
        print(f"[FILE] {message}")


# Protocol 方式：结构匹配，无需继承
@runtime_checkable
class LoggerProto(Protocol):
    def log(self, message: str) -> None: ...

class FileLoggerProto:  # 不需要继承任何东西
    def log(self, message: str) -> None:
        print(f"[FILE] {message}")


# 两者都通过类型检查
abc_logger: LoggerABC = FileLoggerABC()
proto_logger: LoggerProto = FileLoggerProto()

print(isinstance(abc_logger, LoggerABC))      # True
print(isinstance(proto_logger, LoggerProto))   # True

# Protocol 的优势：第三方类也能通过检查
class ThirdPartyLogger:
    """来自第三方库，我们无法修改它"""
    def log(self, message: str) -> None:
        print(f"[3RD] {message}")

# 无法通过 ABC 检查（除非 register）
print(isinstance(ThirdPartyLogger(), LoggerABC))    # False

# 自动通过 Protocol 检查
print(isinstance(ThirdPartyLogger(), LoggerProto))   # True

ABC vs Protocol 选型指南：

特性	ABC	Protocol
子类型方式	名义（需要继承）	结构化（鸭子类型）
运行时检查	`isinstance` 默认支持	需要 `@runtime_checkable`
第三方类兼容	需要 `register`	自动兼容
默认实现	支持（非抽象方法）	不支持
强制实现检查	实例化时检查	仅静态检查器（mypy）
适用场景	框架内的接口定义	跨库的类型约束

经验法则：

如果你控制所有实现类（框架内部），用 ABC -- 更严格，防止忘记实现方法
如果需要兼容第三方类或不想强制继承，用 Protocol -- 更灵活，更 Pythonic
如果需要提供默认实现（模板方法模式），只能用 ABC

七、面试高频题汇总

Q1：Python 中一切皆对象，那类本身是什么？

A：类本身也是对象，它是元类的实例。默认元类是 type，所以 type(int) is type、type(str) is type。type 自身的类型也是 type（自引用），而 type 的基类是 object。这构成了 Python 对象模型的两个根：type 是所有类的类型根，object 是所有类的继承根。这个循环引用在 CPython 启动时通过 C 代码直接建立。

Q2：元类的典型应用场景有哪些？

A：元类的核心价值是在类创建时自动执行逻辑，典型场景包括：

ORM 框架 ：Django 的 ModelBase 元类自动收集 Field 属性，建立模型到数据库表的映射
单例模式 ：覆写元类的 __call__ 方法拦截实例创建
API/插件注册：子类创建时自动注册到全局注册表
接口约束 ：abc.ABCMeta 强制子类实现抽象方法
验证类定义：检查类属性是否符合框架要求（如必须有某些字段或方法）

但在实际开发中，大多数"元类能做的事"都可以用 __init_subclass__ 或类装饰器更简单地实现。真正需要元类的场景主要是 __prepare__（自定义命名空间）和 __call__（拦截实例化）。

Q3：`__init_subclass__` 和元类的区别？

A：__init_subclass__ 是 Python 3.6 引入的钩子方法，在子类被创建时自动调用。它和元类的核心区别在于：

能力范围 ：__init_subclass__ 在类创建之后被调用，只能做后处理；元类可以控制类创建的整个过程 ，包括自定义命名空间（__prepare__）
可组合性 ：__init_subclass__ 在多继承时可以通过 super() 链式调用，不会冲突；元类在多继承时容易出现元类冲突（TypeError）
使用复杂度 ：__init_subclass__ 只是一个普通的类方法，理解和使用门槛低；元类需要理解 type、__new__、__init__、__prepare__ 等概念

建议：如果 __init_subclass__ 能满足需求，就不要用元类。

Q4：如何用元类实现单例模式？

A：覆写元类的 __call__ 方法。当你写 MyClass() 时，实际调用的是 type(MyClass).__call__(MyClass)，即元类的 __call__。在 __call__ 中检查是否已经有实例，有则返回已有实例：

python 复制代码

class SingletonMeta(type):
    _instances = {}
    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super().__call__(*args, **kwargs)
        return cls._instances[cls]

这比在 __new__ 中实现单例更可靠，因为 __call__ 同时控制了 __new__ 和 __init__ 的调用。

Q5：ABC 和 Protocol 有什么区别？各自适用什么场景？

A：ABC 是名义子类型 ，需要显式继承，在实例化时检查是否实现了所有抽象方法，并且支持提供默认实现。Protocol 是结构化子类型（Python 3.8+），不需要继承，只要对象的结构匹配就被认为是该类型。

用 ABC 的场景：框架内部的接口定义，需要强制实现检查和默认方法
用 Protocol 的场景：需要兼容第三方类，不想强制继承关系，更符合"鸭子类型"的 Python 风格

Protocol 的 @runtime_checkable 装饰器可以启用 isinstance 检查，但需要注意它只检查方法/属性的存在性，不检查签名。

本章总结

本文从类的创建过程出发，系统性地讲解了 Python 对象模型最深层的机制：

类的创建过程 ：type 是所有类的默认元类，class 语句的执行经历了确定元类、__prepare__ 准备命名空间、执行类体、调用元类创建类对象四个步骤。理解这个过程是掌握元类的前提。
元类（Metaclass） ：通过继承 type 并覆写 __new__/__init__/__call__ 来控制类的创建和实例化。典型应用包括单例模式（覆写 __call__）、自动注册（覆写 __new__）、ORM 字段收集等。元类有传播性 -- 子类自动继承父类的元类。
__init_subclass__：Python 3.6 引入的轻量替代方案，在子类创建时自动调用。比元类简单得多，且不会产生元类冲突。对于"注册"和"校验"类的需求，应优先使用。
类装饰器 vs 元类 ：类装饰器适合"为类添加功能"的场景（添加方法、包装类），语法简洁、显式标记。元类适合"控制类创建过程"的场景。在三种方案中，推荐顺序是：__init_subclass__ > 类装饰器 > 元类。
ABC 与 Protocol ：abc.ABCMeta 通过名义子类型强制接口约束，适合框架内部；typing.Protocol 通过结构化子类型实现鸭子类型的静态检查，适合跨库兼容。两者互补而非替代。

核心原则 ：元类是 Python 最强大的元编程工具，但也是最容易被滥用的。Tim Peters 在 PEP 3115 中写道："Metaclasses are deeper magic than 99% of users should ever worry about." 日常开发中，__init_subclass__ 和类装饰器能解决绝大部分需求。只有在真正需要控制类创建过程时，才考虑元类。

下一篇预告

第 08 篇：上下文管理器与类型系统 -- 资源管理与代码健壮性

下一篇文章将聚焦 Python 的资源管理与类型系统。你将了解：

上下文管理器协议 ：with 语句的完整执行流程，__enter__ 和 __exit__ 的异常处理语义
contextlib 工具箱 ：@contextmanager、suppress、ExitStack、asynccontextmanager
实战上下文管理器：数据库连接池、临时文件、计时器、分布式锁的上下文管理
Python 类型系统 ：TypeVar、Generic、Protocol、TypeGuard、ParamSpec 等高级类型标注
mypy 静态检查：配置方法、渐进式类型标注策略

从资源管理到类型安全，这两个主题将帮助你写出更健壮、更易维护的 Python 代码。

Python 后端开发技术博客专栏 | 作者：耿雨飞

本文为专栏第 07 篇，共 25 篇。完整目录请参阅《Python技术博客专栏大纲》。

Python 后端开发技术博客专栏 | 第 07 篇 元类与类的创建过程 -- Python 最深层的魔法

导读

学习目标

一、类的创建过程

1.1 type 的双重身份

1.2 class 语句的执行过程

1.3 __prepare__：自定义类的命名空间

二、元类（Metaclass）

2.1 自定义元类

2.2 metaclass= 的传播规则

2.3 元类典型应用：单例模式

2.4 元类典型应用：API 路由注册

2.5 元类典型应用：字段收集（ORM 模式）

三、__init_subclass__ -- 元类的轻量替代

3.1 基本用法

3.2 __init_subclass__ 的高级用法

3.3 __init_subclass__ vs 元类

四、类装饰器 vs 元类

4.1 类装饰器的实现模式

4.2 类装饰器 vs 元类 vs __init_subclass__ 选型

五、abc.ABCMeta 与抽象基类

5.1 抽象基类（ABC）

5.2 抽象属性

5.3 虚拟子类注册（register）

六、Protocol 与结构化子类型

6.1 从名义子类型到结构化子类型

6.2 Protocol vs ABC 选型

七、面试高频题汇总

Q1：Python 中一切皆对象，那类本身是什么？

Q2：元类的典型应用场景有哪些？

Q3：__init_subclass__ 和元类的区别？

Q4：如何用元类实现单例模式？

Q5：ABC 和 Protocol 有什么区别？各自适用什么场景？

本章总结

下一篇预告

Python 后端开发技术博客专栏 | 第 07 篇元类与类的创建过程 -- Python 最深层的魔法

1.3 `prepare`：自定义类的命名空间

三、`__init_subclass__` -- 元类的轻量替代

3.2 `__init_subclass__` 的高级用法

3.3 `__init_subclass__` vs 元类

4.2 类装饰器 vs 元类 vs `__init_subclass__` 选型

五、`abc.ABCMeta` 与抽象基类

Q3：`__init_subclass__` 和元类的区别？