罗罗编程学习记录
本页内容 展开查看

04.7.3 面向对象、元类与描述符

所属:全栈开发面试题库 / 04 后端语言与运行时 / 04.7 Python

覆盖范围

  • 构造与初始化:__new__、__init__、__del__
  • 类属性、实例属性、方法绑定、super() 与 MRO
  • 属性协议:property、描述符、__getattr__
  • __slots__、dataclass、Enum、抽象基类
  • 元类、动态建类、单例与注册模式
  • 运算符重载、比较与哈希契约

04.7.3-001 __new__ 和 __init__ 有什么区别?

一句话结论

__new__ 是构造器,负责创建并返回实例(静态方法,第一个参数是 cls);__init__ 是初始化器,在实例已创建后填充状态,返回 None。__init__ 只有在 __new__ 返回本类实例时才会被调用。

概念解释

  • 不可变类型(int、str、tuple)必须重写 __new__,因为值在创建时确定,__init__ 改不了。
  • 单例、对象池、缓存复用通常在 __new__ 里控制是否新建。

原理流程

  1. Cls(...) 先进入 type.__call__。
  2. 调用 Cls.__new__(Cls, ...) 创建实例;若返回 Cls 实例,再调用 obj.__init__(...)。
  3. __init__ 返回非 None 会 TypeError,这是硬约束;__new__ 返回其他类实例时,__init__ 不会被调用。

代码或图示

class Singleton:
    _inst = None
    def __new__(cls, *a, **kw):
        if cls._inst is None:
            cls._inst = super().__new__(cls)
        return cls._inst
    def __init__(self, value=0):
        self.value = value      # 每次调用都会重新初始化

常见误区

  • 以为 __new__ 复用实例后 __init__ 不会再跑:__new__ 返回本类实例时,type.__call__ 仍会调用 __init__。
  • 自定义 __new__ 不调用 super().__new__(cls):创建普通实例必须调用,否则拿不到初始化好的对象。

追问

  • 为什么单例用 __new__ 后 __init__ 还会重复执行?答:__new__ 返回了本类实例,type.__call__ 仍会调用 __init__。
  • 自定义 __new__ 必须调用 super().__new__(cls) 吗?答:创建普通实例必须,否则拿不到初始化好的对象。
  • 工厂方法和 __new__ 哪个更好?答:工厂更显式、易测试;__new__ 适合“必须保证唯一/复用”的语义。

04.7.3-002 类属性和实例属性有什么区别?查找顺序如何?

一句话结论

类属性存在类的 __dict__(由元类管理),所有实例共享;实例属性存在实例的 __dict__。读取时先找实例 __dict__,再按 MRO 找类,最后找元类;写入 obj.x = v 默认写实例,类属性需 Cls.x = v。

概念解释

  • 实例读取类属性时拿到的是同一个对象引用,不是副本。
  • __slots__ 类没有 __dict__,只能写声明过的槽位。

原理流程

  1. 读取属性先查实例 __dict__,未命中再沿 MRO 查类与元类。
  2. 普通赋值 obj.x = v 写入实例 __dict__,不回写类。
  3. 描述符(property、函数)在类上会参与属性协议,实例 __dict__ 优先级更高(数据描述符除外)。

代码或图示

class A:
    tags = []           # 共享
    def __init__(self):
        self.name = "a" # 每实例独立

a, b = A(), A()
a.tags.append("x")
print(b.tags)           # ['x'],被共享污染

常见误区

  • 可变类属性(list/dict)被所有实例共享,任何实例修改都会影响全部,是经典坑。
  • 删除实例属性用 del obj.x,会回落到类属性(若存在);描述符放在实例 __dict__ 里不会触发协议。

追问

  • 为什么 self.tags = [] 写在 __init__ 里更安全?答:每个实例创建时得到独立列表。
  • 如何区分“读取的是类属性还是实例属性”?答:obj.__dict__ 与 type(obj).__dict__ 分别查看。
  • 类属性可以是描述符吗?答:可以,property/函数/自定义描述符都放在类上才能生效。

04.7.3-003 多继承的方法解析顺序(MRO)是怎样的?

一句话结论

Python 3 用 C3 线性化算法生成 MRO:保证每个类只出现一次、父类排在其所有子类之后、多个父类按声明顺序保持局部优先级。Cls.mro() 可查看,菱形继承时共同基类只出现一次且排在最后。

概念解释

  • 多继承用于 Mixin 组合能力,不用于表达“是一个”的关系。
  • 父类顺序改变会改变 MRO,从而改变同名方法谁生效。

原理流程

  1. C3 合并各父类的 MRO 与父类列表,冲突时报 TypeError: Cannot create a consistent MRO。
  2. 菱形继承 D(B, C) 的 MRO 通常为 D → B → C → A → object,A 只出现一次。
  3. 属性查找与方法解析都沿 MRO 顺序进行。

代码或图示

class A: pass
class B(A): pass
class C(A): pass
class D(B, C): pass

print([c.__name__ for c in D.mro()])   # D B C A object

常见误区

  • 以为 MRO 是深度优先简单遍历:C3 要保证父类在子类之后且共同基类只出现一次。
  • Mixin 左右位置随意:顺序决定覆盖关系,需按覆盖意图安排。

追问

  • 为什么 C3 要保证“父类在子类之后”?答:否则可能调用到被子类覆盖的方法,破坏继承语义。
  • MRO 冲突如何排查?答:打印各父类 mro(),看是否出现顺序矛盾(A 在 B 前又 B 在 A 前)。
  • Mixin 应该放左边还是右边?答:通常放右侧(低优先级),让主类实现优先;顺序取决于覆盖意图。

04.7.3-004 super() 到底做了什么?

一句话结论

super() 返回一个代理对象,按“当前类的 MRO 中下一个类”查找属性,而不是简单地“调用父类”。零参形式 super() 依赖编译器注入的 __class__ cell 与第一个参数,因此只能在方法内使用。

概念解释

  • super() 也用于访问父类的类属性/描述符。
  • 在 Mixin 协作继承中,每个类都调用 super() 形成链,任意一环不调用就会断链。

原理流程

  1. super() 绑定当前类与实例,按实例 MRO 定位当前类的下一个类。
  2. super().method() 沿 MRO 继续向后找,多继承下走到“下一个”父类,而不是直接父类。
  3. 零参 super() 在嵌套函数/生成器里可能失效,需显式 super(Cls, self)。

