对象与属性：把「数据」和「行为」装进同一个东西里

0. 本讲导读

期中考试之前，你已经会两种「把一堆值包成一个整体」的办法：一是直接用列表、元组这样的内置容器，二是自己写抽象数据类型（abstract data type, ADT）——写一个 make_xxx 构造器（constructor）和几个 xxx_yyy 选择器（selector），约定好「只准通过这几个函数碰数据」。

ADT 这套办法很优雅，但它有一个根本的脆弱之处：那道抽象屏障（abstraction barrier）只是一句口头约定，Python 根本不知道它的存在。 你写 make_account('Spock') 返回一个二元列表 [0, 'Spock']，别人拿到之后直接写 acc[1] 也照样能跑。Python 不会拦你，因为在 Python 眼里那就是个普通列表。

本讲引入的面向对象编程（object-oriented programming, OOP）要解决的正是这件事。它提供的不是一个新的算法技巧，而是一种新的组织程序的方式：把「一个东西有哪些数据」和「一个东西能做哪些事」绑在一起，形成一个可以被 Python 本身识别、检查、传递的实体。

从「求值过程」的角度看，本讲实际上只加了一条新的求值规则：点表达式（dot expression）<表达式>.<名字> 该怎么求值。 这条规则看起来只有三步，但它牵扯到实例属性、类属性、绑定方法三种情况，而且属性读取和属性赋值走的是完全不同的两条路。绝大多数 OOP 的坑都长在这条规则上，所以本讲会把它拆得非常细。

往前看：这一讲是 Composing Programs §2.5 的开头，衔接的是第 10~11 讲的可变数据与数据抽象。往后看：下一讲讲继承（inheritance）与 __repr__/__str__，那些内容全都建立在本讲的属性查找规则之上；Lab 06 和大项目 Ants 几乎全部是类的编写，本讲的每一个细节到时候都会用到。

1. 为什么需要 OOP：ADT 撑不住了

先老老实实回答一个问题：ADT 到底哪里不够用？幻灯片列了四条，每一条都值得展开，因为它们直接决定了类的设计长什么样。

软肋一：不改变抽象屏障就没法可变

ADT 只给你两种工具：构造器和选择器。构造器造一个新的出来，选择器从里面取一个部件出来。没有「改」这个动作。 假设你用列表实现一个账户：

def make_account(holder):
    return [0, holder]          # 构造器

def account_balance(account):   # 选择器
    return account[0]

def account_holder(account):    # 选择器
    return account[1]

现在要往账户里存钱。你只能写 account[0] = account[0] + 100——这行代码直接摸了下标 0，它绕过了选择器，等于亲手把自己刚立的规矩踩了。你当然可以再加一个 set_account_balance(account, v) 变异器（mutator），但 ADT 的经典形式里并没有这一层，而且每加一个可变的字段就要再写一个函数，很快就散架了。

软肋二：抽象屏障是约定，不是屏障

这是最要命的一条。看这段：

>>> acc = make_account('Spock')
>>> account_holder(acc)     # 规矩内的写法
'Spock'
>>> acc[1]                  # 违规写法——但它跑得一样好
'Spock'

acc[1] 不会报错，因为 acc 在 Python 眼里就是一个普通的 list。屏障存在于你的脑子里和注释里，不存在于解释器里。等到有一天你决定把内部表示从列表改成字典，所有写 acc[1] 的代码全部崩掉，而你根本无从知道有多少处这么写过。

软肋三：没有正式的类型检查手段

给你一个值，怎么判断它「是不是一个账户」？用 ADT 你办不到：

>>> acc = make_account('Spock')
>>> shopping = [0, 'milk']
>>> type(acc) == type(shopping)
True

账户和购物清单在 Python 看来是同一个类型，都是 list。你可以自己约定「第 0 位是数字、第 1 位是字符串就算账户」，但那是猜，不是判断。而用类之后，isinstance(acc, Account) 是一个 Python 层面的、确定的答案。

软肋四：数据和行为被拆散了

