一天一个冷知识:listint 不是类,为什么能当基类?
摘要 :isinstance(list[int], type) 是 False,但 class Repo(list[int]) 完全合法。CPython 在创建类之前,会把带 __mro_entries__ 的非类型基类交给这个钩子换掉;没有钩子的非类型基类会保留到类创建阶段再报错。这是 PEP 560 留下的钩子,平时几乎不会直接写,但所有 class C(List[int]) 的代码都在用它。本文拆开这条链路,并给出四个能让人调半天的边界。
验证环境:CPython 3.12.3。文中输出均为实际运行结果,版本相关的结论会单独标注。
一、先把现象拆成两个问题
python
python
import types
print(isinstance(list[int], type)) # False
print(type(list[int])) # <class 'types.GenericAlias'>
print(list[int].__origin__) # <class 'list'>
print(list[int].__args__) # (<class 'int'>,)
list[int] 是一个 types.GenericAlias 对象,不是类。它更像"带参数的类引用":origin 是 list,args 是 (int,)。
但下面这段是合法的:
python
objectivec
class Repo(list[int]):
pass
print(Repo.__bases__) # (<class 'list'>,)
print(Repo.__mro__) # (<class '__main__.Repo'>, <class 'list'>, <class 'object'>)
print(Repo.__orig_bases__) # (list[int],)
Repo 真正继承的是 list,参数 int 没有进入 MRO;同时 Repo.__orig_bases__ 保留了用户写的原始基类。
于是有两个问题:
- 谁把
list[int]换成了list? - 为什么还要留一份
__orig_bases__?
答案都在 __mro_entries__。这个钩子由 PEP 560 引入(Python 3.7 起),标准库的 typing 就是它的主要用户。
二、谁在替换基类
CPython 在创建类之前会先解析基类列表,规则由 PEP 560 定义;标准库在 Python 层提供了等价实现 types.resolve_bases(),可以直接调用观察。需要说明的是,class 语句在 CPython 内部走的是 C 层实现,并不调用这个 Python 函数;两者在正常路径上的规则一致:
python
python
import types
class Base: pass
class Obj:
def __mro_entries__(self, bases):
print("hook 收到:", [type(b).__name__ for b in bases])
return (Base,)
print(types.resolve_bases((Obj(),)))
输出:
text
arduino
hook 收到: ['Obj'] (<class '__main__.Base'>,)
规则可以概括成三条:
- 基类本身是类型 → 原样保留,不调用钩子。类已经是类型,MRO 直接可用,不需要降级。
- 基类不是类型 → 查它的
__mro_entries__;有就调用,把返回值拼回基类元组;没有就原样保留,后面在类创建阶段报错。 - 返回值是一个元组,可以包含 0 个、1 个或多个类,按位置替换原来的基类。
反过来的情形要区分"类本身作为基类"和"类的实例作为基类":如果基类本身是一个类(type),即使这个类定义了 __mro_entries__,钩子也不会被调用------类型在第一道检查里就被跳过了;只有非类型对象(通常是实例)才会触发它。下面 HasHook 是作为类基类使用的,所以钩子没有执行:
python
kotlin
class Base: pass
class HasHook:
@classmethod
def __mro_entries__(cls, bases):
return (Base,)
class J(HasHook):
pass
print(J.__bases__) # (<class '__main__.HasHook'>,)
如果把它换成实例,钩子就会执行:
python
kotlin
class J2(HasHook()):
pass
print(J2.__bases__) # (<class '__main__.Base'>,)
在 class 语句里,__mro_entries__ 收到的是原始的 bases 元组,也就是用户写在括号里的那一串,包括其他基类,而不是"去掉自己之后"的列表。多个非类型基类时,每个钩子都能看到完整的原始元组,并且替换按位置进行:
python
python
class A: pass
class B: pass
class Provider:
def __init__(self, cls):
self.cls = cls
def __mro_entries__(self, bases):
names = [b.__name__ if isinstance(b, type) else type(b).__name__ for b in bases]
print("hook 看到:", names)
return (self.cls,)
class K(A, Provider(B)):
pass
print(K.__bases__)
输出:
text
arduino
hook 看到: ['A', 'Provider'] (<class '__main__.A'>, <class '__main__.B'>)
解析完成之后,元类才从解析后的基类里推导出来:
python
python
class Meta(type): pass
class WithMeta(metaclass=Meta): pass
class Provider:
def __mro_entries__(self, bases):
return (WithMeta,)
class D(Provider()):
pass
print(type(D) is Meta) # True
也就是说,__mro_entries__ 可以影响新类用哪个元类------它返回的类会参与"最派生元类"的计算。最终元类由显式 metaclass= 和解析后的各基类的元类共同决定,取其中最派生的那个(冲突则报错);只有当钩子返回的类提供最派生候选时,它才实际决定了元类。这一步发生在 type.__new__ 之前,所以在钩子内部拿不到正在创建的那个类。
三、最小实现
python
kotlin
class Base: pass
class Obj:
def __mro_entries__(self, bases):
return (Base,)
class C(Obj()):
pass
print(C.__bases__) # (<class '__main__.Base'>,)
print(C.__mro__) # (<class '__main__.C'>, <class '__main__.Base'>, <class 'object'>)
print(C.__orig_bases__[0].__class__.__name__) # Obj
Obj() 不是类,但作为基类合法;C 的实际父类是 Base。__orig_bases__ 保存的是原始对象,不是替换后的 Base。在普通 class 语句里,它由类创建过程在发生替换的类上设置;class Plain: pass 自身没有这个属性。但它是普通类属性,会被子类继承,也可能被框架手动设置(例如 typing.NamedTuple / TypedDict);所以不能把"有 __orig_bases__"当成"发生过替换"的可靠标志。要判断某个类"自己"是否设置过,应检查 "__orig_bases__" in cls.__dict__,而不是只看 hasattr。
python
vbscript
class Sub(Repo):
pass
print("__orig_bases__" in Sub.__dict__) # False
print(Sub.__orig_bases__) # (list[int],),继承自 Repo
这也是"为什么还要留一份"的答案:框架需要回读用户写下的参数化信息,而 MRO 只认真实类。
这正是 list[int] 的套路。这样设计的原因很直接:MRO 是一张由真实类构成的线性化序列(CPython 用 C3 算法),list[int] 这种带参数的对象没法参与线性化;把参数留在 __orig_bases__,MRO 只处理真实类,两边各取所需。可以自己写一个简化版:
python
ruby
class Typed:
def __init__(self, origin):
self.origin = origin
def __mro_entries__(self, bases):
return (self.origin,)
def __repr__(self):
return f"Typed({self.origin.__name__})"
class BaseRepo(dict):
pass
class UserRepo(Typed(BaseRepo)):
pass
print(UserRepo.__bases__) # (<class '__main__.BaseRepo'>,)
print(UserRepo.__orig_bases__) # (Typed(BaseRepo),)
Typed(BaseRepo) 充当"参数化基类",UserRepo 真正继承 BaseRepo,而 __orig_bases__ 里留着 Typed(BaseRepo),方便框架回读参数。
标准库自己也在用这个钩子:
python
python
import typing
print(typing.List[int].__mro_entries__((typing.List[int],)))
# (<class 'list'>, <class 'typing.Generic'>)
print(dict[str, int].__mro_entries__((dict[str, int],)))
# (<class 'dict'>,)
同样是"类 + 参数",typing.List[int] 会额外把 typing.Generic 加进基类,而内置的 dict[str, int] 只返回 dict。所以 class C(List[int]) 和 class C(dict[str, int]) 的 MRO 并不对称:前者多一个 typing.Generic。
四、四个坑
1. 返回值必须是 tuple
python
kotlin
class Base: pass
class Bad:
def __mro_entries__(self, bases):
return [Base]
try:
class E(Bad()):
pass
except TypeError as e:
print(e) # __mro_entries__ must return a tuple
列表、生成器都不行,必须是元组(tuple 或其子类)。这个检查发生在解析阶段,报错信息还算直接。
2. 元素不是类时,错误会延迟且极具误导性
python
python
class BadItem:
def __mro_entries__(self, bases):
return (42,)
try:
class H(BadItem()):
pass
except TypeError as e:
print(e) # int() takes at most 2 arguments (3 given)
错误信息里完全看不到 __mro_entries__。原因是解析结果直接进入元类推导:type(42) 是 int,最终相当于把 int 当成元类去调用,于是报了一个"int 参数太多"的错。排查时很容易往元类方向找,而真正的问题在钩子的返回值。
3. 空元组会删掉基类,重复基类会被拒绝
python
kotlin
class Empty:
def __mro_entries__(self, bases):
return ()
class F(Empty()):
pass
print(F.__bases__) # (<class 'object'>,)
返回空元组等于"这个基类不存在"。如果所有基类都被解析成空,类会退化成只继承 object,MRO 静默改变。
另一个方向是重复:
python
kotlin
class Base: pass
class Dup:
def __mro_entries__(self, bases):
return (Base,)
try:
class G(Base, Dup()):
pass
except TypeError as e:
print(e) # duplicate base class Base
替换后出现两个相同的基类,type.__new__ 会直接拒绝。
4. 实例属性可以劫持基类解析
python
kotlin
class Base: pass
class Obj:
def __mro_entries__(self, bases):
return (Base,)
obj = Obj()
obj.__mro_entries__ = lambda bases: (ValueError,)
class I(obj):
pass
print(I.__bases__) # (<class 'ValueError'>,)
__mro_entries__ 走的是普通属性查找;对这里的方法属性,实例字典会覆盖类上的定义。也就是说,一个看起来"只是数据"的对象,只要实例上挂了一个同名属性,就能改掉最终继承的类。如果基类列表来自外部输入,这一点值得警惕。
五、和 __class_getitem__ 的分工
这两个钩子经常被混在一起,但分工要看具体对象:
- 对普通类,
C[int]通常由类级下标产生:list[int]走的是type.__class_getitem__,返回types.GenericAlias;dict[str, int]同理。 typing.List本身不是类,而是一个 typing 别名对象;typing.List[int]走的是它的__getitem__,返回typing._GenericAlias。- 两条路径都产出别名对象,再由别名对象的
__mro_entries__在class语句里降级成真实基类。
list[int] 能生成,是因为 list 支持类级下标;能当基类,是因为 types.GenericAlias 实现了 __mro_entries__。缺任何一个,class Repo(list[int]) 都不成立。
平时写业务代码基本不用直接实现 __mro_entries__;但读 typing、写泛型容器,或者遇到"基类看起来不是类"的框架代码时,知道有这么一个钩子,能省掉很多猜测。