w wyl123ly 的博客
MD

Python-04-面向对象

45 KB 2026.10.11 原文件

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, ...)初始化已有实例必须返回 None99% 的情况只需要写这个

常见错误

__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 线性化算法计算,保证三条性质:

  1. 子类一定排在父类之前;
  2. 多个父类的相对顺序保持一致(按 class C(A, B) 中书写的顺序);
  3. 任意类的 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__继承 objecteq=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 + @abstractmethodShape.area实例化时(运行期)强制子类实现,并明确报出缺哪些方法
@dataclass(frozen=True)Circle、Rect免写 __init__/__repr__/__eq__,并保证不可变
__post_init__校验半径在自动生成的 __init__ 之后插入校验
__lt__sorted(group)让自定义对象支持排序
__len__/__iter__/__getitem__Composite让自定义容器能用 len()、for、下标
@propertytotal_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") 会真的去调用 property getter。如果 getter 抛 AttributeError,hasattr 返回 False;如果抛别的异常,会直接向上冒泡。在 __getattr__ 里写 hasattr(self, ...) 极易造成无限递归。

实践建议

- 字段多、以数据为主 → 用 @dataclass;有复杂不变量与行为 → 手写类。

- 需要「值语义」(相等即相等)→ frozen=True + 自动 __hash__。

- 需要「身份语义」(每个对象唯一)→ eq=False。

- 继承层次尽量不超过两层;跨模块复用功能优先用 mixin + 组合。

- 用 mypy 或 pyright 做静态检查,能让 Protocol 的价值真正兑现。


六、练习题

  1. 基础题:定义一个 Vector2D 类,支持 +、-、==、abs()(返回模长 )、repr()。要求实现 __add__、__sub__、__eq__、__abs__、__repr__,并说明为什么还要(或不要)实现 __hash__。
  1. 基础题:写一个 Student 类,用 @dataclass 定义 name、scores: list[int],加一个只读 @property average。要求:(a) 每个实例的 scores 互相独立;(b) Student 可以放进 set(思考需要什么条件)。
  1. 进阶题:实现一个 Matrix 类,内部用组合持有一个 list[list[float]],支持 __getitem__((i, j)) 取元素、__len__ 返回行数、__matmul__ 实现矩阵乘法。写出矩阵乘法的复杂度 (方阵情形),并解释为什么写成 i, k, j 三层循环比 i, j, k 更快(提示:缓存局部性)。
  1. 进阶题:下列关于 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"。

  1. 思考题:「组合优于继承」在什么情况下不成立?举一个应该用继承的例子,并说明判断标准(提示:里氏替换原则、是否需要被当作父类使用、是否需要多态分派)。

七、常见问题(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.html
  • abc 模块文档: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