一个账户的「余额」在 acc[0] 里，「存钱」这个行为在一个叫 deposit 的全局函数里，「取钱」在另一个叫 withdraw 的全局函数里。它们在文件里可能相隔几百行，名字之间除了前缀之外没有任何正式关联。程序一大，你的全局命名空间里就会堆满 account_deposit、account_withdraw、course_enroll、course_drop……全是靠命名前缀勉强分组的散装函数。

OOP 给出的答案是封装（encapsulation）：把属于同一类事物的数据和行为，装进同一个名字底下。Account 这一个名字之下，既有 balance 和 holder，也有 deposit 和 withdraw。

2. 三个基本词：类、实例、方法

这三个词在后面几讲里每一页都会出现，必须先钉死。

图纸和房子的类比要用对地方。一份图纸可以盖出无数栋房子，每栋房子的门牌号、住户各不相同，但「门在哪、窗户开多大」是图纸统一规定的。同理：Account 这个类只有一份，但你可以造出成千上万个 Account 实例，每个实例有自己的 balance 和 holder；而「怎么存钱」这个行为写在类里，所有实例共用同一份代码。

你其实早就在用类了。list 是一个类，[1, 2, 3] 是它的一个实例，append 是它的一个方法：

>>> type([1, 2, 3])
<class 'list'>
>>> s = [1, 2, 3]
>>> s.append(4)      # 调用 list 类的 append 方法
>>> s
[1, 2, 3, 4]

s.append(4) 这个写法你已经用了十几讲了，本讲要做的就是把这个写法背后的机制彻底讲清楚，并且让你能自己造出这样的东西。

3. 定义一个类：Account 逐行解剖

下面是本讲的第一份完整代码，也是教材 §2.5 的经典例子。先把它整个看一遍，再逐行拆。

class Account:
    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

class Account: 这一行做了什么

它是一条语句，被执行时做两件事：先执行缩进块里的内容（于是三个 def 被执行，产生三个函数对象），然后把这些名字打包成一个类对象，最后把名字 Account 绑定到这个类对象上。

这和 def 的机制是完全平行的：def square(x): ... 执行后，全局帧里多了一个名字 square 指向一个函数对象；class Account: ... 执行后，全局帧里多了一个名字 Account 指向一个类对象。类本身就是一个值，可以赋给别的名字，可以当参数传。

Global frame
    Account ──→ class Account
                    __init__  ──→ func __init__(self, account_holder)
                    deposit   ──→ func deposit(self, amount)
                    withdraw  ──→ func withdraw(self, amount)

注意这三个函数此刻只是被定义了，一次都没被调用。它们住在类对象里面，不在全局帧里——所以你在类外面直接写 deposit(...) 会得到 NameError。

self 到底是什么

self 就是一个普通的形参名字。 它没有任何语法魔力，你把它改名叫 me、this、x，代码照样跑（我在下一节会真的演示这一点）。它之所以特殊，只是因为：

1. Python 在通过实例调用方法时，会自动把那个实例作为第一个实参传进去；
2. 整个 Python 社区一致约定这个形参叫 self。

换句话说，self 是方法体内部指代「正在被操作的那一个实例」的手段。deposit 这份代码只有一份，被一万个账户共用，它靠 self 知道「这次是给哪个账户存钱」。

UnboundLocalError: local variable 'balance' referenced before assignment

class A:
    def __init__(self, x):
        x = x          # 什么也没干成

>>> a = A(5)
>>> a.x
AttributeError: 'A' object has no attribute 'x'

三个方法各自在做什么

4. 创建实例：Account('Spock') 一步步发生了什么

这是本讲最需要慢下来看的地方。表面上你只写了一次调用，实际上 Python 做了四件事。

>>> spock_account = Account('Spock')

第 6 步是最容易搞混的一点。__init__ 的返回值被丢掉了；它的作用完全靠副作用——在传进来的那个实例上安装属性。所以 __init__ 里写 return self 是多余的，而写 return 某个别的东西 会直接报错：TypeError: __init__() should return None。