代码或图示

class Base:
    def __init__(self):
        print("base")

class Mid(Base):
    def __init__(self):
        print("mid")
        super().__init__()

class Leaf(Mid):
    def __init__(self):
        print("leaf")
        super().__init__()

常见误区

  • 不要用 super().__init__() 之后再手动调用另一个父类,容易重复初始化。
  • super(Cls, obj) 要求 obj 必须是 Cls 或其子类实例,否则 TypeError;不能直接拿改名后的 __x 私有属性。

追问

  • super() 能拿到父类的私有属性吗?答:不能直接拿 __x(已被改名),需知道改名后的 _Cls__x。
  • 为什么多继承必须层层 super()?答:它是协作式链式调用,断链会导致某些父类初始化被跳过。
  • super(Cls, obj) 的 Cls 有什么要求?答:obj 必须是 Cls 或其子类实例,否则 TypeError。

04.7.3-005 私有属性真的私有吗?名字改写(name mangling)是怎么回事?

一句话结论

Python 没有真正的私有。__x(双下划线前缀、至多一个后缀下划线)会被改写成 _ClassName__x,目的是避免子类意外覆盖,不是访问控制。_x(单下划线)只是约定“内部使用”,__x__(双前后缀)是魔法方法,不改名。

概念解释

  • 单下划线在 from module import * 时不会被导出(除非 __all__ 包含)。
  • 真正的封装靠约定 + 属性(property)+ 文档,而不是双下划线。

原理流程

  1. 改名发生在编译期,按定义它的类名把 __x 改写为 _ClassName__x。
  2. 子类中同名属性变成 _Sub__x,与父类互不干扰。
  3. 仍可通过 obj._Cls__x 访问,只是“不鼓励”。

代码或图示

class A:
    def __init__(self):
        self.__secret = 1

print(A()._A__secret)      # 1
print([k for k in A().__dict__])   # ['_A__secret']

常见误区

  • 以为双下划线是访问控制:反射/序列化库(pickle、dataclass、ORM)常受改名影响,需要特殊处理。
  • 混淆三种下划线:_x 是约定,__x 是改名,__x__ 是魔法方法。

追问

  • 为什么子类定义 __secret 不会覆盖父类?答:改名后名字不同(_A__secret vs _B__secret)。
  • 双下划线会影响 property 吗?答:会,property 名同样被改写,外部访问要用改写后的名字。
  • 什么时候该用单下划线?答:表达“内部实现细节”,团队约定即可,不必强制。

04.7.3-006 property 的原理是什么?什么时候用?

一句话结论

property 是把“属性访问”转成方法调用的数据描述符:实现了 __get__/__set__/__delete__,因此能拦截 obj.x、obj.x = v、del obj.x。适合做校验、懒加载、计算属性、兼容旧字段。

概念解释

  • @property 定义 getter,@x.setter/@x.deleter 追加写/删。
  • 与 cached_property 区别:后者首次计算后缓存进实例 __dict__。

原理流程

  1. property 作为类上的数据描述符,属性协议优先调用其 __get__/__set__。
  2. 数据描述符优先于实例 __dict__,所以 property 能覆盖实例属性。
  3. 访问属性时 getter 被调用,赋值时 setter 被调用。

代码或图示

class User:
    def __init__(self, age):
        self._age = age

    @property
    def age(self):
        return self._age

    @age.setter
    def age(self, v):
        if not 0 <= v <= 150:
            raise ValueError("invalid age")
        self._age = v

常见误区

  • 只读属性不要只靠“不给 setter”,因为实例 __dict__ 仍可被直接写入(除非配合 __slots__)。
  • property 内不要做重计算或 IO,调用方会以为是廉价属性访问;每次访问一次 Python 调用,热路径需评估。

追问

  • property 为什么能拦截赋值?答:它是数据描述符,属性协议优先调用 __set__。
  • cached_property 怎么实现的?答:非数据描述符,首次 __get__ 把结果写进实例 __dict__,之后直接命中实例字典。
  • property 会影响性能吗?答:每次访问一次 Python 调用,热路径上大量访问需评估。

04.7.3-007 描述符协议是什么?ORM 字段为什么要用它?

一句话结论

描述符是定义了 __get__、__set__、__delete__ 之一的类属性对象。访问 obj.attr 时,若类属性是描述符,则由它接管读写:数据描述符(含 __set__)优先于实例字典,非数据描述符次之。ORM 用它在类层面声明字段,把 User.name = "x" 转成“记录字段变更”,而不污染实例。

概念解释

  • 描述符必须定义在类上,放在实例 __dict__ 里不会触发协议。
  • 描述符实例是类级共享的,状态必须存在实例或通过 obj 参数区分。

原理流程

  1. __set_name__(self, owner, name) 在类创建时由 type.__new__ 调用一次,记录字段名。
  2. 访问时 __get__(self, obj, objtype) 被调用,obj 为 None 表示通过类访问。
  3. 赋值时 __set__(self, obj, value) 接管写入,可做校验、变更记录。

代码或图示

class Field:
    def __set_name__(self, owner, name):
        self.name = "_" + name
    def __get__(self, obj, objtype=None):
        if obj is None: return self
        return getattr(obj, self.name, None)
    def __set__(self, obj, value):
        obj.__dict__[self.name] = value

class User:
    name = Field()

常见误区

  • 把描述符放进实例字典:属性协议只在类型查找阶段识别描述符,实例字典里的对象按普通值返回。
  • 在类级描述符实例上保存实例状态:多实例共享同一描述符,状态会互相覆盖。

追问

  • 为什么描述符放实例里不生效?答:属性协议只在类型查找阶段识别描述符,实例字典里的对象按普通值返回。
  • __set_name__ 什么时候调用?答:类创建时,由 type.__new__ 对所有类属性调用一次。
  • 描述符能实现懒加载吗?答:能,__get__ 里判断缓存缺失再计算并写回实例字典。

04.7.3-008 __slots__ 有什么用?有什么限制?

一句话结论

__slots__ 声明固定属性名,类不再为每个实例创建 __dict__,每个属性存为固定槽位,显著减少内存(约省 40%~50%)并略微加快属性访问。代价是不能动态加属性、不能与 __dict__ 混用、多继承有限制、__slots__ 不继承需逐类声明。

