Python-04-面向对象
一句话概括
Python 的面向对象(Object-Oriented Programming, OOP)本质只有三件事:类(class)是一个对象,属性查找沿一条明确的链走,对象的行为由魔术方法(magic method)定义。把这三件事想通,继承、
super()、@property、dataclass全是推论。
一、是什么
1.1 面向对象在 Python 里的定位
面向对象是一种把数据和对数据的操作打包在一起的组织手段。它不是 Python 的专属特性,但 Python 的实现有一个不寻常的起点:
- 在 C++ / Java 里,类是编译期的类型声明;
- 在 Python 里,类首先是一个运行时对象,和
42、"abc"、[1, 2]一样,可以被赋值、被传参、被动态创建。
这个差别带来一系列后果:可以在运行时给类加方法、可以用函数生成类、可以用装饰器改造类。这也解释了为什么 Python 没有真正的「私有成员」——一切都是运行时可访问的属性。
1.2 类也是对象:type 与 object 的关系
先看一段可以立刻运行的代码:
class Dog:
"""一只普通的狗。"""
species = "Canis lupus familiaris" # 类属性,所有实例共享
def bark(self) -> str:
return "汪"
# 类是对象,所以它可以被赋值、被打印、查看它的类型
print(type(Dog)) # <class 'type'> —— 类的类型是 type
print(type(Dog())) # <class '__main__.Dog'> —— 实例的类型是 Dog
print(Dog.__bases__) # (<class 'object'>,) —— 默认继承 object
print(type(object)) # <class 'type'>
print(object.__bases__) # () —— 链的终点,没有父类
print(type(type)) # <class 'type'> —— type 是自己的实例
由此得到 Python 对象模型的两条终极关系:
用文字说就是:
object是所有类的祖先(object.__bases__是空元组,它是继承链的根);type是所有类的类型(type本身也是type的实例,这个自指是刻意的设计,不是 bug)。
因此一个普通实例 Dog() 身上挂着两条链,理解这两条链是理解 Python OOP 的关键:
| 链 | 方向 | 用途 | 例子 |
|---|---|---|---|
| 实例链(MRO 链) | 实例 → 类 → 父类 → … → object | 决定属性查找走哪条路 | d.bark 找到 Dog.bark |
| 类型链(metaclass 链) | 类 → 它的元类 → … → type | 决定类本身怎么被创建 | type(Dog) is type |
重点
isinstance(x, C)检查的是实例链,issubclass(A, B)检查的是类之间的派生关系。type(x) == C只比最末端的类型,不认父类,这是它与isinstance最大的区别。
1.3 __init__ 与 self 的含义
self 不是关键字,只是约定俗成的第一个参数名。Python 调用 d.bark() 时,真正的动作是:
Dog.bark(d) # 等价于 d.bark()
也就是说,实例被当作第一个位置参数传了进去。self 就是接收它的那个形参名。名字可以改成任意合法标识符,但没人会这么做——可读性远比自由重要。
__init__ 常被误称为「构造函数」,但它不创建对象,只负责初始化已经创建好的对象:
class Point:
def __new__(cls, x, y):
# __new__ 才是真正创建并返回实例的地方
print("__new__ 先执行")
return super().__new__(cls)
def __init__(self, x, y):
# __init__ 拿到 __new__ 返回的实例,再往里填数据
print("__init__ 后执行")
self.x = x
self.y = y
p = Point(1, 2)
# 输出顺序:__new__ 先执行 → __init__ 后执行
| 方法 | 职责 | 返回值 | 何时需要重写 |
|---|---|---|---|
__new__(cls, ...) | 创建并返回实例 | 必须是实例 | 需要控制实例创建时(如不可变类型、单例、缓存) |
__init__(self, ...) | 初始化已有实例 | 必须返回 None | 99% 的情况只需要写这个 |
常见错误
__init__忘记写self,或者写了return self。前者会报TypeError: __init__() takes 1 positional argument but 2 were given;后者会报TypeError: __init__() should return None, not 'Point'。
二、为什么这样设计
2.1 为什么类必须是对象
如果类只是编译期声明,就很难实现下面这些 Python 里习以为常的写法:
# 运行时按名字创建类——Django ORM、SQLAlchemy、pydantic 都依赖这一点
def make_model(name: str) -> type:
return type(name, (object,), {"describe": lambda self: f"我是 {name}"})
User = make_model("User")
print(User().describe()) # 我是 User
2.2 为什么用魔术方法而不是强制接口
Java 要求类 implements Comparable 才能比较大小;Python 不要求,只要实现了 __lt__,< 就能用。这是「鸭子类型(duck typing)」的直接体现:
如果它走起来像鸭子、叫起来像鸭子,那它就是鸭子。
代价是错误从「编译期」推迟到了「运行期」。收益是代码可以极度灵活:写一个函数接收「任何能 len() 的东西」,不必为 list、str、dict 分别写重载。
2.3 为什么 super() 不能简单理解成「父类」
super() 返回的是一个代理对象,它按 MRO 顺序去找「当前类之后的下一个类」。在单继承里它确实等价于「父类」,但在多重继承里它可能是兄弟类。这一点在 3.3 节展开。
三、核心内容
3.1 实例属性与类属性
class Account:
bank = "示例银行" # 类属性:所有实例共享,只存一份
rates = [] # 危险:可变类属性
def __init__(self, owner: str, balance: float = 0.0):
self.owner = owner # 实例属性:每个实例一份
self.balance = balance
查找顺序(读属性时):
即:先找实例自己的字典,找不到再沿 MRO 往上找类。写属性时规则不同:
self.x = v永远写进实例的__dict__;Account.x = v写进类的__dict__,影响所有还没有实例属性的对象。
a, b = Account("张三"), Account("李四")
b.bank = "另一家银行" # 这只是给 b 加了一个实例属性,类属性没变
print(a.bank, b.bank, Account.bank)
# 示例银行 另一家银行 示例银行
可变类属性陷阱
下面这段代码会让两个实例看起来「串数据」,实际原因是它们共享同一个 list 对象:
```python
class Account:
rates = [] # 类级别只创建了一次
def add_rate(self, r):
self.rates.append(r) # 注意:这是「读」rates 再「就地修改」,没有赋值!
x, y = Account(), Account()
x.add_rate(1)
print(y.rates) # [1] —— y 也被改了
```
修正方式只有一种:把可变默认值放进
__init__。```python
class Account:
def __init__(self):
self.rates = [] # 每个实例各自一份
```
3.2 三种方法类型
| 对比项 | 实例方法 | 类方法 @classmethod | 静态方法 @staticmethod |
|---|---|---|---|
| 第一个参数 | self(实例) | cls(类本身) | 无特殊参数 |
| 绑定对象 | 实例 | 类 | 都不绑定 |
| 能否访问实例属性 | ✅ | ❌ | ❌ |
| 能否访问类属性 | ✅(经 self) | ✅(经 cls) | ❌(需显式写类名) |
| 继承时是否多态 | ✅ | ✅(cls 是子类) | ❌(写死类名) |
| 典型用途 | 绝大多数方法 | 备用构造器、工厂方法 | 与类相关但不需要状态的小工具 |
| 调用方式 | obj.m() / C.m(obj) | C.m() / obj.m() | C.m() / obj.m() |
import datetime as dt
class Person:
species = "Homo sapiens"
def __init__(self, name: str, birth: dt.date):
self.name = name
self.birth = birth
def age(self) -> int:
"""实例方法:需要读 self.birth,所以必须绑定实例。"""
today = dt.date.today()
return today.year - self.birth.year - (
(today.month, today.day) < (self.birth.month, self.birth.day)
)
@classmethod
def from_iso(cls, name: str, iso: str) -> "Person":
"""类方法:备用构造器。用 cls 而不是写死 Person,
这样子类调用时返回的是子类实例。"""
return cls(name, dt.date.fromisoformat(iso))
@staticmethod
def is_adult(age: int) -> bool:
"""静态方法:纯粹的判断逻辑,不需要实例也不需要类,
放在类里只是因为概念上属于这里。"""
return age >= 18
p = Person.from_iso("李雷", "2000-05-20")
print(p.age())
print(Person.is_adult(p.age()))
class Student(Person):
pass
# 关键验证:cls 的多态性
s = Student.from_iso("韩梅梅", "2005-01-01")
print(type(s).__name__) # Student —— 如果 from_iso 里写死 return Person(...),这里会是 Person
实践建议
@staticmethod用得越少越好。如果一个方法完全不需要类和实例,它通常更适合做成模块级函数——省掉一层没有信息量的命名空间。它真正的用武之地是「逻辑上从属于该类、但实现上无状态」的场景。
3.3 继承与 MRO
MRO(Method Resolution Order,方法解析顺序)由 C3 线性化算法计算,保证三条性质:
- 子类一定排在父类之前;
- 多个父类的相对顺序保持一致(按
class C(A, B)中书写的顺序); - 任意类的 MRO 中,每个类只出现一次(被继承的「公共祖先」不会重复)。
其中 反复取各列表的第一个元素,若它没有出现在其它列表的尾部,就取出并加入结果。
class A:
def who(self):
return "A"
class B(A):
def who(self):
return "B"
class C(A):
def who(self):
return "C"
class D(B, C):
pass
print([c.__name__ for c in D.__mro__])
# ['D', 'B', 'C', 'A', 'object']
print(D().who()) # B —— 沿 MRO 找第一个实现了 who 的类
菱形问题(diamond problem):A 被 B、C 同时继承,D 又继承 B、C。C3 保证 A 在 MRO 中只出现一次,但如果每个类都用 A.method(self) 这种硬编码方式调用父类,A 会被执行多次。正确写法是协作式 super():
class Base:
def setup(self):
print("Base.setup")
return []
class ReadMixin(Base):
def setup(self):
# 先让 MRO 后续的类完成它们的工作,再叠加自己的
value = super().setup()
print("ReadMixin.setup")
return value + ["read"]
class WriteMixin(Base):
def setup(self):
value = super().setup()
print("WriteMixin.setup")
return value + ["write"]
class Service(ReadMixin, WriteMixin):
pass
print(Service().setup())
# 实际输出(注意顺序是被 MRO 决定的):
# Base.setup
# WriteMixin.setup
# ReadMixin.setup
# ['write', 'read']
# 过程解释:MRO 是 Service → ReadMixin → WriteMixin → Base。
# ① Service.setup 未定义,找到 ReadMixin.setup 并进入;
# ② 它调用 super().setup(),沿 MRO 走到 WriteMixin.setup;
# ③ WriteMixin 再 super() 走到 Base.setup,返回 [];
# ④ 逐层回溯叠加:[] → ['write'] → ['write', 'read']。
# 关键点:Base.setup 只执行了一次——这正是协作式 super() 相对硬编码父类调用的价值。
super() 的真正含义是:「在我所属实例的 MRO 里,排在我这个类之后的那个类」。它携带两个隐含信息——__class__(从哪个类往后找)和第一个参数(拿谁的 MRO)。所以下面两种写法等价,但第二种是唯一正确的通用形式:
class Child(Parent):
def m(self):
super().m() # Python 3 的写法,等价于 super(Child, self).m()
# Parent.m(self) # 硬编码:破坏协作式多继承,尽量不要写
| 写法 | 单继承 | 多继承 | 是否推荐 |
|---|---|---|---|
super().m() | 调用父类 | 按 MRO 调用下一个 | ✅ 推荐 |
Parent.m(self) | 调用父类 | 可能重复调用、跳过兄弟类 | ⚠️ 仅在明确知道后果时使用 |
super(Child, self).m() | 等价 | 等价 | 🔸 显式但啰嗦,Python 2 遗留风格 |
不要重写
__init__时忘记调用super().__init__()```python
class Bad(Person):
def __init__(self, name):
self.name = name # 父类的 birth 永远不会被设置
```
症状是调用父类方法时抛
AttributeError,很难联想到是__init__的问题。
3.4 方法重写与类型检查
class Animal:
def speak(self) -> str:
raise NotImplementedError("子类必须实现 speak")
class Cat(Animal):
def speak(self) -> str:
return "喵"
c = Cat()
print(isinstance(c, Cat), isinstance(c, Animal), isinstance(c, object))
# True True True
print(issubclass(Cat, Animal), issubclass(Animal, Cat))
# True False
print(type(c) is Animal) # False —— type() 不认继承
| 函数 | 检查对象 | 是否认继承 | 是否支持元组 | 典型场景 |
|---|---|---|---|---|
isinstance(x, T) | 实例与类型 | ✅ | ✅ isinstance(x, (int, float)) | 90% 的类型判断 |
issubclass(A, B) | 类与类 | ✅ | ✅ | 校验注册的子类、ABI 检查 |
type(x) is T | 精确类型 | ❌ | ❌ | 需要排除子类时(如序列化的精确匹配) |
hasattr(x, "m") | 属性是否存在 | ✅ | ❌ | 鸭子类型检查(注意触发 @property) |
3.5 魔术方法
魔术方法是「以双下划线开头和结尾」的方法,它们由语言语法触发,而不是由你手动调用。
| 魔术方法 | 触发语法 | 作用 |
|---|---|---|
__str__ | str(x)、print(x)、f-string | 给人看的可读表示 |
__repr__ | repr(x)、交互式回显、容器内部的元素显示 | 给开发者看的、理想情况下能重建对象 |
__eq__ | x == y | 相等性判定 |
__hash__ | hash(x)、放进 set/dict 的键 | 哈希值 |
__len__ | len(x) | 长度 |
__getitem__ | x[i]、切片、for 迭代(备选协议) | 下标访问 |
__setitem__ | x[i] = v | 下标赋值 |
__contains__ | v in x | 成员判断(没有则退化为迭代) |
__call__ | x(...) | 让实例可调用 |
__iter__ | for v in x、iter(x) | 返回迭代器 |
__enter__ / __exit__ | with x: | 上下文管理 |
__add__ / __radd__ | x + y | 算术运算(r 版本处理右操作数) |
__bool__ | if x:、bool(x) | 真值判断(没有则看 __len__) |
__str__ 与 __repr__ 的分工,用一句口诀记住:
__repr__面向开发者,要能重建对象;__str__面向用户,要好看。没定义__str__时会退回到__repr__,反之不成立。
class Money:
def __init__(self, amount: float, currency: str = "CNY"):
self.amount = amount
self.currency = currency
def __repr__(self) -> str:
# 目标是 eval(repr(obj)) == obj,所以带齐全部构造参数
return f"Money(amount={self.amount!r}, currency={self.currency!r})"
def __str__(self) -> str:
# 目标是给终端用户看,所以带上符号和千分位
return f"{self.amount:,.2f} {self.currency}"
def __eq__(self, other) -> bool:
# 类型不同时返回 NotImplemented 而不是 False,这样 Python 会去尝试
# other.__eq__(self)(反射比较),是更正确的协议用法
if not isinstance(other, Money):
return NotImplemented
return (self.amount, self.currency) == (other.amount, other.currency)
def __hash__(self) -> int:
# 参与比较的字段必须参与哈希,否则会出现「相等但哈希不同」的矛盾
return hash((self.amount, self.currency))
m = Money(1234.5)
print(repr(m)) # Money(amount=1234.5, currency='CNY')
print(str(m)) # 1,234.50 CNY
print({m, Money(1234.5)}) # 只有一个元素,说明 __eq__/__hash__ 生效
__len__、__getitem__、__iter__、__call__ 综合示例:
class Deck:
"""一副牌:演示容器协议与可调用协议。"""
def __init__(self, cards: list[str]):
self._cards = list(cards)
def __len__(self) -> int:
return len(self._cards)
def __getitem__(self, index):
# 委托给 list,切片、负索引、for 迭代就全部自动可用
return self._cards[index]
def __contains__(self, item) -> bool:
return item in self._cards
def __iter__(self):
# 显式实现迭代器协议;不写的话 for 会退化成 __getitem__ 从 0 递增
return iter(self._cards)
def __call__(self, n: int) -> list[str]:
# 让实例可调用,适合「取前 n 张」这类带参数的行为
return self._cards[:n]
d = Deck(["A♠", "K♥", "Q♦"])
print(len(d), d[0], d[-1], d[0:2])
print("A♠" in d)
print(d(2))
for card in d: # 迭代可用
print(card)
实现 __eq__ 后为什么必须考虑 __hash__:这是 Python 数据模型里最经典的陷阱。规则是——
定义了
__eq__但没有定义__hash__的类,其__hash__会被自动设为None,实例不可哈希。
class P:
def __init__(self, x): self.x = x
def __eq__(self, other): return isinstance(other, P) and self.x == other.x
print(P.__hash__) # None —— 自动被设为 None,而不是继承 object.__hash__
try:
{P(1)} # 报错
except TypeError as e:
print(e) # unhashable type: 'P'
原因是哈希契约:
如果自动继承 object.__hash__(基于 id()),那么两个「相等」的对象会有不同哈希,导致 set 或 dict 出现重复键,逻辑彻底崩坏。所以 Python 选择直接禁用哈希,强迫你明确表态。
三种处理方式:
# 方式 1:对象需要参与相等比较,也需要当 dict 键 → 手动实现一致版本的 __hash__
class A:
def __init__(self, x): self.x = x
def __eq__(self, o): return isinstance(o, A) and self.x == o.x
def __hash__(self): return hash(self.x)
# 方式 2:对象是可变的,本来就不该当键 → 显式禁用,把意图写进代码
class B:
def __init__(self, x): self.x = x
def __eq__(self, o): return isinstance(o, B) and self.x == o.x
__hash__ = None # 显式声明「我有意不可哈希」
# 方式 3:@dataclass 里用 eq=False,保留默认的按身份比较与 hash
3.6 属性管理:@property、setter 与 __slots__
@property 把「方法」包装成「属性访问」,用途是在保持 obj.x 语法不变的前提下加入校验或计算逻辑——这正是「统一访问原则(uniform access principle)」的落地。
class Temperature:
def __init__(self, celsius: float = 0.0):
self.celsius = celsius # 走 setter,初值也会被校验
@property
def celsius(self) -> float:
return self._celsius
@celsius.setter
def celsius(self, value: float) -> None:
if value < -273.15:
raise ValueError(f"温度不能低于绝对零度:{value}")
self._celsius = value # 内部存到 _celsius,避免无限递归
@property
def fahrenheit(self) -> float:
"""派生属性:只读,无需存储,永远不会不一致。"""
return self._celsius * 9 / 5 + 32
t = Temperature(25)
print(t.fahrenheit) # 77.0
t.celsius = 30 # 触发 setter
try:
t.celsius = -300 # 触发校验
except ValueError as e:
print(e)
无限递归陷阱
在 setter 里写
self.celsius = value会无限递归(setter 调用自己),最终RecursionError。必须用一个不同名的内部属性(通常加下划线),如self._celsius。
__slots__ 的内存优势:默认情况下每个实例都带一个 __dict__(哈希表),对拥有上百万个实例的程序是巨大开销。__slots__ 用固定偏移的槽位取代字典:
| 对比项 | 默认(有 __dict__) | 声明 __slots__ |
|---|---|---|
| 每个实例的额外内存 | 一个 dict(约 100+ 字节起步,且随属性数增长) | 每个槽一个指针(约 8 字节) |
| 能否动态加属性 | ✅ obj.new_attr = 1 | ❌ AttributeError |
| 能否被继承 | — | 子类若不声明 __slots__,会重新获得 __dict__ |
是否有 __dict__ / __weakref__ | 有 | 默认无(需显式加进 __slots__) |
| 访问速度 | 稍慢(字典查找) | 稍快(偏移访问) |
| 典型场景 | 一般业务对象 | 海量小对象(几何点、图节点、数据行) |
import sys
class PointDict:
def __init__(self, x, y):
self.x, self.y = x, y
class PointSlots:
__slots__ = ("x", "y")
def __init__(self, x, y):
self.x, self.y = x, y
a, b = PointDict(1, 2), PointSlots(1, 2)
print(sys.getsizeof(a), sys.getsizeof(a.__dict__)) # 48 296 —— 实例本体 + 一个字典
print(sys.getsizeof(b)) # 48 —— 只有实例本体,没有字典
# 于是每个实例实际占用:PointDict ≈ 344 字节,PointSlots = 48 字节。
# 百万个实例就是 344 MB 与 48 MB 的差别。
# 注意:具体字节数随 Python 版本与平台变化,务必用 sys.getsizeof 自己量一遍。
为什么
__slots__省内存差别不在实例本体上(两者都是 48 字节),而在那个额外的
__dict__:字典为了支持任意键和快速查找,内部有哈希表结构,即使只有两个字段也要占近 300 字节。__slots__改用固定偏移的槽位,每个槽只是一个指针(8 字节),于是两个字段只需 16 字节而不是一个完整的字典。
关于内存数字
sys.getsizeof只统计对象自身,不含其引用的对象。要测准确的内存占用请用sys.getsizeof递归统计或第三方库pympler。具体字节数以官方最新文档与当前解释器版本为准。
3.7 私有约定与 name mangling
Python 没有访问控制关键字,只有约定:
| 写法 | 名称 | 含义 | 是否真的被限制 |
|---|---|---|---|
name | 公开 | 任何人都可以用 | — |
_name | 单下划线 | 「内部使用」,请勿依赖 | ❌ 纯约定,from m import * 会跳过 |
__name | 双下划线前缀 | 触发名称改写(name mangling) | 🔸 变成 _ClassName__name,防意外覆盖 |
__name__ | 双下划线前后 | 系统保留名 | ❌ 不要自造 |
class BankAccount:
def __init__(self, balance: float):
self.__balance = balance # 实际存成 _BankAccount__balance
def get_balance(self) -> float:
return self.__balance
acct = BankAccount(100)
print(acct._BankAccount__balance) # 100 —— 改写只是避免冲突,不是安全机制
name mangling 的两个坑
1. 它不是安全机制。任何人写
obj._ClassName__attr都能访问,最多防「手滑」。真正的敏感数据(密钥、密码)根本不该放进客户端可访问的对象里。2. 在子类里会失效:子类定义
self.__x会变成_Sub__x,与父类的_Base__x是两个不同属性,容易写出「明明赋值了但父类方法读不到」的诡异 bug。需要跨类协作的内部属性,用单下划线更清晰。
3.8 dataclass 装饰器
@dataclass(PEP 557)根据类变量上的类型注解自动生成 __init__、__repr__、__eq__ 等方法,把「只用来装数据的类」从模板代码里解放出来。
from dataclasses import dataclass, field, asdict, replace
@dataclass(order=True, frozen=False)
class Student:
name: str
age: int
# 可变默认值必须用 field(default_factory=...),不能用 []
# 因为 dataclass 会把默认值放在类属性上,共享可变对象正是 3.1 节的陷阱
courses: list[str] = field(default_factory=list)
# 不参与 __init__,也不参与比较;常用于缓存或运行时填充
_cache: dict = field(default_factory=dict, init=False, repr=False, compare=False)
def add(self, course: str) -> None:
self.courses.append(course)
s1 = Student("李雷", 20, ["数学"])
s2 = Student("韩梅梅", 19)
s1.add("物理")
print(s1) # Student(name='李雷', age=20, courses=['数学', '物理'])
print(s1 == Student("李雷", 20, ["数学", "物理"])) # True
print(Student("A", 18) < Student("B", 18)) # True —— order=True 按字段顺序比较
print(asdict(s2)) # {'name': '韩梅梅', 'age': 19, 'courses': [], '_cache': {}}
# 注意:asdict 会包含所有字段,repr=False / compare=False 只影响 __repr__ 与比较,不影响 asdict
print(replace(s2, age=20)) # Student(name='韩梅梅', age=20, courses=[])
常用 field 参数:
| 参数 | 作用 | 典型用途 |
|---|---|---|
default | 简单默认值 | age: int = 0 |
default_factory | 用工厂函数生成默认值 | list、dict、set |
init=False | 不出现在 __init__ 签名里 | 缓存、派生数据 |
repr=False | 不参与 __repr__ | 长字段、敏感字段 |
compare=False | 不参与 __eq__ 与排序 | 缓存、时间戳 |
kw_only=True | 强制关键字传参(3.10+) | 避免位置参数错位 |
@dataclass 与普通类的对比:
| 对比项 | 手写普通类 | @dataclass |
|---|---|---|
__init__ | 手写,字段多时冗长 | 自动生成 |
__repr__ | 手写或继承默认(<__main__.X object at 0x...>) | 自动生成,字段一览无余 |
__eq__ | 默认按身份比较 | 默认按字段比较(eq=False 可关) |
__hash__ | 继承 object | eq=True, frozen=False 时为 None(不可哈希);frozen=True 时自动生成 |
| 排序 | 需手写 __lt__ 等 6 个方法 | order=True 一行搞定 |
| 可变默认值 | 手写 __init__ 里处理 | field(default_factory=...) |
| 适用场景 | 有复杂行为逻辑的领域对象 | 数据传输对象(DTO)、配置、值对象 |
from dataclasses import dataclass
@dataclass(frozen=True)
class Config:
host: str = "127.0.0.1"
port: int = 8000
c = Config()
print(hash(c)) # frozen=True 自动生成了 __hash__,可以当 dict 键
try:
c.port = 9000 # 报错:frozen 禁止赋值
except Exception as e:
print(type(e).__name__, e) # FrozenInstanceError ...
3.9 抽象基类 abc
抽象基类(Abstract Base Class, ABC)用于强制子类实现指定方法,把「接口约定」从注释和文档变成运行期错误。PEP 3119 引入了 abc 模块。
from abc import ABC, abstractmethod
class Shape(ABC):
@abstractmethod
def area(self) -> float:
"""所有形状都必须能算面积。"""
@abstractmethod
def perimeter(self) -> float:
...
def describe(self) -> str:
# 非抽象方法可以有默认实现,子类可复用
return f"{type(self).__name__}: 面积={self.area():.2f},周长={self.perimeter():.2f}"
class Circle(Shape):
def __init__(self, r: float):
self.r = r
def area(self) -> float:
return 3.141592653589793 * self.r ** 2
def perimeter(self) -> float:
return 2 * 3.141592653589793 * self.r
print(Circle(1).describe()) # Circle: 面积=3.14,周长=6.28
try:
Shape() # 不能实例化抽象类
except TypeError as e:
# 报错信息会明确列出还缺哪些抽象方法,这是 ABC 相对 NotImplementedError 的优势
print(e) # Can't instantiate abstract class Shape without an implementation for abstract methods 'area', 'perimeter'
abc 还提供两个强大工具:register 虚子类和 __subclasshook__。
from abc import ABC
from collections.abc import Sized
class MyListLike(ABC):
@classmethod
def __subclasshook__(cls, C):
# 鸭子类型的「结构化」判定:有 __len__ 就算 Sized 的实现
if cls is MyListLike:
if any("__len__" in B.__dict__ for B in C.__mro__):
return True
return NotImplemented
class NotRegistered: # 没有显式继承 MyListLike
def __len__(self): return 0
print(issubclass(NotRegistered, MyListLike)) # True —— 靠 __subclasshook__ 判定
print(issubclass(list, Sized)) # True —— 标准库的典型用法
3.10 组合优于继承
经典设计原则:优先使用组合(composition)而不是继承(inheritance)。继承表达的是「is-a」,组合表达的是「has-a」。
| 维度 | 继承 | 组合 |
|---|---|---|
| 关系语义 | is-a(学生是人) | has-a(汽车有引擎) |
| 耦合度 | 高:父类改动直接影响子类 | 低:只依赖被组合对象的公开接口 |
| 是否受 MRO 影响 | 是 | 否 |
| 运行时替换 | ❌ | ✅ 换一个实现对象即可 |
| 单元测试 | 需要构造父类环境 | 可以注入 fake 对象 |
| 膨胀风险 | 继承层次变深后难以理解 | 职责清晰,易拆分 |
| 正确用法 | 真正的类型层级,且子类满足里氏替换 | 绝大多数「复用代码」的场景 |
# ❌ 用继承复用代码:Stack 继承了 list,于是继承了 insert/pop(0) 等不该有的方法
class BadStack(list):
def push(self, item):
self.append(item)
s = BadStack()
s.push(1)
s.insert(0, 999) # 栈的语义被破坏了,而且没人会报错
print(s)
# ✅ 用组合:只暴露栈该有的接口,内部实现可以随时更换
class GoodStack:
def __init__(self):
self._items: list[int] = []
def push(self, item: int) -> None:
self._items.append(item)
def pop(self) -> int:
if not self._items:
raise IndexError("pop from empty stack")
return self._items.pop()
def __len__(self) -> int:
return len(self._items)
def __bool__(self) -> bool:
return bool(self._items)
gs = GoodStack()
gs.push(1)
print(gs.pop(), len(gs), bool(gs))
3.11 鸭子类型与协议
鸭子类型:不检查对象的类型,只检查它是否支持所需操作。
def total_length(items) -> int:
# 不关心 items 是 list、tuple、set 还是自定义容器,只要有 __len__
return sum(len(x) for x in items)
print(total_length([[1, 2], "abc", {"k": 1}])) # 6
typing.Protocol(PEP 544)把鸭子类型写成静态类型:既不要求继承,又能让类型检查器(mypy / pyright)理解你的意图。
from typing import Protocol, runtime_checkable
@runtime_checkable
class Drawable(Protocol):
def draw(self) -> str: ...
class Circle: # 没有继承 Drawable
def draw(self) -> str:
return "○"
def render(x: Drawable) -> None: # 类型检查器会静态校验 x 有 draw
print(x.draw())
render(Circle())
print(isinstance(Circle(), Drawable)) # True —— runtime_checkable 让它在运行时也能查
结构子类型 vs 名义子类型
- 名义子类型(nominal subtyping):靠显式继承建立关系,Java/C# 的接口属于此类。
- 结构子类型(structural subtyping):靠「有哪些方法」建立关系,Python 的鸭子类型与
Protocol属于此类。前者更明确、更易做静态分析;后者更灵活、更少改动既有代码。Python 用
Protocol同时拿到了两者。
四、怎么用
下面是一个端到端的小例子,把本节的核心概念串起来:一个可扩展的「形状面积统计器」。
"""形状统计:演示 ABC + dataclass + property + 魔术方法 + 组合 的协作。"""
from __future__ import annotations
import math
from abc import ABC, abstractmethod
from dataclasses import dataclass, field
class Shape(ABC):
"""抽象基类:约定所有形状必须能算面积。"""
@abstractmethod
def area(self) -> float:
...
def __lt__(self, other: "Shape") -> bool:
# 实现 __lt__ 之后,sorted() 就能直接对形状排序
if not isinstance(other, Shape):
return NotImplemented
return self.area() < other.area()
@dataclass(frozen=True)
class Circle(Shape):
radius: float
def __post_init__(self) -> None:
# frozen=True 时也不能直接赋值,要用 object.__setattr__ 绕过
if self.radius <= 0:
raise ValueError("半径必须为正数")
object.__setattr__(self, "radius", float(self.radius))
def area(self) -> float:
return math.pi * self.radius ** 2
def __str__(self) -> str:
return f"圆(r={self.radius})"
@dataclass(frozen=True)
class Rect(Shape):
width: float
height: float
def area(self) -> float:
return self.width * self.height
def __str__(self) -> str:
return f"矩形({self.width}×{self.height})"
class Composite:
"""组合:一个「形状集合」本身不是 Shape,但拥有若干 Shape。"""
def __init__(self) -> None:
self._shapes: list[Shape] = []
def add(self, shape: Shape) -> "Composite":
self._shapes.append(shape)
return self # 返回 self 以支持链式调用
def __len__(self) -> int:
return len(self._shapes)
def __iter__(self):
return iter(self._shapes)
def __getitem__(self, index):
return self._shapes[index]
@property
def total_area(self) -> float:
return sum(s.area() for s in self._shapes)
def __repr__(self) -> str:
return f"Composite({self._shapes!r})"
if __name__ == "__main__":
group = Composite().add(Circle(1)).add(Rect(2, 3)).add(Circle(0.5))
print(f"共 {len(group)} 个形状,总面积 {group.total_area:.4f}")
for s in sorted(group):
# 注意:不能写 f"{s:<16}"。只定义 __str__ 而没有实现 __format__ 的类,
# 继承的是 object.__format__:格式串为空时它会退化成 str(self),
# 但只要格式串非空(如 "<16")就直接抛
# TypeError: unsupported format string passed to Circle.__format__。
# 先 str() 转成字符串,格式串作用在字符串上,才是安全写法。
print(f" {str(s):<16} 面积={s.area():.4f}")
print("最大的形状:", max(group, key=lambda s: s.area()))
运行结果:
共 3 个形状,总面积 9.9270
圆(r=0.5) 面积=0.7854
圆(r=1.0) 面积=3.1416
矩形(2×3) 面积=6.0000
最大的形状: 矩形(2×3)
四点值得注意:
- 总面积可手工验算:。
- 排序结果是 ,证明
__lt__让sorted()正确按面积比较(而不是按对象身份或定义顺序)。 - 第一个圆显示为
圆(r=1.0)而不是圆(r=1),因为__post_init__里做了float(self.radius)归一化——同一种数值在输出里保持同一形式,能避免「1」与「1.0」混杂带来的比对困扰。 - 看起来对齐不齐,是因为
str.ljust按字符数补齐,而中日韩字符在终端里占 2 个显示列。真要严格对齐需要用unicodedata.east_asian_width自己算宽度。
这个例子里每个概念都有明确职责:
| 概念 | 在本例中的体现 | 解决什么问题 |
|---|---|---|
ABC + @abstractmethod | Shape.area | 实例化时(运行期)强制子类实现,并明确报出缺哪些方法 |
@dataclass(frozen=True) | Circle、Rect | 免写 __init__/__repr__/__eq__,并保证不可变 |
__post_init__ | 校验半径 | 在自动生成的 __init__ 之后插入校验 |
__lt__ | sorted(group) | 让自定义对象支持排序 |
__len__/__iter__/__getitem__ | Composite | 让自定义容器能用 len()、for、下标 |
@property | total_area | 派生数据不存储,永不不一致 |
| 组合 | Composite 持有 list[Shape] | 不继承 list,只暴露必要接口 |
五、注意事项与常见坑
坑 1:可变默认参数 / 可变类属性
```python
def f(items=[]): ... # 函数默认值也是同一类错误:默认值在定义时求值一次
class C:
items = [] # 类属性共享
```
一律改成
None哨兵或__init__内创建。@dataclass用field(default_factory=list)。
坑 2:
__eq__忘了__hash__一旦定义
__eq__,__hash__自动变成None,对象无法进set、不能当dict键。要么成对实现,要么显式写__hash__ = None表明意图。
坑 3:
__repr__里访问未初始化的属性调试器或异常信息可能在对象构造到一半时调用
__repr__。```python
class Broken:
def __init__(self, a, b):
self.a = a
raise RuntimeError("构造失败") # 此时 self.b 还不存在
def __repr__(self):
return f"Broken({self.a}, {self.b})" # 打印时会再抛 AttributeError
```
用
getattr(self, "b", None)或让__repr__只引用安全字段。
坑 4:在
__init__之前使用self静态方法、类方法、
@property都可能在实例尚未初始化完整时被调用(例如被__repr__、被反序列化框架、被copy)。所有属性初始化逻辑尽量集中在__init__顶部。
坑 5:多重继承里混用
super()和硬编码父类调用一个类层次里只要有一处写了
Parent.m(self),协作式链就断了,可能出现「某个 mixin 的初始化被跳过」。统一用super(),并让__init__都接受**kwargs并向下传递。
坑 6:
__slots__与继承、__dict__的冲突子类不声明
__slots__时会重新获得__dict__,父类的内存优化白做。另外声明了__slots__的类不能再给实例动态加属性,如果某个框架(如某些 ORM)依赖动态属性,会直接崩。
坑 7:
property与hasattr的交互
hasattr(obj, "x")会真的去调用propertygetter。如果 getter 抛AttributeError,hasattr返回False;如果抛别的异常,会直接向上冒泡。在__getattr__里写hasattr(self, ...)极易造成无限递归。
实践建议
- 字段多、以数据为主 → 用
@dataclass;有复杂不变量与行为 → 手写类。- 需要「值语义」(相等即相等)→
frozen=True+ 自动__hash__。- 需要「身份语义」(每个对象唯一)→
eq=False。- 继承层次尽量不超过两层;跨模块复用功能优先用 mixin + 组合。
- 用
mypy或pyright做静态检查,能让Protocol的价值真正兑现。
六、练习题
- 基础题:定义一个
Vector2D类,支持+、-、==、abs()(返回模长 )、repr()。要求实现__add__、__sub__、__eq__、__abs__、__repr__,并说明为什么还要(或不要)实现__hash__。
- 基础题:写一个
Student类,用@dataclass定义name、scores: list[int],加一个只读@property average。要求:(a) 每个实例的scores互相独立;(b)Student可以放进set(思考需要什么条件)。
- 进阶题:实现一个
Matrix类,内部用组合持有一个list[list[float]],支持__getitem__((i, j))取元素、__len__返回行数、__matmul__实现矩阵乘法。写出矩阵乘法的复杂度 (方阵情形),并解释为什么写成i, k, j三层循环比i, j, k更快(提示:缓存局部性)。
- 进阶题:下列关于 MRO 的代码输出什么?先手算再运行验证。
```python
class A:
def ping(self): return "A"
class B(A):
def ping(self): return "B" + super().ping()
class C(A):
def ping(self): return "C" + super().ping()
class D(B, C):
def ping(self): return "D" + super().ping()
print(D().ping())
```
同时写出 D.__mro__,并解释为什么结果不是 "DBCA" 或 "DBAC"。
- 思考题:「组合优于继承」在什么情况下不成立?举一个应该用继承的例子,并说明判断标准(提示:里氏替换原则、是否需要被当作父类使用、是否需要多态分派)。
七、常见问题(FAQ)
Q1:self 一定要叫 self 吗?静态方法和类方法可以叫别的名字吗?
A:self 只是约定,改成 this、obj 程序照样运行;但所有 Python 代码、文档、工具(IDE 补全、linter)都假设它叫 self,改名会显著降低可读性,不要这么做。@classmethod 的第一个参数惯例叫 cls,同理。@staticmethod 没有任何隐含参数,参数名随便取。
Q2:isinstance 和 type() 该用哪个?
A:默认用 isinstance,因为它认继承,符合多态语义。只有在你明确希望排除子类时才用 type(x) is T——例如判断「这个对象恰好是 bool 而不是 int」(注意 bool 是 int 的子类,isinstance(True, int) 是 True)。另外,isinstance(True, int) 为真,这在实际项目中造成过不少「布尔值被当成 1 参与计算」的 bug。
Q3:为什么定义了 __eq__ 之后对象就不能放进 set 了?
A:不是「不能」,而是 Python 故意把 __hash__ 设成 None,强迫你明确表态。因为默认的哈希基于 id(),而你新定义的相等语义基于字段值,两者会违反「相等则哈希相同」的契约,导致 set/dict 出现逻辑上重复的键。解法见 3.5 节的三种方式。
Q4:@dataclass 能完全替代手写类吗?
A:不能。@dataclass 只生成 __init__、__repr__、__eq__(以及可选的 __lt__ 系列)和 __hash__ 相关代码,它不处理:复杂的构造逻辑(需配合 __post_init__)、不可变对象的嵌套深度(frozen=True 只冻结顶层)、继承时的字段顺序约束(有默认值的字段必须在无默认值字段之后)、以及 __slots__ 的完整配合(3.10+ 支持 slots=True)。以数据容器为主的类用它最划算;有丰富行为的领域对象通常手写更清楚。
Q5:什么时候该用 __slots__?
A:当你有大量(十万级以上)同类实例,且属性集合固定、不需要动态添加属性、不需要 __dict__ 时。典型如几何点、图算法的节点、解析出的数据行。一般业务对象用它收益有限,反而牺牲了灵活性。用之前先 sys.getsizeof 实测,不要凭感觉优化。
相关笔记
- Python-03-函数与模块 —— 理解
self的本质需要先掌握参数传递与作用域规则 - Python-05-异常与文件IO ——
__enter__/__exit__是魔术方法在资源管理上的应用 - Python-07-进阶特性 —— 装饰器、迭代器、生成器与类型注解,和本节紧密衔接
- Python-02-内置数据结构 —— 组合优于继承的实践,很大程度是「用内置容器装数据」
- CSharp-02-面向对象 —— 对比名义子类型(接口/继承)与 Python 的鸭子类型
参考来源
- Python 官方教程 · 类:https://docs.python.org/3/tutorial/classes.html
- Python 数据模型(魔术方法、MRO、
__hash__规则):https://docs.python.org/3/reference/datamodel.html dataclasses模块文档:https://docs.python.org/3/library/dataclasses.htmlabc模块文档:https://docs.python.org/3/library/abc.html- 描述符指南(理解
@property的实现机制):https://docs.python.org/3/howto/descriptor.html - PEP 8 · 命名约定(下划线约定、name mangling):https://peps.python.org/pep-0008/
- PEP 557 · Data Classes:https://peps.python.org/pep-0557/
- PEP 3119 · Introducing Abstract Base Classes:https://peps.python.org/pep-3119/
- PEP 3135 · New Super:https://peps.python.org/pep-3135/
- PEP 544 · Protocols(结构子类型):https://peps.python.org/pep-0544/
版本提示
dataclass的slots=True、kw_only=True需要 Python 3.10+;@dataclass本身自 Python 3.7 起可用。X | Y类型写法需要 3.10+。具体行为与新增参数以官方最新文档为准:https://docs.python.org/3/library/dataclasses.html