Global frame
    Account       ──→ class Account
                          __init__  ──→ func __init__(self, account_holder)
                          deposit   ──→ func deposit(self, amount)
                          withdraw  ──→ func withdraw(self, amount)
    spock_account ──┐
                    │
                    └─→ Account instance          ← 一个独立的对象
                            balance ──→ 0
                            holder  ──→ 'Spock'

f1: Account.__init__ [parent=Global]        （已返回，图上留作对照）
    self            ──→ 上面那个 Account instance
    account_holder  ──→ 'Spock'
    返回值          ──→ None

请特别注意图里的一件事：实例是一个独立于任何帧的对象，它画在帧的外面（跟函数对象、列表对象一样）。f1 这一帧执行完就消失了，但实例不会消失，因为全局帧里的 spock_account 还指着它。这正是「对象持有状态」的机制——状态活在对象里，不活在帧里。

验证：属性确实挂在实例上

>>> spock_account.balance
0
>>> spock_account.holder
'Spock'

你还可以直接把实例的属性字典打印出来（这不是课程要求的内容，但看一眼很有说服力）：

>>> spock_account.__dict__
{'balance': 0, 'holder': 'Spock'}

实例内部就是这么一张「名字 → 值」的表，跟一个帧长得很像。self.balance = 0 做的事，就是往这张表里加一条记录。

造第二个实例：两张表互不相干

>>> picard_account = Account('Picard')
>>> picard_account.balance
0
>>> spock_account.balance = 500
>>> picard_account.balance
0

每次调用 Account(...) 都会走一遍上面六步，造出一个全新的实例，配一张全新的属性表。改一个实例的 balance 完全不影响另一个。这就是「一份图纸盖出很多栋房子，每栋房子的门牌号各自独立」。

class C:
    def greet():
        return 'hi'

>>> c = C()
>>> c.greet()
TypeError: C.greet() takes 0 positional arguments but 1 was given

5. 调用方法：绑定方法与 self 的来历

接着上面的账户往下做，这是幻灯片上的完整会话：

>>> spock_account = Account('Spock')
>>> spock_account.balance
0
>>> spock_account.holder
'Spock'
>>> spock_account.deposit(100)
100
>>> spock_account.withdraw(90)
10
>>> spock_account.withdraw(90)
'Insufficient funds'
>>> picard_account = Account('Picard')
>>> picard_account.balance += 100
>>> Account.withdraw(picard_account, 75)
25

逐条追一遍。

亲眼看看绑定方法长什么样：

>>> spock_account.deposit
<bound method Account.deposit of <__main__.Account object at 0x7f3a...>>
>>> Account.deposit
<function Account.deposit at 0x7f3a...>
>>> type(spock_account.deposit)
<class 'method'>
>>> type(Account.deposit)
<class 'function'>

同一个 deposit，从实例身上取得到 method，从类身上取得到 function。区别只有一个：method 记住了一个实例，调用时自动补上第一个实参；function 什么都不记，你得自己传。

这正是最后两行在演示的东西：

>>> picard_account.balance += 100     # 直接改属性，等价于 picard_account.balance = picard_account.balance + 100
>>> Account.withdraw(picard_account, 75)
25

Account.withdraw 是一个普通函数（不是绑定方法），所以必须手动把实例作为第一个实参传进去。函数体里 self 就绑到 picard_account，amount 绑到 75。检查 75 > 100 为假，跳过 return；self.balance = 100 - 75 = 25；返回 25。

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

再确认一次：self 只是个名字

不信的话，把它改名：

class Dog:
    def __init__(banana, name):
        banana.name = name
    def bark(banana):
        return banana.name + ' says woof'

>>> d = Dog('Rex')
>>> d.bark()
'Rex says woof'

照跑不误。Python 只关心「第一个形参」这个位置，不关心它叫什么。但你在作业和考试里必须写 self——这是全世界 Python 程序员的共同约定，写别的会让人读不懂，Ants 项目的模板代码也一律用 self。

另一条常被忽略的等式：self 可以指向别的实例