概念解释

  • 适合“大量小对象”(百万级节点、点坐标、事件对象),不适合需要动态属性的对象。
  • 槽位名不能与类属性/方法同名,会被覆盖。

原理流程

  1. 类创建时按 __slots__ 声明为每个槽位生成描述符。
  2. 实例不再分配 __dict__,属性直接存入固定槽位。
  3. 未声明的属性赋值触发 AttributeError;子类不声明 __slots__ 会重新获得 __dict__,优化失效。

代码或图示

class Point:
    __slots__ = ("x", "y")
    def __init__(self, x, y):
        self.x, self.y = x, y

p = Point(1, 2)
# p.z = 3   # AttributeError

常见误区

  • 子类忘记声明 slots:父类的内存优化在子类上失效。
  • 与 weakref 共用时需把 "__weakref__" 加进 slots;两个都有 slots 的类不能同时继承(槽位布局冲突)。

追问

  • __slots__ 为什么省内存?答:省掉每实例的 __dict__(哈希表)开销,只留固定指针数组。
  • 用了 __slots__ 还能做多继承吗?答:两个都有 slots 的类不能同时继承(槽位布局冲突)。
  • dataclass 怎么开 slots?答:@dataclass(slots=True)(3.10+)自动生成新类并声明槽位。

04.7.3-009 实例方法、类方法、静态方法有什么区别?

一句话结论

实例方法第一个参数是 self,通过实例调用时自动绑定;@classmethod 第一个参数是 cls,可被类或实例调用,常用于工厂方法;@staticmethod 不接收隐式参数,就是挂在类命名空间里的普通函数。

概念解释

  • @staticmethod 语义上属于类但不需要类状态,用于组织代码或工具函数。
  • 类方法不能访问实例属性;实例方法能访问类属性。

原理流程

  1. 实例方法经函数描述符把实例绑定为第一个参数。
  2. 类方法经 classmethod 描述符把类绑定为第一个参数,子类调用时 cls 是子类。
  3. 静态方法不绑定任何隐式参数,调用时原样转发。

代码或图示

class User:
    def __init__(self, name): self.name = name

    @classmethod
    def from_dict(cls, d):
        return cls(d["name"])

    @staticmethod
    def is_valid(name):
        return bool(name)

常见误区

  • 工厂方法误用 staticmethod:无法保证子类返回正确类型,需要 cls 感知。
  • 装饰顺序错误:@classmethod 应放在最外层。

追问

  • 为什么工厂方法用 classmethod 而不是 staticmethod?答:需要 cls 保证子类返回正确类型。
  • 静态方法什么时候必要?答:逻辑上属于该类、但不需要类/实例状态时;也可直接放模块函数。
  • 能被实例调用吗?答:都能,obj.cls_method() 的 cls 仍是类,obj.static() 不传隐式参数。

04.7.3-010 元类(metaclass)是什么?什么时候真的需要?

一句话结论

元类是“创建类的类”,默认是 type。class C(metaclass=M) 表示 C = M("C", bases, namespace)。元类在类创建时介入,可修改命名空间、校验字段、自动注册、生成代理方法。绝大多数业务不需要元类,用 __init_subclass__ 或类装饰器就够。

概念解释

  • ORM、ABC、Enum、dataclass 都在元类层做工作。
  • 元类让代码难懂、难调试,优先考虑更简单的替代方案。

原理流程

  1. 解析类体并执行得到 namespace 字典。
  2. 调用元类(默认 type.__new__)生成类对象,再调用元类 __init__。
  3. 元类可拦截 __getattribute__、__call__,实现“类级别的行为定制”。

代码或图示

class Registry(type):
    def __new__(mcls, name, bases, ns):
        cls = super().__new__(mcls, name, bases, ns)
        if name != "Base":
            REGISTRY[name] = cls
        return cls

class Base(metaclass=Registry): pass
class User(Base): pass

常见误区

  • 元类冲突:多继承时只能有一个元类(或共同的元类子类)。
  • 能用 __init_subclass__ 或装饰器解决却上元类:增加复杂度且难调试。

追问

  • 元类和类装饰器怎么选?答:需要影响所有子类、需要拦截类创建本身用元类;一次性加工用装饰器。
  • __init_subclass__ 能替代元类吗?答:多数“注册子类/校验字段”场景可以,且更简单。
  • 元类能改实例行为吗?答:通过定义 __call__ 包装实例创建,或在命名空间里注入方法。

04.7.3-011 单例模式在 Python 里有几种实现?各有什么问题?

一句话结论

常见五种:模块级实例(最 Pythonic)、__new__ 复用、类装饰器、元类、functools.lru_cache 工厂。模块天然单例(sys.modules 缓存),优先用它;需要延迟初始化或参数化时再用类实现。

概念解释

  • 模块单例:把状态放模块级变量,导入即共享,简单且线程安全(导入锁)。
  • 多进程下单例不跨进程,需要外部协调(Redis 锁、文件锁)。

原理流程

  1. 模块在首次导入时创建一次,sys.modules 缓存后续复用。
  2. __new__ 方案在检查-创建阶段复用同一实例;装饰器/元类方案在类创建或实例化阶段约束。
  3. 工厂缓存方案用 lru_cache 按参数缓存实例。

代码或图示

class Config:
    _instance = None
    _ready = False
    def __new__(cls, *a, **kw):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
        return cls._instance
    def __init__(self, path="config.yml"):
        if self._ready:
            return
        self.path = path
        type(self)._ready = True

常见误区

  • __new__ 方案忘记处理 __init__ 重复执行,需加标记避免重复初始化。
  • 装饰器方案返回包装函数/代理,类型会变,isinstance 失效;并发下检查-创建不是原子操作,需加锁。

追问

  • 单例为什么在并发下仍会创建多个?答:__new__ 的检查-创建不是原子操作,需加锁或依赖模块导入锁。
  • 单例怎么测试?答:提供 reset() 或依赖注入,避免测试间状态串味。
  • 单例和全局变量有什么区别?答:单例可延迟初始化、可控访问、可替换实现;全局变量无法约束创建时机。

04.7.3-012 __getattr__ 和 __getattribute__ 有什么区别?

