冷门Python知识点007篇:list[int]不是类,为什么能当基类?

一天一个冷知识: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__ 保留了用户写的原始基类。

于是有两个问题:

  1. 谁把 list[int] 换成了 list?
  2. 为什么还要留一份 __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'>,)

规则可以概括成三条:

  1. 基类本身是类型 → 原样保留,不调用钩子。类已经是类型,MRO 直接可用,不需要降级。
  2. 基类不是类型 → 查它的 __mro_entries__;有就调用,把返回值拼回基类元组;没有就原样保留,后面在类创建阶段报错。
  3. 返回值是一个元组,可以包含 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、写泛型容器,或者遇到"基类看起来不是类"的框架代码时,知道有这么一个钩子,能省掉很多猜测。

相关推荐
用户6152183299611 分钟前
为什么 String 是不可变的?看懂字符串常量池和底层实现
后端
Dmz丶14 分钟前
前端转 AI 100 天 Day 49:文档切分——RAG 效果的隐形开关
python
brilliance25 分钟前
HashMap 底层原理详解,从数组、链表到红黑树
后端
未秃头的程序猿1 小时前
RedisTemplate 序列化用错,线上多了 3 个 G 的隐形 key
redis·后端
掘金者阿豪1 小时前
MySQL兼容性实践:从SQL语法适配到业务系统平滑迁移
后端
青少儿编程课堂1 小时前
第十八届蓝桥杯青少组图形化真题 + 全国青少年信息素养大赛 + 电子学会图形化考级:校园泡泡堂大挑战解析
c++·python·算法·bfs·信息学竞赛
超低空2 小时前
一文说清LRU算法
后端·算法·架构
前端小万2 小时前
思考,行动,复盘|2026
前端·后端·面试
Starry-sky(jing)2 小时前
Hermes Agent 升级 v0.23.2:先辨更新渠道,再看 CLI 退出残留修复
人工智能·python·ai agent