方法的参数里出现的别的实例，处理方式和 self 一模一样——它们都只是普通的名字，指向普通的对象：

class Account:
    # ... 前面的方法照旧 ...
    def transfer(self, other, amount):
        """把 amount 从 self 转到 other。"""
        if amount > self.balance:
            return 'Insufficient funds'
        self.balance -= amount
        other.balance += amount
        return self.balance

a.transfer(b, 50) 里，self 是 a，other 是 b。两个实例各有各的属性表，各改各的。这个方法在两张表上分别做了一次修改，没有任何魔法。

6. 实例属性 vs 类属性

到目前为止，所有属性都是在 __init__ 里用 self.xxx = ... 挂上去的，每个实例一份。但有些数据天然属于「这一类东西整体」，而不属于某一个个体——比如「已经开过多少个账户」。这种数据应该放在类上。

幻灯片的例子给 Account 加了一个自动编号：

class Account:
    account_number = 1                      # ← 类属性，写在类定义体里

    def __init__(self, account_holder):
        self.balance = 0
        self.holder = account_holder
        self.account_number = Account.account_number   # ← 实例属性，抄一份当前编号
        Account.account_number += 1                    # ← 把类属性加 1，给下一个人留号
    ...

请先自己把下面这段的输出预测一遍，再往下看。 这段代码是本讲区分度最高的地方。

>>> kaz_account = Account('Kaz')
>>> kaz_account.account_number
1
>>> kaz_account.account_number += 10
>>> kaz_account.account_number
11
>>> Account.account_number
2
>>> inej_account = Account('Inej')
>>> inej_account.account_number
2

Global frame
    Account      ──→ class Account
                         account_number ──→ 2          ← 类属性，一份
                         __init__ ──→ func __init__(self, account_holder)
    kaz_account  ──→ Account instance
                         balance        ──→ 0
                         holder         ──→ 'Kaz'
                         account_number ──→ 11         ← 实例属性，遮住了类属性
    inej_account （尚未创建）

用一个词概括第 5 步和第 6 步：遮蔽（shadowing）。实例上一旦有了同名属性，类上那个就永远读不到了（除非你写 Account.account_number 明确从类走）。这和函数里局部名字遮住全局名字是同一个道理。

class E:
    n = 0                 # 想做一个所有实例共享的计数器
    def inc(self):
        self.n += 1       # 错！

>>> e1, e2 = E(), E()
>>> e1.inc()
>>> e1.n, e2.n, E.n
(1, 0, 0)
>>> e1.__dict__
{'n': 1}

class D:
    items = []            # 危险：一个列表，所有实例共用
    def add(self, x):
        self.items.append(x)

>>> d1, d2 = D(), D()
>>> d1.add(1)
>>> d2.items
[1]
>>> d1.items is D.items
True

7. 点表达式的求值规则：查找与赋值

前面所有现象，其实都由同一条规则推出来。现在把它正式写下来。

规则本身

点表达式的语法是：

<实例或类的表达式>.<名字>

三点补充，每一点都对应一类考题：

• Python 在查找时完全不区分「属性」和「方法」。 方法本身既是属性，也是函数。查找只认名字。
• 如果第 2b 步在类上找到的是一个函数，而第 1 步得到的是实例，那么返回的是绑定方法（第 5 节讲过）。若第 1 步得到的是类，返回的就是普通函数，你得自己传 self。
• 若第 2a 步就在实例上找到一个函数，返回的是那个函数本身，不做任何绑定。这是下面 Car 例子的关键。

Car：把规则用到底

>>> class Car:
...     def __init__(self):
...         self.fuel = 10
...     def drive(self, distance):
...         if distance > self.fuel:
...             return "Can't drive that far"
...         self.fuel -= distance
...         return self.fuel
...
>>> a = Car()
>>> b = Car()

此刻的状态：类 Car 上有 __init__ 和 drive；实例 a 上只有 fuel = 10；实例 b 上只有 fuel = 10。