一句话结论

__getattribute__ 拦截所有属性访问,是属性协议的总入口;__getattr__ 只在常规查找失败(抛 AttributeError)后兜底调用。实现动态属性优先用 __getattr__,重写 __getattribute__ 风险高、易死循环。

概念解释

  • __getattr__ 适合代理对象、懒加载、兼容旧字段名、访问不存在属性时给出友好错误。
  • __setattr__/__delattr__ 是写入侧的对应入口。

原理流程

  1. 常规查找顺序:数据描述符 → 实例 __dict__ → 类/MRO → __getattr__。
  2. 全部失败后才调用 __getattr__;只实现它时,正常存在的属性不会走它。
  3. __getattribute__ 在查找开始前介入,覆盖上述全部流程。

代码或图示

class Proxy:
    def __init__(self, target): self._t = target
    def __getattr__(self, name):
        return getattr(self._t, name)     # 仅在正常查找失败时触发

常见误区

  • 在 __getattribute__ 里访问 self.x 会再次触发自身,必须用 super().__getattribute__ 或 object.__getattribute__。
  • 在 __getattr__ 里访问不存在的 self.xxx 会再次进入 __getattr__,形成死循环;重写 __getattribute__ 每次属性访问都走 Python 代码,热路径显著变慢。

追问

  • 为什么在 __getattr__ 里访问 self.xxx 可能死循环?答:若 xxx 不存在,会再次进入 __getattr__。
  • 重写 __getattribute__ 的性能代价?答:每次属性访问都走 Python 代码,热路径会显著变慢。
  • 如何实现“访问不存在属性返回默认值”?答:用 __getattr__ 返回默认值,但会掩盖真实错误,需谨慎。

04.7.3-013 为什么重写 __eq__ 必须同时考虑 __hash__?

一句话结论

Python 要求:a == b 时 hash(a) == hash(b)。默认 __hash__ 基于 id;一旦定义 __eq__,__hash__ 被置为 None(不可哈希),必须显式实现,否则对象不能进 set/dict。

概念解释

  • 不可变值对象(如坐标、金额)应同时实现二者;可变实体(如 ORM 对象)通常只实现 __eq__ 并保持不可哈希。
  • 哈希冲突只影响性能,不影响正确性(还有 __eq__ 兜底)。

原理流程

  1. 定义 __eq__ 后解释器把 __hash__ 置为 None,对象不可哈希。
  2. 显式实现 __hash__ 时,用参与相等判断的不可变字段组合哈希。
  3. 值相等必须哈希相同,否则 dict/set 会同时存两份。

代码或图示

class Money:
    __slots__ = ("amount", "currency")
    def __init__(self, amount, currency):
        self.amount, self.currency = amount, currency
    def __eq__(self, o):
        return isinstance(o, Money) and (self.amount, self.currency) == (o.amount, o.currency)
    def __hash__(self):
        return hash((self.amount, self.currency))

常见误区

  • 哈希基于可变字段:字段变化后哈希漂移,原条目找不到。
  • 哈希随便返回常量:能保证正确性但退化成链表,性能崩塌;dataclass(eq=True, frozen=False) 会把 __hash__ 设为 None,正是这个规则的体现。

追问

  • 只实现 __eq__ 会怎样?答:类变成不可哈希,放 dict/set 报 TypeError。
  • 能否让对象始终按身份比较?答:不重写 __eq__ 即可,默认行为就是身份比较且可哈希。
  • 哈希值能随便返回常量吗?答:能保证正确性但退化成链表,性能崩塌。

04.7.3-014 dataclass 解决了什么问题?和普通类、namedtuple 怎么选?

一句话结论

@dataclass 按字段声明自动生成 __init__、__repr__、__eq__,可选 order、frozen、slots,减少样板代码。与 namedtuple 相比它可变、支持默认值/类型注解/继承;与普通类相比更声明式,但不适合复杂校验逻辑。

概念解释

  • 字段顺序决定 __init__ 参数顺序;带默认值的字段必须排在无默认值之后。
  • __post_init__ 做派生计算或校验。

原理流程

  1. 装饰器在类创建后按字段声明生成 __init__、__repr__、__eq__ 等方法。
  2. frozen=True 生成不可变对象与 __hash__,可作 dict key。
  3. field(default_factory=list) 解决可变默认值问题。

代码或图示

from dataclasses import dataclass, field

@dataclass(frozen=True, slots=True)
class Order:
    id: int
    items: tuple[str, ...] = ()
    tags: list[str] = field(default_factory=list)

常见误区

  • dataclass 不做运行时类型校验,校验要靠 Pydantic 或手写。
  • frozen 只阻止属性赋值,内部可变对象仍可被修改;可变默认值会被 dataclass 拒绝(ValueError),必须用 default_factory。

追问

  • 为什么默认值要用 default_factory?答:dataclass 会拒绝可变默认值(ValueError),避免共享。
  • frozen 真的不可变吗?答:阻止属性赋值,但内部可变对象仍可被修改。
  • dataclass 和 Pydantic 怎么选?答:只需容器语义用 dataclass,需要校验/序列化/JSON Schema 用 Pydantic。

04.7.3-015 抽象基类(ABC)有什么用?

一句话结论

ABC 用 abc.ABC + @abstractmethod 声明“必须由子类实现”的方法,实例化未实现抽象方法的类会 TypeError。它提供接口契约、isinstance 虚拟子类注册、以及 collections.abc 一套基于协议的接口。

概念解释

  • 抽象方法可有默认实现,子类可覆盖;@abstractmethod 只要求“被覆盖”,不要求重写为空。
  • 与 typing.Protocol 区别:ABC 是运行时检查,Protocol 主要给静态检查器。

原理流程

  1. 继承 ABC 并用 @abstractmethod 标记必须实现的方法。
  2. 子类未覆盖全部抽象方法时,实例化触发 TypeError。
  3. register() 可把不相关类型注册为虚拟子类,影响 isinstance/issubclass。

代码或图示

from abc import ABC, abstractmethod

class Store(ABC):
    @abstractmethod
    def get(self, key): ...
    @abstractmethod
    def put(self, key, value): ...

