继承与字符串表示

0. 本讲导读

上一讲你已经会写类了：class 语句造出一个类对象，调用类会走 __init__ 造出一个实例，self.x = ... 往实例上挂实例属性（instance attribute），写在 class 体里的赋值挂出类属性（class attribute），点表达式 obj.attr 先查实例再查类。

但只要你真的拿这套东西去建模一个稍微像样的系统，马上会撞上一堵墙。这一讲的幻灯片从一个很具体的场景切入：做一个 Spotify。你会需要 User、Artist、Song、Playlist、Album 这几个类。写着写着你会发现两件很别扭的事：

• Album 和 Playlist 的 play 方法一个字都不差——都是「把里面的歌一首首放出来」。你把同一段代码抄了两遍。
• Artist 和 User 也有一堆共同的东西：都有 name，都能被关注，都有播放列表。你又抄了一遍。

抄代码的代价不是「打字累」，而是改一处要记得改两处。哪天 play 要加一行「记录播放次数」，你改了 Playlist 忘了改 Album，bug 就埋下了。更深层的问题是：Album 和 Playlist 之间那个「专辑就是一种播放列表」的关系，在代码里完全没有被表达出来。你心里知道，Python 不知道。

本讲补上的第一样东西是继承（inheritance）：一种在语言层面表达「A 是一种 B」的手段。写出 class Album(Playlist): 之后，Album 不需要重写 play，它白拿 Playlist 的 play。这不是「复制一份过来」，而是属性查找时多走一步——上一讲那条「先查实例，再查类」的规则，本讲要正式扩写成「先查实例，再查类，再沿着继承链一层层往上查」。所以这一讲的核心仍然是老问题：一个名字是怎么被查到的。

本讲补上的第二样东西是字符串表示（string representation）。你自己写的对象，直接 print 出来是 <__main__.Account object at 0x7f...> 这种鬼东西。一个好的对象应该表现得像它所代表的那种数据——分数应该能打印成 1/2，歌应该能打印成 All Too Well by Taylor Swift (5:27)。Python 给每个对象规定了两种字符串表示（str 给人看、repr 给解释器看），并且提供了 __str__ / __repr__ 两个特殊方法（special method）让你接管它们。

这两块内容合在一起，正好构成本讲最后那个练习：重构（refactor）上一讲的 Spotify 代码——用继承消掉重复，用 __str__ 让每个对象会自我介绍。往后看，Lab 06 全是继承题，Project Ants 里几乎每一种蚂蚁都是 Ant 的子类，Bee、Insect 之间的继承层次是整个项目的骨架。这一讲的属性查找规则不熟，Ants 会寸步难行。

1. 动机：Spotify 代码里那些抄了两遍的东西

先把问题摆到台面上。上一讲的课堂练习是给 Spotify 设计一组类，头脑风暴的结果大致是这样：

如果只用上一讲的工具（class、__init__、实例属性、方法），你写出来的 Playlist 和 Album 会长成这样：

class Playlist:
    def __init__(self, name, songs, owner):
        self.name = name
        self.songs = songs
        self.owner = owner
        self.total_duration_sec = sum([s.duration_sec for s in songs])
        self.owner.playlists.append(self)

    def play(self):
        for song in self.songs:
            song.play()


class Album:                      # 没有继承，什么都得自己写
    def __init__(self, name, songs, artist):
        self.name = name
        self.songs = songs
        self.owner = artist
        self.total_duration_sec = sum([s.duration_sec for s in songs])
        self.owner.playlists.append(self)
        self.owner.albums.append(self)

    def play(self):               # ←←← 和 Playlist.play 一模一样
        for song in self.songs:
            song.play()

两个 play 完全相同，两个 __init__ 有五行里的四行相同。这就是幻灯片里说的「a lot of repeated code」。

注意「Album 是一种 Playlist」这个判断里藏着一层意思：Album 能做的事，Playlist 全都能做；Album 只是多了一点东西、或者把某件事做得不太一样。专辑比歌单多的是「它会被登记到歌手的 albums 列表里」，不一样的是「所有者被限定成 Artist」。除此之外它就是个歌单。这种「基本一样、稍有不同」正是继承要处理的情形。