>>> a.drive = lambda distance: "Car overheating!"
>>> a.drive(1)
'Car overheating!'
>>> b.drive(5)
5
>>> Car.drive = lambda self: "Tire popped!"
>>> a.drive(100)
'Car overheating!'
>>> b.drive()
'Tire popped!'
>>> f = a.drive
>>> f(1)
'Car overheating!'

这一串我在 Python 3 里逐行跑过，输出与上面完全一致。下面一条条讲为什么。

第 3 步和第 6 步的对照最值得反复看：同样写 b.drive，一次要传实参一次不用。因为绑定方法自动补的是第一个参数，剩下几个由你补——原 drive 有 self, distance 两个形参，补掉 self 还剩 1 个要你给；新 lambda 只有 self 一个形参，补掉就一个不剩。

两种 AttributeError 长得不一样

>>> class Person:
...     def __init__(self, name):
...         self.name = name
...
>>> p = Person('Rebecca')
>>> p.age
AttributeError: 'Person' object has no attribute 'age'
>>> Person.name
AttributeError: type object 'Person' has no attribute 'name'

第一条里的 'Person' object 说明点左边是实例；第二条里的 type object 'Person' 说明点左边是类。第二条特别值得注意：name 是在 __init__ 里挂到实例上的，类身上从来就没有过这个属性。看报错时读清楚是哪一种，能直接告诉你该往哪儿找问题。

8. 身份 vs 相等：is、== 与 __eq__

第 10 讲讲可变数据时区分过 is（是不是同一个对象）和 ==（值是不是相等）。到了自定义类这里，这个区分会给出一个让很多人意外的结果。

>>> class Person:
...     def __init__(self, name):
...         self.name = name
...
>>> rebecca1 = Person('Rebecca')
>>> rebecca2 = Person('Rebecca')
>>> rebecca1 is rebecca2
False
>>> rebecca1 == rebecca2
False

is 是 False，这个不奇怪：调用了两次 Person(...) 就造了两个独立的实例，各占各的位置。

让人意外的是 == 也是 False。两个人的 name 明明都是 'Rebecca'。原因是：Python 不知道你所谓的「相等」是什么意思。 对于一个自定义类，比较两个实例是该看 name？看全部属性？还是看某个 ID？Python 无从判断，于是采用最保守的默认：== 退化成 is——只有同一个对象才算相等。

用 __eq__ 自己定义相等

把幻灯片右半边那份代码补上：

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

    def __eq__(self, other):
        if type(other) is not Person:
            return NotImplemented
        return self.name == other.name

>>> rebecca1 = Person('Rebecca')
>>> rebecca2 = Person('Rebecca')
>>> rebecca1 is rebecca2
False
>>> rebecca1 == rebecca2
True

is 仍然是 False，而且永远改不了——身份就是身份，两个对象就是两个对象，没有任何办法让它们变成同一个。变的只有 ==。

NotImplemented 是干什么的

这是整段代码里最容易被囫囵读过去的一行。为什么类型不对时不直接 return False？

NotImplemented 是一个特殊的内置值，含义是「我不知道怎么比，你去问对方」。返回它之后，Python 会转而去问右边那个对象的 __eq__；如果对方也说不知道，Python 才最终退回到比身份，给出 False。

>>> rebecca1 == 5
False
>>> rebecca1 != rebecca2
False

rebecca1 == 5 最终仍然得到 False，看起来跟直接 return False 没区别。区别在于：直接返回 False 会堵死对方表态的机会。假如有人写了一个 PersonRecord 类，它知道怎么和 Person 比较，你返回 NotImplemented 就能让它接手，返回 False 就把路封死了。这是「不知道」和「否」的区别，别混为一谈。

另外，!= 会自动由 __eq__ 的结果取反得来，不必单独写 __ne__——上面 rebecca1 != rebecca2 得 False 就是这么来的。

>>> {rebecca1}
TypeError: unhashable type: 'Person'

9. 四个必须会用的内置函数

有了类之后，Python 提供了几个函数让你在运行时询问一个对象的情况。这四个在 Lab 06 和 Ants 里都会用到。