常见误区

  • 以为 ABC 只做静态约束:它在运行时实例化阶段检查,有运行时开销(每次实例化检查),但可接受。
  • collections.abc 的 Iterable/Mapping/Sequence 是结构化协议,实现对应魔法方法即可被识别,不需要显式继承。

追问

  • 抽象方法能被实例调用吗?答:不能,未实现的子类实例化时就报错。
  • ABC 和接口有什么区别?答:Python 无原生接口,ABC 是最接近的运行时契约。
  • 抽象属性怎么写?答:@property + @abstractmethod 叠加,或用 __init_subclass__ 校验字段。

04.7.3-016 鸭子类型和 typing.Protocol 是什么关系?

一句话结论

鸭子类型是“看行为不看类型”:只要对象有需要的方法就能用。Protocol 把这种约定显式化,供 mypy 静态检查(结构化子类型),运行时不强制;@runtime_checkable 可让 isinstance 做方法存在性检查。

概念解释

  • 鸭子类型灵活但有运行时风险:少个方法到调用时才 AttributeError。
  • 与 ABC 相比,Protocol 不要求继承,适合给第三方类型加约束。

原理流程

  1. Protocol 定义方法签名与类型注解。
  2. 静态检查器验证实现类是否满足协议(结构化子类型)。
  3. runtime_checkable 的 isinstance 只检查成员是否存在,不校验签名。

代码或图示

from typing import Protocol

class Closeable(Protocol):
    def close(self) -> None: ...

def shutdown(x: Closeable) -> None:
    x.close()

常见误区

  • 以为 Protocol 运行时强制类型:默认不强制,除非 runtime_checkable 且只查成员存在。
  • 大型项目中鸭子类型约定隐含在调用点,重构时静态检查无法发现破坏;泛型 Protocol 可表达 SupportsClose、SupportsRead 这类能力接口。

追问

  • Protocol 能在运行时验证参数类型吗?答:不能(除非 runtime_checkable 且只查成员存在)。
  • 为什么鸭子类型在大型项目中危险?答:接口约定隐含在调用点,重构时静态检查无法发现破坏。
  • 泛型 Protocol 有什么好处?答:能表达“可迭代且元素类型为 T”这类结构化约束。

04.7.3-017 Mixin 是什么?多继承实践要注意什么?

一句话结论

Mixin 是只提供可复用行为、不表达“是一个”关系的类,通常无状态或少状态,通过多继承组合到主类上。实践要点:Mixin 放右侧低优先级、每个 Mixin 都调用 super() 以维护协作链、避免多个 Mixin 修改同一状态。

概念解释

  • 典型 Mixin:日志、序列化、权限校验、时间戳、软删除。
  • Mixin 不应依赖主类的具体字段名,除非明确文档化。

原理流程

  1. Mixin 只提供行为方法,不定义核心身份与主状态。
  2. 主类通过多继承把 Mixin 能力组合进来,方法解析沿 MRO 进行。
  3. 多个 Mixin 都有 __init__ 时,必须靠 super() 链逐一初始化。

代码或图示

class TimestampMixin:
    created_at: float
    def touch(self):
        self.created_at = time.time()

class Model(TimestampMixin, Base):
    ...

常见误区

  • 多个 Mixin 修改同一状态:初始化顺序难以预测,应改为组合。
  • 继承层级过深会让 MRO 难以推理,超过两三个 Mixin 应重构为组合;Mixin 方法命名冲突时用明确前缀或改为组合。

追问

  • Mixin 和组合怎么选?答:需要横向复用行为且不影响类型语义用 Mixin;否则用组合(持有对象)。
  • 为什么 Mixin 要无状态?答:多继承共享状态容易冲突,且 MRO 顺序会让初始化难以预测。
  • Mixin 方法命名冲突怎么办?答:用明确前缀或改为组合,别依赖继承顺序猜。

04.7.3-018 __init_subclass__ 有什么用?比元类简单在哪?

一句话结论

__init_subclass__ 是类方法钩子,在每个子类创建完成时被调用,可做子类注册、字段校验、自动注入属性。它不需要元类,写法简单,是“元类轻量替代方案”。

概念解释

  • 定义在父类上,签名 def __init_subclass__(cls, **kwargs),子类可通过类关键字参数传配置。
  • 适合插件注册表、ORM/序列化框架的字段收集、枚举式约束。

原理流程

  1. 子类创建完成后,由 type.__new__ 触发父类的 __init_subclass__。
  2. 钩子收到子类对象与类关键字参数,执行注册/校验/注入。
  3. 必须调用 super().__init_subclass__(**kwargs) 以维持链。

代码或图示

class Plugin:
    registry = {}
    def __init_subclass__(cls, **kw):
        super().__init_subclass__(**kw)
        Plugin.registry[cls.__name__] = cls

class A(Plugin): pass
print(Plugin.registry)      # {'A': <class 'A'>}

常见误区

  • 以为它能拦截类体执行过程:不能,也不能改变类的创建方式(那是元类的能力)。
  • 忘记调用 super().__init_subclass__,导致协作链断裂。

追问

  • 它和元类 __new__ 的区别?答:前者在类创建后回调,后者直接参与创建过程并可修改命名空间。
  • 能给子类传参数吗?答:能,class Child(Parent, key="v") 会传给 __init_subclass__。
  • 为什么注册表放父类而不是模块全局?答:便于测试清理与多实例隔离。

04.7.3-019 上下文管理器协议是什么?__exit__ 返回 True 会怎样?

一句话结论

with obj as x: 进入时调用 __enter__(返回值绑定给 as),退出时调用 __exit__(exc_type, exc, tb)。若 __exit__ 返回 True,异常被吞掉;返回 False/None 则异常继续传播。文件、锁、事务、临时目录都靠它保证释放。

概念解释

  • __exit__ 的三个参数在无异常时都是 None。
  • 异步版本是 __aenter__/__aexit__ + async with。

原理流程

  1. 进入 with 块时调用 __enter__,其返回值绑定给 as 目标。
  2. 块内代码执行,正常或异常退出都调用 __exit__。
  3. __exit__ 返回 True 抑制异常,返回 False/None 让异常继续传播。

代码或图示

from contextlib import contextmanager

@contextmanager
def tx(conn):
    try:
        yield conn
        conn.commit()
    except Exception:
        conn.rollback()
        raise