反过来说，如果两个类只是碰巧有几个同名方法，但概念上毫无从属关系（比如 Song 和 Advertisement 都有 play），硬要给它们造一个共同父类往往是过度设计。继承首先是一个建模决定，其次才是一个省代码手段。

2. 继承：is-a 关系与子类的定义

继承（inheritance）描述子类（subclass，又叫 child class）与基类（base class，又叫 parent class / superclass）之间的一种 is-a 关系。

子类继承基类的属性和方法——「继承」在这里的准确含义是：子类的实例能访问、能使用基类里定义的那些名字。一个 Playlist 可以被 play，所以一个 Album 也可以被 play，哪怕 Album 自己一个字都没写。

语法

定义子类只需要在类名后面加一对括号，里面写基类名：

class 子类名(基类名):
    <类体>

本讲的运行例子是账户。先看基类 Account：

class Account:
    interest = 0.02                      # 类属性：所有账户共享的默认利率

    def __init__(self, account_holder):
        self.balance = 0
        self.holder = account_holder

    def deposit(self, amount):
        self.balance = self.balance + amount
        return self.balance

    def withdraw(self, amount):
        if amount > self.balance:
            return 'Insufficient funds'
        self.balance = self.balance - amount
        return self.balance

这里没有任何新东西，全是上一讲的内容：interest 是类属性（写在类体里、不带 self.），balance 和 holder 是实例属性（在 __init__ 里用 self. 挂上去）。

现在定义支票账户。它跟普通账户几乎一样，只有两点不同：取款要收 1 元手续费，利率低一些（0.01）。

class CheckingAccount(Account):
    withdraw_charge = 1
    interest = 0.01

    def withdraw(self, amount):
        return Account.withdraw(self, amount + self.withdraw_charge)

请数一下这个类没有写什么：没有 __init__、没有 deposit。但下面这些全都能跑：

>>> emma = CheckingAccount('Emma')     # 用的是 Account.__init__
>>> emma.balance
0
>>> emma.holder
'Emma'
>>> emma.deposit(100)                  # 用的是 Account.deposit
100

这就是继承在做的事。CheckingAccount 里查不到 __init__，Python 就去它的基类 Account 里查，查到了就用。

重写（override）

CheckingAccount 自己定义了一个 withdraw，而 Account 里也有一个 withdraw。这时对 emma.withdraw 的查找会在 CheckingAccount 这一层就命中，根本走不到 Account。子类的定义「挡住」了基类的同名定义，这叫重写（override，也译作覆盖）。

类属性同理：Account.interest 是 0.02，但 CheckingAccount.interest 是 0.01，后者重写了前者。

3. 一次 withdraw 调用里到底发生了什么

这一节把幻灯片上那段交互记录逐步拆开。这是本讲最该慢下来看的一段。

>>> sriya = Account('Sriya')
>>> sriya.deposit(100)
100
>>> sriya.withdraw(50)
50
>>> emma = CheckingAccount('Emma')
>>> emma.deposit(100)
100
>>> emma.withdraw(50)
49

前四行没什么可说的：sriya 是普通账户，存 100 取 50 剩 50。关键在最后一行——为什么是 49 而不是 50。

把两帧画出来，注意两帧里的 self 是同一个对象——这是理解继承的关键：整个过程只有一个 emma，没有「父类那一半」和「子类那一半」之分。

Global frame
    Account         ──→ class Account
    CheckingAccount ──→ class CheckingAccount   [base: Account]
    sriya           ──→ Account instance #1
    emma            ──→ CheckingAccount instance #2

class Account                       class CheckingAccount(Account)
    interest        0.02                withdraw_charge  1
    __init__        func                interest         0.01
    deposit         func                withdraw         func
    withdraw        func

Account instance #1                 CheckingAccount instance #2
    balance   50                        balance   49      ← 被 f2 改掉
    holder    'Sriya'                   holder    'Emma'
                                        （实例上没有 withdraw / interest）

f1: CheckingAccount.withdraw   [parent=Global]
    self    ──→ instance #2
    amount  50
    正在算  Account.withdraw(self, 50 + 1)