>>> class Person:
...     def __init__(self, name):
...         self.name = name
...
>>> rebecca = Person('Rebecca')
>>> type(rebecca)
<class 'Person'>
>>> isinstance(rebecca, Person)
True
>>> isinstance(rebecca, str)
False
>>> hasattr(rebecca, 'name')
True
>>> getattr(rebecca, 'name')
'Rebecca'

这解决了第 1 节说的「ADT 没法做类型检查」——isinstance 就是那个正式的答案。

细节一：type 的输出到底长什么样

幻灯片上写的是 <class 'Person'>。在真实的 Python 交互环境里，你看到的其实是：

>>> type(rebecca)
<class '__main__.Person'>

__main__ 是当前正在运行的模块的名字。幻灯片省略了这个前缀以免分散注意力。不要因为这个差别以为自己写错了。 重点是：type 返回的是类对象本身，不是它的名字字符串，所以 type(rebecca) is Person 得 True。

细节二：hasattr 和 getattr 走的是同一条查找链

它们不是什么另辟蹊径的后门，就是第 7 节那条规则的函数版：

>>> hasattr(rebecca, '__init__')     # 实例上没有，但类上有
True
>>> hasattr(rebecca, 'age')
False
>>> getattr(rebecca, 'age')
AttributeError: 'Person' object has no attribute 'age'
>>> getattr(rebecca, 'age', 0)       # 给个默认值就不报错了
0

getattr 的第三个参数是「找不到时返回什么」，很实用。

for field in ['name', 'balance', 'holder']:
    print(field, '=', getattr(acc, field, '(无)'))

10. 实战：把 Spotify 拆成五个类

课堂后半段是一道设计题：要做一个音乐流媒体 app，该有哪些类？它们之间是什么关系？ 这不是语法练习，而是本讲的真正目的——学会用对象的眼光看一个真实系统。

怎么想到该有哪些类

方法很朴素：把需求用大白话写出来，句子里的名词是候选的类，动词是候选的方法，「A 的 B」和「A 由 B 组成」是候选的属性。

注意最后三行体现的一个核心观念：一个对象的属性可以是另一个对象。 Song.artist 存的不是艺术家的名字字符串，而是那个 Artist 对象本身。所以你能写 song.artist.name——连续两次点表达式，先从歌拿到艺术家对象，再从艺术家对象拿到名字。这比存一个名字字符串强得多：艺术家改名时，所有歌自动跟着改，因为它们指的是同一个对象。

Artist：最简单的一个，先做它

class Artist:
    def __init__(self, name: str):
        """
        >>> taylor = Artist('Taylor Swift')
        >>> taylor.name
        'Taylor Swift'
        >>> taylor.albums
        []
        >>> taylor.followers
        0
        """
        self.name = name
        self.albums = []
        self.followers = 0

doctest 直接告诉你要装哪三个属性和它们的初值。self.albums = [] 必须写在 __init__ 里——写成类属性 albums = [] 会让所有艺术家共用一个专辑列表（第 6 节那个坑）。

User：一个顺序陷阱

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

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

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

「order matters」这句注释是启动代码里就给好的。为什么？看 Playlist.__init__ 的最后一行（下面就写）：self.owner.playlists.append(self)——歌单被创建时，会反过来把自己塞进拥有者的 playlists 列表。所以在调用 Playlist(...) 之前，self.playlists 必须已经是一个列表了。

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

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

>>> r = User('Rebecca')
>>> len(r.playlists)
0                       # 期望是 1
>>> r.liked_songs is r.playlists[0]
IndexError: list index out of range

follow 方法则展示了「一个动作同时改两个对象」：

Song：格式化输出

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

    def play(self):
        """Prints the song title, artist name, and duration (M:SS)"""
        minutes = self.duration_sec // 60
        seconds = self.duration_sec % 60
        print(f'{self.name} by {self.artist.name} ({minutes}:{seconds})')