常见误区

  • 吞异常应极其谨慎,通常只在“异常已处理并记录”时返回 True;否则会掩盖故障。
  • contextlib.contextmanager 用生成器写:yield 前是进入,yield 后是退出,异常在 yield 处抛出;不确定数量的资源用 contextlib.ExitStack 动态管理。

追问

  • __exit__ 返回 True 会让调用方以为什么都没发生?答:异常被抑制,后续代码继续执行,容易掩盖故障。
  • 生成器版上下文管理器异常怎么处理?答:异常会在 yield 处重新抛出,可 try/except/finally 处理。
  • 多个资源怎么保证都释放?答:用 ExitStack 或嵌套 with,后者按逆序退出。

04.7.3-020 运算符重载怎么写?__radd__ 什么时候被调用?

一句话结论

算术运算符对应 __add__/__sub__/__mul__ 等;当左操作数不支持该运算(返回 NotImplemented)时,Python 尝试右操作数的 __radd__ 等反射方法。实现时要返回 NotImplemented 而不是抛异常,以便其他类型接手。

概念解释

  • 比较运算符对应 __lt__/__le__/__eq__,可用 functools.total_ordering 补齐。
  • 不要让运算符有隐藏副作用,调用方默认它是纯运算。

原理流程

  1. a + b 先调用 type(a).__add__(a, b)。
  2. 返回 NotImplemented 再试 type(b).__radd__(b, a)。
  3. 原地运算 += 优先 __iadd__,没有则退回 __add__ 并重新绑定。

代码或图示

class Vec:
    def __init__(self, x): self.x = x
    def __add__(self, o):
        if isinstance(o, Vec): return Vec(self.x + o.x)
        return NotImplemented
    __radd__ = __add__      # 交换律成立时可复用

常见误区

  • 把 NotImplemented(单例)与 NotImplementedError 混淆:前者是协议协商,后者是异常。
  • 不支持的类型直接抛异常,阻断了另一侧反射方法接手的机会。

追问

  • 为什么返回 NotImplemented 而不是 raise?答:让 Python 有机会尝试另一侧或报出友好 TypeError。
  • __radd__ 在 1 + vec 时会被调用吗?答:会,int 的 __add__ 不认识 Vec,返回 NotImplemented 后触发。
  • 重载 __eq__ 后比较结果会影响排序吗?答:不会,排序用 __lt__,需要 total_ordering 或全部实现。

04.7.3-021 __repr__ 和 __str__ 有什么区别?

一句话结论

__repr__ 面向开发者,应尽量无歧义、可作为重建表达(User(id=1));__str__ 面向用户,追求可读。print/f"{x}" 优先 __str__(缺失则退回 __repr__),容器与交互式环境用 __repr__。

概念解释

  • 未定义 __repr__ 时默认 <Class object at 0x...>,信息量低,调试痛苦。
  • 列表/字典嵌套时会递归调用元素的 __repr__。

原理流程

  1. print 与 f-string 优先取 __str__,缺失时退回 __repr__。
  2. 容器打印、交互式回显、日志 %r/!r 使用 __repr__。
  3. __repr__ 应无歧义、可重建,__str__ 应面向用户可读。

代码或图示

class User:
    def __init__(self, uid, name):
        self.uid, self.name = uid, name
    def __repr__(self):
        return f"User(uid={self.uid!r}, name={self.name!r})"

常见误区

  • __repr__ 不应抛异常、不应有副作用、不应做重 IO。
  • 敏感字段(密码、token)在 repr 中应打码,避免日志泄漏;只实现 __str__ 时容器打印仍用默认 repr。

追问

  • 为什么 repr 要“可重建”风格?答:便于调试时直接复制到控制台复现对象。
  • 只实现 __str__ 会怎样?答:容器打印时仍用默认 repr,调试信息依旧缺失。
  • repr 里能省略敏感信息吗?答:能且应该,日志脱敏优先于“完整表达”。

04.7.3-022 继承中的初始化顺序是怎样的?

一句话结论

Cls(...) 先 __new__ 创建实例,再 __init__ 初始化;多继承下 __init__ 沿 MRO 链由子类到父类依次执行,前提是每个 __init__ 都调用 super().__init__()。缺失任一层就会跳过其后的父类初始化。

概念解释

  • 父类 __init__ 被调用时,self 已是最终子类实例,因此不能假设子类字段已就绪。
  • 类属性初始化(类体代码)在类创建时执行一次,早于任何实例。

原理流程

  1. __new__ 与 __init__ 都按 MRO 顺序协作,但 __new__ 通常只由最底层创建。
  2. 子类 __init__ 调用 super().__init__(),沿 MRO 进入下一个类。
  3. 元类 __init__ 在类创建时执行,与实例初始化无关。

代码或图示

class A:
    def __init__(self, a): self.a = a; super().__init__()
class B:
    def __init__(self, b): self.b = b; super().__init__()
class C(A, B):
    def __init__(self):
        super().__init__(1)      # 只会给第一个父类传参

常见误区

  • 多继承下父类初始化参数需要显式传递,否则 TypeError;super().__init__() 走的是 MRO 下一个类,不是直接父类。
  • 在父类 __init__ 中假设子类字段已就绪:此时子类 __init__ 尚未执行完。

追问

  • 为什么 super().__init__() 会调用到另一个父类?答:它按 MRO 走“下一个类”,不是“直接父类”。
  • 多继承参数冲突怎么解决?答:用仅关键字参数分发,或改为组合避免共享初始化链。
  • 类体代码什么时候执行?答:class 语句执行时(模块导入/函数调用时),只执行一次。

04.7.3-023 如何用 type() 动态创建类?什么时候用?

一句话结论

type(name, bases, namespace) 是类创建的三参形式,等价于 class 语句。动态建类用于插件系统、按配置生成模型、测试替身、动态注册;可先构造字典(含方法、属性),再交给 type 或元类。

概念解释

  • namespace 是普通 dict,方法就是函数对象,__slots__、__doc__ 也可放进去。
  • 动态类同样会触发元类与 __init_subclass__。

原理流程

  1. 先构造命名空间字典,放入方法函数、注解、槽位等。
  2. 调用 type(name, bases, namespace) 生成类对象。
  3. 动态创建后显式设置 __module__、__qualname__,否则 pickle/调试信息混乱。

代码或图示