f2: Account.withdraw           [parent=Global]
    self    ──→ instance #2      ← 和 f1 里的 self 指向同一个对象
    amount  51
    返回值  49

class CheckingAccount(Account):
    withdraw_charge = 1
    def withdraw(self, amount):
        return amount            # 完全不碰基类

NameError: name 'withdraw_charge' is not defined

为什么第 6 步一定要写 self.withdraw_charge 而不是 CheckingAccount.withdraw_charge？

在目前这段代码里，两种写法结果都是 1。但它们的含义不同，而且差别马上就会显现：

• CheckingAccount.withdraw_charge：写死去 CheckingAccount 这个类上取。
• self.withdraw_charge：从当前这个对象出发往上查。如果实例上有自己的 withdraw_charge（比如第 5 节里手续费 0.5 的那个账户），就用实例的；如果哪天又有个 CheckingAccount 的子类把手续费改成 3，用 self. 写的这段代码不用改一个字就能正确收 3 块。

这就是所谓的动态查找（dynamic lookup）：方法体里写 self.x，具体取到哪个 x 要到运行时、看 self 究竟是谁才知道。这是继承体系里绝大多数灵活性的来源。默认就该写 self.，除非你确实想要「无论如何都用这个类上的那个值」。

4. 两种调用基类的写法：Account.withdraw(self, …) 与 super()

幻灯片把同一个 CheckingAccount.withdraw 写了两遍，这不是重复，是在对比两种等价写法。

class CheckingAccount(Account):
    withdraw_charge = 1
    interest = 0.01

    def withdraw(self, amount):
        return Account.withdraw(self, amount + self.withdraw_charge)

写法二用内建函数 super()：

class CheckingAccount(Account):
    withdraw_charge = 1
    interest = 0.01

    def withdraw(self, amount):
        return super().withdraw(amount + self.withdraw_charge)

super() 的含义是：「从我的超类开始查这个名字，并且把当前的 self 自动补上」。所以 super().withdraw(51) 拿到的是一个已经绑定好 self 的方法，你不能再手写一遍 self。

为什么 super() 更受推荐？因为它把「我的父亲是谁」这个信息只写一遍——写在 class CheckingAccount(Account): 那一行。哪天你把继承关系改成 class CheckingAccount(SavingsAccount):，用 super() 的代码自动跟着变；用类名硬写的代码则会悄悄地继续调用 Account，而且不报错——这是最难查的那类 bug。

CS 61A 的作业和考试两种写法都会出现，Ants 项目的框架代码里 super() 用得很多，所以两种都必须认得。

def withdraw(self, amount):
    return super().withdraw(self, amount + self.withdraw_charge)   # ✗

TypeError: Account.withdraw() takes 2 positional arguments but 3 were given

def withdraw(self, amount):
    return Account.withdraw(amount + self.withdraw_charge)         # ✗

TypeError: Account.withdraw() missing 1 required positional argument: 'amount'

emma.withdraw(50)            # 左边是实例 → self=emma 自动
CheckingAccount.withdraw(emma, 50)   # 左边是类 → self 手写
super().withdraw(51)         # super() 特殊：查找从超类开始，但 self 仍自动

5. 在子类里重写 __init__

到目前为止 CheckingAccount 借用了基类的 __init__。但如果子类需要多存一点东西，或者想让调用者多传一个参数，就得自己写 __init__。

需求：允许开户时指定手续费，不指定就用默认的 1。

class CheckingAccount(Account):
    withdraw_charge = 1
    interest = 0.01

    def __init__(self, holder, withdraw_charge=None):
        super().__init__(holder)
        if withdraw_charge:
            self.withdraw_charge = withdraw_charge
        else:
            self.withdraw_charge = CheckingAccount.withdraw_charge

    def withdraw(self, amount):
        return super().withdraw(amount + self.withdraw_charge)

>>> emma = CheckingAccount('Emma')
>>> emma.withdraw_charge
1
>>> amy = CheckingAccount('Amy', 0.5)
>>> amy.withdraw_charge
0.5
>>> amy.deposit(100)
100
>>> amy.withdraw(50)
49.5