play 是 print 而不是 return——doctest 里 all_too_well.play() 下面那行 All Too Well by Taylor Swift (5:27) 是打印出来的，函数本身返回 None。把 print 改成 return，doctest 会因为多出一对引号而失败。

秒转分秒：327 秒 → 327 // 60 = 5 分，327 % 60 = 27 秒 → 5:27。// 取整除、% 取余，两个一起用就是「拆成两级单位」的标准手法。

>>> Song('Short', taylor, 305).play()
Short by Taylor Swift (5:5)

print(f'{self.name} by {self.artist.name} ({minutes}:{seconds:02d})')

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:
    def __init__(self, name: str, songs: list[Song], artist: Artist):
        self.name = name
        self.songs = songs
        self.artist = artist
        self.total_duration_sec = sum([song.duration_sec for song in self.songs])
        self.artist.albums.append(self)

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

四处值得说：

怎么验证

启动代码是 13.py，用课上说的方式跑测试：

$ python3 -m doctest 13.py

没有任何输出就是全过了（这是 doctest 的惯例，跟 ok 不一样）。想看细节就加 -v。我在本机对参考解答 13-sol.py 跑过：43 tests in 15 items. 43 passed and 0 failed.

课上提示「有些类要等别的类实现完才能跑通 doctest」，原因很具体：User.__init__ 里用到了 Playlist，而 Playlist 定义在文件后面。这不影响运行——class User 语句执行时并不会去查 Playlist 这个名字，只有真正调用 User('Rebecca') 时才会查，那时整个文件早已执行完，Playlist 已经在全局帧里了。所以建议按顺序把五个类全写完再统一跑测试。

11. 常见误区清单

把本讲散落各处的坑集中起来。每一条都配了真实的报错或真实的错误输出，建议对照着自己敲一遍。

忘了 self.

class Account:
    def __init__(self, holder):
        balance = 0          # 错：这只是个局部名字
        self.holder = holder

>>> a = Account('Spock')
>>> a.balance
AttributeError: 'Account' object has no attribute 'balance'

诊断口诀：看到 'X' object has no attribute 'y'，先去 __init__ 里找有没有 self.y = ... 这一行。 十次有八次是漏了 self.。

忘了 self 形参

class Counter:
    def __init__(self):
        self.n = 0
    def increment():          # 错：少了 self
        pass

>>> Counter().increment()
TypeError: Counter.increment() takes 0 positional arguments but 1 was given

「我一个参数都没传，它却说给了 1 个」——那 1 个就是实例。

手动传 self

>>> a = Account('Spock')
>>> a.deposit(a, 100)
TypeError: Account.deposit() takes 2 positional arguments but 3 were given

通过实例调方法时，实例是自动补上的，你再写一次就多了一个。只有用 类.方法(实例, ...) 的形式才需要手写。

把类当实例用

>>> Account.deposit(100)
TypeError: Account.deposit() missing 1 required positional argument: 'amount'
>>> acc = Account            # 错：只是给类起了个别名，没造实例
>>> acc.balance
AttributeError: type object 'Account' has no attribute 'balance'

造实例必须带括号：Account('Spock')。 不带括号只是在传递类本身。type object 'X' has no attribute 这种报错措辞，几乎总意味着「你把类当成实例了」。

用 self.x += 1 去改类属性

见第 6 节。改的是实例，类属性不动，而且从此这个实例被遮蔽，再也读不到类属性的更新。改类属性一律写 类名.属性 += 1。

可变的类属性

见第 6 节。items = [] 写在类里 → 所有实例共用一个列表 → 一个实例 append，全体都变。凡是列表、字典这类可变对象，一律在 __init__ 里创建。

期待 __init__ 的返回值

>>> class Z:
...     def __init__(self):
...         return 5
...
>>> Z()
TypeError: __init__() should return None, not 'int'

__init__ 只负责装修，实例由 Python 自己造好并返回。

print 与 return 混淆

class Song:
    def play(self):
        return f'{self.name} by {self.artist.name}'    # 题目要的是 print

