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__里控制是否新建。
原理流程
Cls(...)先进入type.__call__。- 调用
Cls.__new__(Cls, ...)创建实例;若返回 Cls 实例,再调用obj.__init__(...)。 __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__,只能写声明过的槽位。
原理流程
- 读取属性先查实例
__dict__,未命中再沿 MRO 查类与元类。 - 普通赋值
obj.x = v写入实例__dict__,不回写类。 - 描述符(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,从而改变同名方法谁生效。
原理流程
- C3 合并各父类的 MRO 与父类列表,冲突时报
TypeError: Cannot create a consistent MRO。 - 菱形继承
D(B, C)的 MRO 通常为D → B → C → A → object,A 只出现一次。 - 属性查找与方法解析都沿 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()形成链,任意一环不调用就会断链。
原理流程
super()绑定当前类与实例,按实例 MRO 定位当前类的下一个类。super().method()沿 MRO 继续向后找,多继承下走到“下一个”父类,而不是直接父类。- 零参
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)+ 文档,而不是双下划线。
原理流程
- 改名发生在编译期,按定义它的类名把
__x改写为_ClassName__x。 - 子类中同名属性变成
_Sub__x,与父类互不干扰。 - 仍可通过
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__secretvs_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__。
原理流程
- property 作为类上的数据描述符,属性协议优先调用其
__get__/__set__。 - 数据描述符优先于实例
__dict__,所以 property 能覆盖实例属性。 - 访问属性时 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 参数区分。
原理流程
__set_name__(self, owner, name)在类创建时由type.__new__调用一次,记录字段名。- 访问时
__get__(self, obj, objtype)被调用,obj为 None 表示通过类访问。 - 赋值时
__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__ 不继承需逐类声明。
概念解释
- 适合“大量小对象”(百万级节点、点坐标、事件对象),不适合需要动态属性的对象。
- 槽位名不能与类属性/方法同名,会被覆盖。
原理流程
- 类创建时按
__slots__声明为每个槽位生成描述符。 - 实例不再分配
__dict__,属性直接存入固定槽位。 - 未声明的属性赋值触发 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语义上属于类但不需要类状态,用于组织代码或工具函数。- 类方法不能访问实例属性;实例方法能访问类属性。
原理流程
- 实例方法经函数描述符把实例绑定为第一个参数。
- 类方法经 classmethod 描述符把类绑定为第一个参数,子类调用时
cls是子类。 - 静态方法不绑定任何隐式参数,调用时原样转发。
代码或图示
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 都在元类层做工作。
- 元类让代码难懂、难调试,优先考虑更简单的替代方案。
原理流程
- 解析类体并执行得到 namespace 字典。
- 调用元类(默认
type.__new__)生成类对象,再调用元类__init__。 - 元类可拦截
__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 锁、文件锁)。
原理流程
- 模块在首次导入时创建一次,
sys.modules缓存后续复用。 __new__方案在检查-创建阶段复用同一实例;装饰器/元类方案在类创建或实例化阶段约束。- 工厂缓存方案用 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__是写入侧的对应入口。
原理流程
- 常规查找顺序:数据描述符 → 实例
__dict__→ 类/MRO →__getattr__。 - 全部失败后才调用
__getattr__;只实现它时,正常存在的属性不会走它。 __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__兜底)。
原理流程
- 定义
__eq__后解释器把__hash__置为 None,对象不可哈希。 - 显式实现
__hash__时,用参与相等判断的不可变字段组合哈希。 - 值相等必须哈希相同,否则 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__做派生计算或校验。
原理流程
- 装饰器在类创建后按字段声明生成
__init__、__repr__、__eq__等方法。 frozen=True生成不可变对象与__hash__,可作 dict key。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 主要给静态检查器。
原理流程
- 继承 ABC 并用
@abstractmethod标记必须实现的方法。 - 子类未覆盖全部抽象方法时,实例化触发 TypeError。
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 不要求继承,适合给第三方类型加约束。
原理流程
- Protocol 定义方法签名与类型注解。
- 静态检查器验证实现类是否满足协议(结构化子类型)。
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 不应依赖主类的具体字段名,除非明确文档化。
原理流程
- Mixin 只提供行为方法,不定义核心身份与主状态。
- 主类通过多继承把 Mixin 能力组合进来,方法解析沿 MRO 进行。
- 多个 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/序列化框架的字段收集、枚举式约束。
原理流程
- 子类创建完成后,由
type.__new__触发父类的__init_subclass__。 - 钩子收到子类对象与类关键字参数,执行注册/校验/注入。
- 必须调用
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。
原理流程
- 进入
with块时调用__enter__,其返回值绑定给as目标。 - 块内代码执行,正常或异常退出都调用
__exit__。 __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补齐。 - 不要让运算符有隐藏副作用,调用方默认它是纯运算。
原理流程
a + b先调用type(a).__add__(a, b)。- 返回 NotImplemented 再试
type(b).__radd__(b, a)。 - 原地运算
+=优先__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__。
原理流程
print与 f-string 优先取__str__,缺失时退回__repr__。- 容器打印、交互式回显、日志
%r/!r使用__repr__。 __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已是最终子类实例,因此不能假设子类字段已就绪。 - 类属性初始化(类体代码)在类创建时执行一次,早于任何实例。
原理流程
__new__与__init__都按 MRO 顺序协作,但__new__通常只由最底层创建。- 子类
__init__调用super().__init__(),沿 MRO 进入下一个类。 - 元类
__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__。
原理流程
- 先构造命名空间字典,放入方法函数、注解、槽位等。
- 调用
type(name, bases, namespace)生成类对象。 - 动态创建后显式设置
__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"]按名取。- 枚举成员在模块导入时创建,适合做配置枚举与状态机状态。
原理流程
- 定义 Enum 子类时,类体中的赋值被收集为枚举成员。
- 成员按值注册别名;
@unique禁止重复值。 - 访问成员返回枚举实例,
.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)。
原理流程
- 排序算法只通过“小于”关系确定顺序,调用
__lt__。 - 比较不支持的类型应返回 NotImplemented,以支持反射比较。
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__< 元类。
原理流程
- 类装饰器接收已创建的类对象,修改后返回。
- 元类在
type.__new__阶段参与类的生成,可改命名空间、控制__call__。 - 元类会参与 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也能模拟。
原理流程
- 访问
obj.method时,函数描述符__get__被调用。 - 返回 bound method 对象,内部持有函数与
__self__(实例)。 - 调用 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__只在前面全部失败后调用,适合动态兜底。
原理流程
- 先查类型 MRO 上的数据描述符(有
__set__)。 - 再查实例
__dict__。 - 再查类型上的非数据描述符/普通类属性,最后进入
__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__更可控,且不阻止回收。
原理流程
- 引用计数归零时对象被回收;循环引用由 GC 标记回收。
- 回收时调用
__del__,之后释放内存。 - 解释器退出时模块全局可能已被清理,
__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 冲突)。
原理流程
__slots__去掉__dict__,堵住直接改字典的绕过路径。- frozen dataclass 生成抛 FrozenInstanceError 的
__setattr__,并自动生成__hash__。 - 内部可变字段深度冻结(递归转 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)