class CheckingAccount(Account)
    withdraw_charge  1          ← 类属性，一份
    interest         0.01
    __init__ / withdraw  func

emma （没传手续费）              amy （传了 0.5）
    balance          0              balance          49.5
    holder           'Emma'         holder           'Amy'
    withdraw_charge  1              withdraw_charge  0.5
                     ↑                               ↑
        else 分支写上去的实例属性，        if 分支写上去的实例属性，
        值恰好等于类属性，但是            值来自调用者
        实例上确实存了一份

注意 else 分支：self.withdraw_charge = CheckingAccount.withdraw_charge 把类属性的值抄了一份到实例上。这一句其实可以不写——不写的话 emma.withdraw_charge 照样能通过类属性查到 1。幻灯片这样写是为了让「每个账户都有自己的手续费」这件事在实例层面统一、显式。代价是：以后改 CheckingAccount.withdraw_charge = 2，已经开出去的账户不会跟着变，因为它们实例上已经存了自己的一份。这是一个有意的设计取舍，不是 bug。

class Artist(User):
    def __init__(self, name):
        self.albums = []          # ✗ 忘了 super().__init__(name)

>>> a = Artist('Taylor Swift')
>>> a.name
AttributeError: 'Artist' object has no attribute 'name'

>>> free = CheckingAccount('Free', 0)
>>> free.withdraw_charge
1

6. 点表达式求值的完整规则

上一讲给过一个简化版规则（先查实例、再查类）。有了继承之后，规则要补上「再往上」这一步。这是本讲唯一需要背下来的东西，而且考试年年考。

把它拆成人话，一条一条对着念：

用这条规则把前面所有结果重新验算一遍：

最后一行的真实报错分两种，取决于点号左边是什么：

>>> emma.rate
AttributeError: 'CheckingAccount' object has no attribute 'rate'

>>> CheckingAccount.rate
AttributeError: type object 'CheckingAccount' has no attribute 'rate'

两句话的差别是 'CheckingAccount' object 和 type object 'CheckingAccount'。读到 type object，说明你点的是类不是实例——这条信息在调试时很有用，比如你本想写 emma.balance 却手滑写成了 CheckingAccount.balance。

为什么 2b 里说「或者第 1 步得到的本来就是个类」

因为类没有「实例属性」这一说，直接从 2b 起步。这也解释了一个初学者常问的问题：为什么 Account.balance 会报错，而 sriya.balance 好好的？因为 balance 是在 __init__ 里用 self.balance = 0 挂到某个具体实例上的，类身上从来就没有过这个名字。

>>> emma.interest            # 查找：一路走到 CheckingAccount，得 0.01
0.01
>>> emma.interest = 0.08     # 赋值：直接在 emma 这个实例上创建一个新属性
>>> emma.interest
0.08
>>> CheckingAccount.interest # 类属性纹丝不动
0.01

7. 类属性、实例属性与继承的相互作用

上一讲你已经知道「类属性只有一份、被所有实例共享」。加上继承之后，「一份」这个说法要说得更精确：一份属于定义它的那个类。子类重写了就是子类自己新的一份，子类没重写就共用基类那一份。

下面这段交互把四种情况全试了一遍，输出是真实跑出来的：

>>> a = Account('A')
>>> b = Account('B')
>>> emma = CheckingAccount('Emma')
>>> a.interest, b.interest, emma.interest
(0.02, 0.02, 0.01)

>>> Account.interest = 0.05          # ① 改基类的类属性
>>> a.interest, b.interest
(0.05, 0.05)
>>> emma.interest                    # CheckingAccount 有自己的，不受影响
0.01

>>> a.interest = 0.08                # ② 给某个实例赋值
>>> a.interest, b.interest, Account.interest
(0.08, 0.05, 0.05)

可以直接看实例的属性字典来确认第 3 步真的往 a 身上加了东西：

>>> a.__dict__
{'balance': 0, 'holder': 'A', 'interest': 0.08}
>>> b.__dict__
{'balance': 0, 'holder': 'B'}