def make_model(fields):
    ns = {"__annotations__": {f: str for f in fields}}
    ns["describe"] = lambda self: ", ".join(vars(self))
    return type("DynamicModel", (object,), ns)

M = make_model(["a", "b"])

常见误区

  • 大量动态类会影响启动时间与内存,别在热路径反复建类。
  • 用 types.new_class 更规范,能正确处理 __mro_entries__ 与元类关键字;动态类默认不能被 pickle,需要类在模块级有稳定名字并能被导入找到。

追问

  • type() 动态类和 class 语句有什么区别?答:语义等价,class 更可读,动态形式便于程序化生成。
  • 动态类能被 pickle 吗?答:默认不能,需要类在模块级有稳定名字并能被导入找到。
  • 为什么推荐 types.new_class?答:它按标准流程处理基类解析、元类选择与命名空间准备。

04.7.3-024 Enum 有什么用?和常量、dataclass 常量怎么选?

一句话结论

Enum 提供具名常量集合,成员唯一、可迭代、可比较身份,值可重复检查、支持别名与自定义方法。相比裸常量,它防止拼写错误、可枚举全集、能挂行为;相比 dataclass,它强调“有限可选集合”而非数据结构。

概念解释

  • Color.RED.value 取值,Color(1) 按值反查,Color["RED"] 按名取。
  • 枚举成员在模块导入时创建,适合做配置枚举与状态机状态。

原理流程

  1. 定义 Enum 子类时,类体中的赋值被收集为枚举成员。
  2. 成员按值注册别名;@unique 禁止重复值。
  3. 访问成员返回枚举实例,.value 取底层值。

代码或图示

from enum import Enum, auto

class Status(Enum):
    PENDING = auto()
    DONE = auto()

print(Status.PENDING.value, Status(1))    # 1 Status.PENDING

常见误区

  • 成员默认按值比较相等性但不与裸值相等(Color.RED == 1 为 False,除非用 IntEnum)。
  • 标准 json 不认 Enum,需 default=lambda o: o.value 或自定义编码器;枚举成员定义后不可再扩展,子类只能定义新成员且行为受限。

追问

  • 为什么不用字符串常量?答:拼写错误无法静态发现、无法枚举全集、无法挂方法。
  • Enum 能继承吗?答:枚举成员定义后不可再扩展;子类只能定义新成员且行为受限。
  • JSON 序列化怎么办?答:标准 json 不认 Enum,需 default=lambda o: o.value 或自定义编码器。

04.7.3-025 对象比较与排序需要实现哪些方法?total_ordering 有什么用?

一句话结论

== 用 __eq__,< 用 __lt__,排序只依赖 __lt__。functools.total_ordering 只需实现 __eq__ 与一个比较方法(如 __lt__),自动补齐其余三个,但会带来额外调用开销。

概念解释

  • 未实现 __lt__ 时对象不可排序,sorted 报 TypeError。
  • 值对象应同时考虑 __hash__(见 04.7.3-013)。

原理流程

  1. 排序算法只通过“小于”关系确定顺序,调用 __lt__。
  2. 比较不支持的类型应返回 NotImplemented,以支持反射比较。
  3. total_ordering 基于 __lt__ 推导 __le__/__gt__/__ge__。

代码或图示

from functools import total_ordering

@total_ordering
class Version:
    def __init__(self, n): self.n = n
    def __eq__(self, o): return isinstance(o, Version) and self.n == o.n
    def __lt__(self, o):
        if not isinstance(o, Version): return NotImplemented
        return self.n < o.n

常见误区

  • 比较不是“严格弱序”(自相矛盾)时,Timsort 可能报错。
  • total_ordering 派生比较多一层 Python 调用,热路径可手写全部方法;元组比较逐元素进行,首个不同元素决定结果。

追问

  • 为什么排序只要求 __lt__?答:比较排序算法只需“小于”关系即可确定顺序。
  • total_ordering 有性能问题吗?答:每次派生比较多一层 Python 调用,热路径可手写全部方法。
  • 元组比较规则是什么?答:逐元素比较,首个不同元素决定结果;长度不同时短的小于长的。

04.7.3-026 类装饰器和元类该怎么选?

一句话结论

类装饰器在类创建之后加工(改属性、注册、包装),写法简单、作用域局部;元类参与类的创建过程(改命名空间、控制实例化、影响所有子类),能力更强但成本与复杂度更高。优先装饰器或 __init_subclass__,确需拦截“类创建”本身才用元类。

概念解释

  • 装饰器只能作用于被标注的类,不影响其子类的创建;元类会被所有子类继承。
  • 从可维护性看:函数 < 装饰器 < __init_subclass__ < 元类。

原理流程

  1. 类装饰器接收已创建的类对象,修改后返回。
  2. 元类在 type.__new__ 阶段参与类的生成,可改命名空间、控制 __call__。
  3. 元类会参与 MRO 与元类冲突检查,组合多个框架时容易打架。

代码或图示

def add_repr(cls):
    cls.__repr__ = lambda self: f"<{cls.__name__}>"
    return cls

@add_repr
class A: pass

常见误区

  • 装饰器可返回非类对象,元类必须返回类实例;装饰器不能拦截子类创建,除非内部改写了 __init_subclass__。
  • 框架组合时元类容易互相冲突,应优先更轻量的钩子。

追问

  • 装饰器能拦截子类创建吗?答:不能,除非装饰器内部改写了 __init_subclass__。
  • 元类能修改实例化行为吗?答:能,重写元类的 __call__ 可控制 Cls(...) 的全过程。
  • 框架里为什么大量用元类?答:ORM/枚举需要收集声明期信息并生成运行时行为,属于“类创建即加工”的场景。

04.7.3-027 绑定方法(bound method)的本质是什么?

一句话结论

函数是描述符:obj.method 触发 function.__get__,返回一个把 obj 预先绑定为第一个参数的 bound method 对象。因此 self 不是语法糖,而是绑定机制的产物;Cls.method 得到普通函数,需手动传 self。

概念解释

  • 类方法绑定的是类,静态方法不绑定。
  • types.MethodType(func, obj) 可手动绑定;functools.partial 也能模拟。

原理流程

  1. 访问 obj.method 时,函数描述符 __get__ 被调用。
  2. 返回 bound method 对象,内部持有函数与 __self__(实例)。
  3. 调用 bound method 时把 __self__ 作为第一个参数传入。