doctest 会这样失败（这是 doctest 的标准报错格式）：

Expected:
    All Too Well by Taylor Swift (5:27)
Got:
    'All Too Well by Taylor Swift (5:27)'

看到「Got 里比 Expected 多一对引号」，就是把 print 写成了 return。 因为 REPL 显示返回值时会带引号（用 repr），而 print 是直接输出内容。

以为 == 默认会比内容

见第 8 节。自定义类的 == 默认等同于 is。想比内容必须写 __eq__。

属性存了名字而不是对象

self.artist = artist.name       # 只存了字符串

这样 song.artist.name 会变成 'Taylor Swift'.name，报 AttributeError: 'str' object has no attribute 'name'。需要「顺着关系继续往下走」时，属性要存对象本身。

本讲小结

动手练习

练习 1：Account 追踪

用第 3 节那个 Account（无类属性版本），下面每一行输出什么？有报错就写出报错类型。

>>> a = Account('Ann')
>>> a.deposit(50)
>>> a.withdraw(60)
>>> a.balance
>>> b = Account('Bob')
>>> b.balance
>>> Account.deposit(b, 30)
>>> a.balance
>>> Account.balance

>>> a.deposit(50)
50
>>> a.withdraw(60)
'Insufficient funds'
>>> a.balance
50
>>> b.balance
0
>>> Account.deposit(b, 30)
30
>>> a.balance
50
>>> Account.balance
AttributeError: type object 'Account' has no attribute 'balance'

练习 2：实例属性遮蔽类属性

class Dorm:
    capacity = 100

    def __init__(self, name):
        self.name = name
        self.residents = 0

    def move_in(self, n):
        self.residents += n
        Dorm.capacity -= n
        return self.capacity

下面每一行输出什么？

>>> unit1 = Dorm('Unit 1')
>>> unit2 = Dorm('Unit 2')
>>> unit1.move_in(30)
>>> unit2.capacity
>>> unit1.capacity = 5
>>> unit1.move_in(10)
>>> Dorm.capacity
>>> unit2.capacity

>>> unit1.move_in(30)
70
>>> unit2.capacity
70
>>> unit1.capacity = 5
>>> unit1.move_in(10)
5
>>> Dorm.capacity
60
>>> unit2.capacity
60

练习 3：绑定与不绑定

class Robot:
    def __init__(self, name):
        self.name = name
    def speak(self, word):
        return self.name + ': ' + word

r1 = Robot('R1')
r2 = Robot('R2')
r1.speak = lambda word: 'R1 is broken'
Robot.speak = lambda self: self.name + ' hums'

下面四行分别输出什么？

>>> r1.speak('hi')
>>> r2.speak()
>>> r2.speak('hi')
>>> Robot.speak(r1)

>>> r1.speak('hi')
'R1 is broken'
>>> r2.speak()
'R2 hums'
>>> r2.speak('hi')
TypeError: <lambda>() takes 1 positional argument but 2 were given
>>> Robot.speak(r1)
'R1 hums'

练习 4：给 Playlist 加一个方法

给第 10 节的 Playlist 加一个 add_song(self, song)：把歌加到 songs 末尾，并让 total_duration_sec 保持正确。再加一个 longest_song(self)，返回时长最长的那首 Song 对象（歌单为空时返回 None）。

def add_song(self, song):
    self.songs.append(song)
    self.total_duration_sec += song.duration_sec

def longest_song(self):
    if not self.songs:
        return None
    longest = self.songs[0]
    for song in self.songs:
        if song.duration_sec > longest.duration_sec:
            longest = song
    return longest

练习 5：设计题——图书馆

不写代码，只回答：要给一个图书馆管理系统建模，你会定义哪些类？每个类有哪些属性和方法？哪些数据该做成类属性？

def borrow(self, book):
    if book.is_borrowed:
        return 'Already borrowed'
    if len(self.borrowed_books) >= Member.max_borrow_limit:
        return 'Limit reached'
    self.borrowed_books.append(book)     # 改会员
    book.is_borrowed = True              # 改书