class Playlist:
    songs = []          # ✗ 类属性列表，所有实例共用同一个列表！

    def add(self, song):
        self.songs.append(song)     # 没有赋值，只是修改那个共享列表

8. 组合：has-a 关系，以及 type() 与 isinstance()

组合（composition）描述两个类之间的 has-a 关系：一个银行有很多账户；一门课有很多学生；一个歌单有很多首歌。

组合在语法上没有任何新东西——就是把别的对象存进实例属性里。它值得单独讲，是因为初学者太容易在该用组合的地方用继承。

class Bank:
    def __init__(self):
        self.accounts = []

    def open_account(self, holder, kind=Account):
        account = kind(holder)
        self.accounts.append(account)
        return account

    def pay_interest(self):
        for account in self.accounts:
            account.deposit(account.balance * account.interest)

>>> bank = Bank()
>>> sriya = bank.open_account('Sriya')
>>> emma = bank.open_account('Emma', CheckingAccount)
>>> sriya.deposit(100)
100
>>> emma.deposit(100)
100
>>> bank.pay_interest()
>>> sriya.balance
102.0
>>> emma.balance
101.0

pay_interest 只有两行，却能对两种不同的账户做正确的事——因为它从头到尾没有问过「你是哪一类账户」，只是写 account.interest，让属性查找规则去决定取到哪个值。这种「同一段代码，对不同类型的对象各自做对的事」叫多态（polymorphism），是继承最主要的收益。

type() vs isinstance()

有了继承，「这个对象是什么类型」就有了两种答案，Python 用两个不同的函数分别回答：

>>> type(sriya)
<class 'Account'>
>>> type(emma)
<class 'CheckingAccount'>
>>> isinstance(sriya, Account)
True
>>> isinstance(emma, Account)
True
>>> isinstance(sriya, CheckingAccount)
False
>>> isinstance(emma, CheckingAccount)
True

注意其中最关键的一行：isinstance(emma, Account) 是 True。这正是 is-a 关系在语言层面的体现——一个支票账户就是一个账户。而 type(emma) 只回答「它恰好是哪个类造出来的」，是 CheckingAccount，不是 Account。

def count_accounts(self):
    return len([a for a in self.accounts if type(a) == Account])     # 漏掉子类

9. 字符串表示：str 与 repr

换一个话题，但动机是同一个：一个对象应该表现得像它所代表的那种数据。你造了一个 Rational 类来表示分数，那它至少应该能被打印成 1/2，而不是：

>>> print(sriya)
<__main__.Account object at 0x7f2c1a3d5f70>

这行默认输出里唯一有用的信息是那串十六进制的内存地址——它能告诉你「两次打印出来的是不是同一个对象」，除此以外毫无价值。

Python 的做法是：每个对象都有两种字符串表示，用途不同。

repr：给解释器看的那一份

repr 函数返回一个字符串，按惯例这个字符串应当是一个 Python 表达式，把它求值回来能得到一个相等的对象。对大多数类型来说：

eval(repr(obj)) == obj

eval 是一个内建函数，接受一个字符串，把它当成 Python 表达式来求值。所以 repr 相当于「把对象序列化成源代码」。

更常用的一个事实是：你在交互式解释器里输入一个表达式，回显出来的那行就是它的 repr。

>>> 3e5
300000.0
>>> print(repr(3e5))
300000.0

这两行输出一样，说明提示符回显走的就是 repr。字符串的例子对比更明显：

>>> s = 'hello'
>>> s
'hello'
>>> print(s)
hello

直接输入 s，回显的是带引号的 'hello'——因为 'hello' 才是一个能求值回这个字符串的 Python 表达式。而 print(s) 用的是 str，给人看的当然不带引号。这就是你写 doctest 时「什么时候要打引号」的全部依据：doctest 比对的是解释器回显，也就是 repr。

不是所有对象都有「能求值回来」的表示。这时 repr 退而求其次，给一个带尖括号的描述：

>>> repr(min)
'<built-in function min>'

注意 repr 的返回值是一个字符串，所以在提示符下它自己又被 repr 了一次，于是外面多了一层单引号。<built-in function min> 显然不是合法的 Python 表达式——惯例就是惯例，做不到时按惯例用尖括号包一个描述。你在开头看到的 <__main__.Account object at 0x...> 正是这种「做不到」的默认形式。