代码或图示

class A:
    def hi(self): return "hi"

a = A()
print(a.hi)              # <bound method A.hi of ...>
print(A.hi(a))           # 等价调用
print(a.hi.__self__)     # a

常见误区

  • f = obj.method 会强引用 obj,长期持有会导致对象无法释放;存放回调时可用 weakref.WeakMethod 避免强引用。
  • obj.method 每次访问都会新建 bound method 对象(有缓存优化但不保证同一对象)。

追问

  • 为什么把 obj.method 存进全局列表会导致内存泄漏?答:bound method 持有 __self__ 强引用。
  • weakref.WeakMethod 解决什么问题?答:让回调不阻止实例回收,实例没了回调自动失效。
  • 为什么 A.hi 调用要传参?答:未绑定函数没有 self,必须显式给第一个参数。

04.7.3-028 属性访问的完整优先级是什么?

一句话结论

obj.x 依次尝试:类型(按 MRO)上的数据描述符 → 实例 __dict__ → 类型上的非数据描述符/普通类属性 → __getattr__ 兜底。__getattribute__ 是整个过程的总入口,自定义它会覆盖上述流程。

概念解释

  • 类属性若为普通值,实例字典优先。
  • __getattr__ 只在前面全部失败后调用,适合动态兜底。

原理流程

  1. 先查类型 MRO 上的数据描述符(有 __set__)。
  2. 再查实例 __dict__。
  3. 再查类型上的非数据描述符/普通类属性,最后进入 __getattr__。

代码或图示

class A:
    x = "class"
    @property
    def y(self): return "prop"

a = A()
a.__dict__["x"] = "instance"
print(a.x)     # instance:普通类属性被实例字典遮蔽
print(a.y)     # prop:数据描述符优先

常见误区

  • 以为所有描述符都压过实例字典:只有数据描述符优先,函数是非数据描述符,实例字典同名属性会遮蔽方法。
  • 元类的 __getattribute__ 只影响“类对象自身的属性访问”,不影响实例。

追问

  • 为什么 property 能覆盖实例属性?答:它是数据描述符,优先级高于实例 __dict__。
  • 实例字典能覆盖方法吗?答:能,函数是非数据描述符,同名实例属性会遮蔽它。
  • __getattr__ 会拦截已存在的属性吗?答:不会,只有查找失败时才调用。

04.7.3-029 __del__ 什么时候调用?为什么不该依赖它?

一句话结论

__del__ 在对象被回收时调用(引用计数归零或 GC 回收循环引用时),时机不确定、可能在解释器关闭时、可能永不调用。资源释放应使用 with/try-finally/contextlib,__del__ 只作为最后的兜底并做好异常吞掉。

概念解释

  • 对象可能被缓存、被闭包持有,导致 __del__ 迟迟不触发。
  • weakref.finalize 比 __del__ 更可控,且不阻止回收。

原理流程

  1. 引用计数归零时对象被回收;循环引用由 GC 标记回收。
  2. 回收时调用 __del__,之后释放内存。
  3. 解释器退出时模块全局可能已被清理,__del__ 中访问其他全局可能报错。

代码或图示

import weakref
f = open("x.txt")
weakref.finalize(f, f.close)     # 对象回收时关闭,且不阻止回收

常见误区

  • 循环引用中的对象若定义了 __del__,在老版本中会阻碍回收;现代 CPython 能处理但仍不安全。
  • __del__ 抛异常会被忽略并打印到 stderr,不能作为业务逻辑;回收顺序不确定,不能假设其他对象还活着。

追问

  • 为什么 __del__ 里不能假设其他对象还活着?答:回收顺序不确定,可能依赖的模块已销毁。
  • 文件不关闭会怎样?答:句柄泄漏、数据未 flush、Windows 上文件被占用。
  • __del__ 和 close() 怎么配合?答:close() 做显式释放且幂等,__del__ 仅调用 close() 兜底。

04.7.3-030 如何实现一个真正不可变的对象?

一句话结论

组合三件事:__slots__ 限制字段、frozen dataclass 或重写 __setattr__/__delattr__ 阻止赋值、所有字段本身不可变(tuple/frozenset/str/数值)。只重写 __setattr__ 而保留 __dict__ 仍可通过 obj.__dict__["x"] = ... 绕过。

概念解释

  • 不可变对象天然线程安全、可缓存、可做 dict key。
  • 不可变不等于不能有派生属性:用 property 或 cached_property 计算即可(后者会写实例字典,与 frozen 冲突)。

原理流程

  1. __slots__ 去掉 __dict__,堵住直接改字典的绕过路径。
  2. frozen dataclass 生成抛 FrozenInstanceError 的 __setattr__,并自动生成 __hash__。
  3. 内部可变字段深度冻结(递归转 tuple/frozenset),否则仍可变。

代码或图示

from dataclasses import dataclass

@dataclass(frozen=True, slots=True)
class Config:
    host: str
    ports: tuple[int, ...] = ()

常见误区

  • frozen dataclass 不能防 object.__setattr__ 与内部可变对象,只是“常规路径”被禁止。
  • 只重写 __setattr__ 而保留 __dict__,仍可通过实例字典绕过;需要更强约束时在 __setattr__ 里判断“是否已初始化”,或用 object.__setattr__ 在 __init__ 阶段写入。

追问

  • frozen dataclass 能完全防修改吗?答:不能防 object.__setattr__ 与内部可变对象,只是“常规路径”被禁止。
  • 不可变对象怎么做缓存?答:用 lru_cache 直接以对象为 key(可哈希),或外部字典缓存。
  • 为什么 __slots__ 要和 frozen 一起用?答:__slots__ 去掉 __dict__,堵住直接改字典的绕过路径。

本节高频题

  • __new__ 与 __init__(001)
  • 类属性与实例属性(002)
  • MRO 与 C3(003)
  • super() 的真实语义(004)
  • property 与描述符(006、007)
  • __slots__(008)
  • 三种方法类型(009)
  • 元类(010)
  • 单例实现(011)
  • __eq__ 与 __hash__(013)
  • dataclass(014)
  • ABC 与 Protocol(015、016)
  • __init_subclass__(018)
  • 属性访问优先级(028)