str：给人看的那一份

str 的结果就是 print 打出来的东西，也是 f-string 插值时用的东西。标准库里的 Fraction 把两者区分得很典型：

>>> from fractions import Fraction
>>> frac = Fraction(1, 2)
>>> repr(frac)
'Fraction(1, 2)'
>>> str(frac)
'1/2'
>>> print(frac)
1/2
>>> f'My fraction is {frac}'
'My fraction is 1/2'

逐行对照一遍：

对绝大多数类型（整数、浮点数、列表……）str 和 repr 结果相同，所以平时感觉不到区别。字符串本身和 Fraction 是两个最容易看出差别的例子。

>>> names = ['ann', 'bob']
>>> print(names)
['ann', 'bob']

10. __repr__ 与 __str__

repr(x) 和 str(x) 这两个内建函数，实际上是去找对象的特殊方法（special method） __repr__ 和 __str__ 并调用它们。你在自己的类里定义这两个方法，就接管了对象的字符串表示。

class Rational:
    def __init__(self, numer, denom):
        self.numer = numer
        self.denom = denom

    def __repr__(self):
        return f'Rational({self.numer}, {self.denom})'

    def __str__(self):
        return f'{self.numer}/{self.denom}'

>>> rat = Rational(1, 2)
>>> repr(rat)
'Rational(1, 2)'
>>> str(rat)
'1/2'
>>> rat                      # 提示符回显 → __repr__
Rational(1, 2)
>>> print(rat)               # print → __str__
1/2
>>> [rat, rat]               # 容器里的元素 → __repr__
[Rational(1, 2), Rational(1, 2)]

只写一个的话，写哪个？

两者之间有一条单向的兜底规则：

兜底是单向的：str 找不到 __str__ 会退回去用 __repr__；反过来 repr 绝不会用 __str__。所以如果只写一个，写 __repr__——它一份顶两份，而且能让对象在列表里、在调试输出里都好看。

这条兜底规则不是特例，用第 6 节的属性查找就能解释：str(x) 去查 x 的 __str__，实例没有、类没有、超类……一路查到所有类的共同祖先 object，而 object.__str__ 的实现恰好就是「调用 self.__repr__()」。兜底本身就是一次继承。同理，你没写 __repr__ 时用到的 object.__repr__ 就是那个打印内存地址的实现。

def __str__(self):
    print(f'{self.numer}/{self.denom}')     # ✗

>>> print(rat)
1/2
TypeError: __str__ returned non-string (type NoneType)

def __repr__(self):
    return f'Account({self.holder})'        # 得到 'Account(Sriya)'，eval 会 NameError
def __repr__(self):
    return f'Account({self.holder!r})'      # 得到 "Account('Sriya')"  ✓

11. 实战：用继承重构 Spotify

重构（refactoring）是「在不改变外部行为的前提下重新组织已有代码」。关键词是「不改变外部行为」——重构之后所有 doctest 必须照样通过，改的只是代码的组织方式。

这次要做两件事：Artist 继承 User、Album 继承 Playlist，并且给各个类加上 __str__。起始代码是课程网站 Lecture 14 下的 14.py，用 python3 -m doctest 14.py 跑测试（没有输出就是全过）。

User：先把基类写对

class User:
    def __init__(self, name: str):
        self.name = name
        self.following = []
        self.followers = 0

        # NOTE: be careful, order matters!
        self.playlists = []
        self.liked_songs = Playlist('Liked Songs', [], self)

    def follow(self, user):
        self.following.append(user)
        user.followers += 1

    def __str__(self):
        return self.name

follow 这个方法值得看一眼：它同时改了两个对象。self.following.append(user) 改的是关注者的列表，user.followers += 1 改的是被关注者的计数。方法的 self 不代表「只能碰自己」——只要拿得到别的对象的引用，就能改它。

self.playlists = []
self.liked_songs = Playlist('Liked Songs', [], self)

>>> rebecca = User('Rebecca')
AttributeError: 'User' object has no attribute 'playlists'

Artist：这一节的主角

class Artist(User):
    def __init__(self, name: str):
        super().__init__(name)
        self.albums = []

整个类只有三行。Artist 比 User 多的只有一个 albums 列表，其余全部继承：name、following、followers、playlists、liked_songs、follow、__str__，一个都不用重写。doctest 里这几行因此自动成立：

>>> taylor = Artist('Taylor Swift')
>>> taylor.followers
0
>>> len(taylor.playlists)
1
>>> taylor.liked_songs is taylor.playlists[0]
True
>>> str(taylor)
'Taylor Swift'

str(taylor) 走的是继承来的 User.__str__，返回 self.name。这就是第 10 节说的「基类的字符串表示要写得对子类也成立」——return self.name 没有写死任何类名，所以对 Artist 一样正确。

还有一个细节：super().__init__(name) 必须在 self.albums = [] 之前吗？在这个例子里两种顺序都能跑。但把 super().__init__() 放第一行是强烈推荐的习惯：基类初始化过程中可能会调用别的方法（比如这里会去造 Playlist），而那些方法可能依赖对象已经处于「基类那部分已就绪」的状态。

Song：__str__ 的实战

class Song:
    def __init__(self, name: str, artist: Artist, duration_sec: int):
        self.name = name
        self.artist = artist
        self.duration_sec = duration_sec

    def __str__(self):
        minutes = self.duration_sec // 60
        seconds = self.duration_sec % 60
        return f'{self.name} by {self.artist} ({minutes}:{seconds})'

    def play(self):
        print(self)

两处需要停下来看：

第一处：f'... by {self.artist} ...'。self.artist 是一个 Artist 对象，不是字符串。f-string 插值时会对它调用 str，于是走到 User.__str__，得到 'Taylor Swift'。这就是给 User 写 __str__ 的回报：这里不用写 self.artist.name，写 self.artist 就够了。（写 .name 也对，但那样 Song 就必须知道 Artist 内部有个叫 name 的属性，抽象屏障被捅破了一点。）

第二处：def play(self): print(self)。print(self) 会对 self 调用 str，也就是这个类自己的 __str__。所以 play 就一行，因为 __str__ 已经把「一首歌该怎么显示」这件事说清楚了。方法体里出现 print(self) 是「我已经写好 __str__」的典型信号。

>>> str(Song('X', taylor, 305))
'X by Taylor Swift (5:5)'          # 本该是 5:05

Playlist 与 Album

class Playlist:
    def __init__(self, name: str, songs: list[Song], owner: User):
        self.name = name
        self.songs = songs
        self.owner = owner
        self.total_duration_sec = sum([song.duration_sec for song in self.songs])
        self.owner.playlists.append(self)

    def play(self):
        for song in self.songs:
            song.play()


class Album(Playlist):
    def __init__(self, name: str, songs: list[Song], artist: Artist):
        super().__init__(name, songs, artist)
        self.owner.albums.append(self)

Album 也只有两行。play 一个字都不用写——重构前抄了两遍的那段代码，现在只剩一份。这就是本讲开头那个动机的兑现。

三个细节：

• super().__init__(name, songs, artist) 把 artist 传给了基类的 owner 形参。形参名不需要一致，位置对上就行。Album 把它叫 artist 是为了在签名上表达「专辑的所有者必须是歌手」。
• 第二行写的是 self.owner.albums.append(self) 而不是 artist.albums.append(self)。两者在这里等价，但用 self.owner 更稳——它读的是对象当前的真实状态，万一基类的 __init__ 对 owner 做了什么处理，也不会读到过时的值。
• 一张专辑会被登记两次：基类那行把它 append 进 artist.playlists，子类这行又 append 进 artist.albums。这是有意的——专辑是歌单，理应出现在歌单列表里；同时它又是专辑，所以另有一份索引。这正是 is-a 关系在数据上的体现。

class User                        class Playlist
    __init__  follow  __str__         __init__  play
        ↑                                 ↑
        │ base                            │ base
        │                                 │
class Artist(User)                class Album(Playlist)
    __init__（只加 albums）           __init__（只加 albums 登记）
    follow    ← 继承                  play      ← 继承
    __str__   ← 继承

taylor : Artist                   red : Album
    name       'Taylor Swift'         name              'Red'
    following  []                     songs             [all_too_well, trouble]
    followers  0                      owner        ─────→ taylor
    playlists  [liked_songs, red] ←──── 被 Playlist.__init__ 登记
    albums     [red]              ←──── 被 Album.__init__ 登记
    liked_songs ──→ Playlist('Liked Songs', [], taylor)

把 14.py 补完后跑 python3 -m doctest 14.py：没有任何输出就是 50 条 doctest 全部通过。加 -v 可以看到详细统计。

本讲小结

一页纸的求值规则

1. 求 <expr>
2. 若结果是实例 → 查实例自己的属性 ── 命中 → 返回（函数则绑定成方法）
                          │未命中
                          ↓
   查该实例所属的类 ─────────── 命中 → 返回
   （若第 1 步结果本就是类，从这里开始）
                          │未命中
                          ↓
   查超类，重复上一步 ─────────── 命中 → 返回
                          │一直没有超类了
                          ↓
                  AttributeError

赋值 <expr>.<name> = v ：不查找、不上溯，直接绑在 <expr> 求出的那个对象上。

动手练习

五道题，都能在本机用 python3 验证。先自己推，再展开答案。

练习 1：查找路径

class A:
    x = 1
    def f(self):
        return self.x

class B(A):
    x = 2

class C(B):
    def f(self):
        return super().f() + 10

c = C()

c.f() 的值是多少？A().f() 呢？如果再执行 c.x = 100，c.f() 又是多少？

练习 2：忘了 super

class Animal:
    def __init__(self, name):
        self.name = name
        self.legs = 4

class Bird(Animal):
    def __init__(self, name):
        self.legs = 2

b = Bird('Tweety')

创建 b 会报错吗？b.legs 是多少？b.name 呢？怎么改？

AttributeError: 'Bird' object has no attribute 'name'

class Bird(Animal):
    def __init__(self, name):
        super().__init__(name)     # 先把基类那套跑完（name=..., legs=4）
        self.legs = 2              # 再覆盖成 2

练习 3：共享的列表

class Team:
    members = []
    def add(self, name):
        self.members.append(name)

a, b = Team(), Team()
a.add('ann')
b.add('bob')

a.members 是什么？如果把 add 改成 self.members = self.members + [name]，结果又是什么？

class Team:
    def __init__(self):
        self.members = []
    def add(self, name):
        self.members.append(name)

练习 4：str 与 repr

class Point:
    def __init__(self, x, y):
        self.x, self.y = x, y
    def __repr__(self):
        return f'Point({self.x}, {self.y})'

p = Point(1, 2)

下面五行分别输出什么？

>>> p
>>> print(p)
>>> str(p)
>>> [p]
>>> f'{p}'

再问：如果把 __repr__ 改名成 __str__，这五行又分别输出什么？

>>> p
Point(1, 2)
>>> print(p)
Point(1, 2)
>>> str(p)
'Point(1, 2)'
>>> [p]
[Point(1, 2)]
>>> f'{p}'
'Point(1, 2)'

>>> p
<__main__.Point object at 0x7f...>
>>> print(p)
Point(1, 2)
>>> str(p)
'Point(1, 2)'
>>> [p]
[<__main__.Point object at 0x7f...>]
>>> f'{p}'
'Point(1, 2)'

练习 5：把 Album 的 __str__ 写出来

给第 11 节的 Playlist 加一个 __str__，让它满足：

>>> str(love_songs)
'Love Songs by Rebecca (3 songs)'
>>> str(red)
'Red by Taylor Swift (2 songs)'

要求：Album 一个字都不用写。想清楚为什么可以做到，以及 {self.owner} 这一处插值背后连锁调用了几个 __str__。

class Playlist:
    # ... __init__ 和 play 不变 ...

    def __str__(self):
        return f'{self.name} by {self.owner} ({len(self.songs)} songs)'

class Album(Playlist):
    def __str__(self):
        return super().__str__() + ' [ALBUM]'