可变性与数据抽象

0. 本讲导读

上一讲你学会了用列表（list）装一串东西，用切片取出其中一段，用 for 和列表推导式（list comprehension）批量加工它们。但有一件事一直被绕开：列表是可以被改的。lst.append(3) 这一行执行完，到底是「lst 这个名字现在指向一个新列表」，还是「lst 指的还是原来那个列表，只不过那个列表本身长大了一格」？

这两种说法听起来差不多，实际后果天差地别。如果是前者，别的名字不受影响；如果是后者，所有指向那个列表的名字都会一起「变」——哪怕它们在别的函数里、别的帧里，哪怕你压根没碰过它们。这门课接下来的一半 bug 都来自没想清楚这件事。

本讲的前半段（第 1–5 节）就是把这件事讲透：什么叫可变（mutable），什么叫不可变（immutable），改名字和改对象为什么必须分开想，以及两个新容器——不可变的元组（tuple）和可变的字典（dictionary）。

后半段（第 6–12 节）看起来是另一个话题：数据抽象（data abstraction）。它问的是：当你要在程序里表示「一个有理数」「一个银行账户」「一个二维坐标」时，该怎么组织代码？答案是抽象数据类型（Abstract Data Type，ADT）：写一个构造器（constructor）负责造出这个东西，写若干选择器（selector）负责从里面取出属性，然后其余所有代码只许通过这两类函数打交道。

这两半为什么放在同一讲？因为它们是同一个故事的两面。可变性给了你很多种表示数据的方式（列表、字典、甚至一个闭包函数），而数据抽象保证：你随时可以换一种实现，而调用方一行都不用改。反过来说，如果调用方到处直接写 x['numer']，那你就永远被锁死在「字典」这个实现上——想加个约分、想换成元组、想换成闭包，全都办不到。

往前看：本讲的 ADT 会在 Lab 04、HW 03 里反复出现；下一讲的树（tree）本身就是一个用 ADT 定义的递归数据结构，构造器 tree(label, branches) 和选择器 label(t)、branches(t) 正是本讲这套东西的直接应用。本讲不扎实，下一讲会寸步难行。

1. 可变与不可变：为什么突然要关心这个

课程给的定义只有两句话：

请注意主语是对象（object）。这不是咬文嚼字。在 Python 里，「名字」和「对象」是两样东西：名字住在帧（frame）里，对象住在别的地方，名字通过一根箭头指向对象。「可变 / 不可变」描述的是箭头指向的那一端，跟箭头本身、跟名字叫什么，全都无关。

那么问题来了：既然能改是一种能力，为什么还要有不可变的东西？课上给的理由很朴素——有时候我们就是不希望东西被改，比如只读数据。展开说有三层：

• 安全：你把一个元组传给别人写的函数，可以确信回来以后它还是原样。传列表就不能确信。
• 可以当字典的键：字典要靠键的值来定位条目，如果键能被偷偷改掉，放进去的东西就再也找不到了。所以 Python 规定只有不可变对象才能当键（详见第 5 节）。
• 推理简单：一个不可变对象，你在程序任何位置看到它，值都一样。可变对象则必须问「现在是第几行？谁在这之前动过它？」

Python 内建类型的可变性分布如下。这张表值得背下来，因为几乎每道 WWPD（What Would Python Display）题都要用到它。

2. 元组：不可变的序列

元组（tuple）就是一个不能被修改的列表。上一讲学的关于序列的一切——索引、切片、len、in、for 遍历、+ 拼接——对元组全都成立，唯独「改」这一类操作不行。

怎么写一个元组

>>> tup = (1, 2, 3)
>>> tup = 1, 2, 3        # 括号可以省，但建议写上
>>> tup
(1, 2, 3)

真正决定「这是一个元组」的其实是逗号，不是括号。这导致一个必须记住的坑：

>>> t = (1)
>>> t
1
>>> type(t)
<class 'int'>
>>> t = (1,)          # 单元素元组，逗号不能省
>>> t
(1,)
>>> type(t)
<class 'tuple'>
>>> len(t)
1

(1) 里的括号被当成了「改变运算优先级的括号」，跟 (1 + 2) 里的那对括号是同一回事，所以求值结果就是整数 1。

元组解包

>>> tup = (1, 2, 3)
>>> a, b, c = tup      # tuple unpacking
>>> a
1
>>> b
2
>>> c
3

元组解包（tuple unpacking）是赋值语句的一个扩展：等号左边写若干个名字，右边给一个长度相同的序列，Python 会按位置一一绑定。它在本讲后面会用得非常多——遍历字典的 items() 时，每一项都是一个二元组，直接解包比写 item[0]、item[1] 清楚得多。

改不动

>>> tup = (1, 2, 3)
>>> tup[1]
2
>>> tup[0] = 'go bears'
Traceback (most recent call last):
  ...
TypeError: 'tuple' object does not support item assignment

读（tup[1]）没问题，写（tup[0] = ...）直接抛异常。元组也没有 append、pop、remove 这些方法——它们全是「改」，元组一个都不提供。

>>> tp = (1, [2, 3])
>>> tp[1].append(4)      # 没有改元组，改的是元组里那个列表
>>> tp
(1, [2, 3, 4])
>>> tp[0] = 9            # 这才是改元组
Traceback (most recent call last):
  ...
TypeError: 'tuple' object does not support item assignment

3. 名字改变 vs. 对象改变

这是本讲最重要的一节，也是最容易自以为懂了的一节。课上把它总结成一句话：名字的改变不等于变异（Name changes are not the same as mutation）。一个表达式的值可以变，原因可能是名字变了，也可能是对象变了。

左栏：名字改变

>>> x = 2
>>> x + x
4
>>> x = 4
>>> x + x
8

执行 x = 2 之后
Global frame
    x ────→ 2                （整数对象 2）

执行 x + x：查 x 得 2，算 2 + 2 = 4

执行 x = 4 之后
Global frame
    x ────→ 4                （箭头挪到了整数对象 4）
                             整数对象 2 一根汗毛没动

执行 x + x：查 x 得 4，算 4 + 4 = 8

右栏：对象改变

>>> x = [1, 2]
>>> x + x
[1, 2, 1, 2]
>>> x.append(3)
>>> x + x
[1, 2, 3, 1, 2, 3]

执行 x = [1, 2] 之后
Global frame
    x ────→ ┌───┬───┐
            │ 1 │ 2 │        （列表对象 L）
            └───┴───┘

执行 x + x：查 x 得 L，+ 造一个全新的列表 [1, 2, 1, 2]（L 没变）

执行 x.append(3) 之后
Global frame
    x ────→ ┌───┬───┬───┐
            │ 1 │ 2 │ 3 │    （还是那个 L，只是长了一格）
            └───┴───┴───┘
    x 这根箭头从头到尾没动过

执行 x + x：查 x 得 L，现在 L 是 [1, 2, 3]，算出 [1, 2, 3, 1, 2, 3]

>>> x = [1, 2]
>>> x = x.append(3)     # 错！
>>> x
>>> print(x)
None
>>> x + [4]
Traceback (most recent call last):
  ...
TypeError: unsupported operand type(s) for +: 'NoneType' and 'list'

4. 别名与可变默认参数：可变性最会咬人的两个地方

如果一个可变对象自始至终只有一个名字指着它，可变性其实很无害。麻烦全部来自同一个对象被多个名字指着——这叫别名（aliasing）。

别名从哪来

>>> a = [1, 2, 3]
>>> b = a               # 来源一：直接赋值
>>> c = a[:]            # 切片会造一个新列表，不是别名
>>> a.append(4)
>>> a
[1, 2, 3, 4]
>>> b
[1, 2, 3, 4]
>>> c
[1, 2, 3]
>>> a is b
True
>>> a is c
False
>>> a == c
False

Global frame
    a ──┐
        ├──→ L1: [1, 2, 3, 4]      ← a.append(4) 改的是这个对象
    b ──┘
    c ─────→ L2: [1, 2, 3]         ← a[:] 当时复制出来的另一个对象

a is b  →  True   （同一个对象）
a is c  →  False  （两个对象，只是当初内容相同）
a == c  →  False  （现在连内容都不同了）

b = a 这一行做的事只有一件：求值右边得到列表对象 L1，然后让名字 b 也指向 L1。它没有复制任何东西。之后不管你从 a 还是从 b 去改 L1，另一边都会「看到」。

别名的三个来源，记住它们就能预判绝大多数 bug：

第二条尤其要紧，因为它意味着函数可以改到调用方的数据：

>>> def add_four(lst):
...     lst.append(4)
...
>>> nums = [1, 2, 3]
>>> add_four(nums)
>>> nums
[1, 2, 3, 4]

f1 里的 lst 和全局帧里的 nums 指着同一个列表 L1。lst.append(4) 改的是 L1，所以 f1 消失之后，nums 看到的还是那个被改过的 L1。

>>> def f(lst):
...     lst += [4]        # 对 list 而言等价于 lst.extend([4])，是变异
...
>>> a = [1, 2, 3]
>>> f(a)
>>> a
[1, 2, 3, 4]

>>> def g(lst):
...     lst = lst + [5]   # 造一个新列表，再把本地名字 lst 绑过去
...
>>> b = [1, 2, 3]
>>> g(b)
>>> b
[1, 2, 3]

可变默认参数

现在来看课上那道 WWPD。先自己想清楚答案，再往下看。

>>> def f(s=[]):
...     s.append(len(s))
...     return s
...
>>> f()
[0]
>>> f()
[0, 1]
>>> f([5])
[5, 1]
>>> f()
[0, 1, 2]

很多人预期四次都是 [0]。要理解真实结果，得先想清一个问题：默认值 [] 这个表达式，是在什么时候被求值的？

Global frame
    f ────→ func f(s=[])
                 │
                 └── 默认值 ──→ D: [0, 1, 2]   ← 三次无参调用都在改它

f2: f [parent=Global]        （第二次 f() 的帧）
    s ────→ D                 同一个对象，不是副本
    返回值 ──→ D

f3: f [parent=Global]        （f([5]) 的帧）
    s ────→ L: [5, 1]         调用现场新造的列表，与 D 无关

怎么避免？标准做法是用 None 当默认值，在函数体里再造新对象：

>>> def f(s=None):
...     if s is None:
...         s = []          # 每次调用都执行一次，每次造一个新列表
...     s.append(len(s))
...     return s
...
>>> f()
[0]
>>> f()
[0]

None 是不可变的，做默认值绝对安全；而 s = [] 这一行在函数体里，每次调用都会重新执行，所以每次都得到一个全新的空列表。这里用 is None 而不是 == None，也不是 if not s:——后者会把调用方明确传进来的空列表也一并当成「没传」，那是另一个 bug。

5. 字典：键值对容器

字典（dictionary）是由键值对（key-value pair，也叫 entry）组成的容器，在别的语言里常叫 map 或 hashmap。列表用「位置」找元素，字典用「键」找元素。

为什么需要它？因为现实里大量数据天然就是「从一组值到另一组值的映射」：

• 姓名 → 邮箱地址
• 学生 → 等第成绩
• 姓名 → 家庭住址
• IP 地址 → 域名

这些如果硬用列表存，你就得维护两个平行列表并保证下标一一对应，还得靠线性扫描去查——又笨又易错。字典把「查找」这件事直接做成了语言原语。

增、查、改、删

>>> roman_numerals = {'I': 1, 'V': 5, 'X': 10}
>>> roman_numerals['I']
1
>>> roman_numerals['L'] = 50          # 新增一条
>>> roman_numerals
{'I': 1, 'V': 5, 'X': 10, 'L': 50}
>>> roman_numerals['V'] = 'five'      # 修改已有的一条
>>> roman_numerals
{'I': 1, 'V': 'five', 'X': 10, 'L': 50}
>>> del roman_numerals['V']           # 删除一条
>>> roman_numerals
{'I': 1, 'X': 10, 'L': 50}

注意 roman_numerals['L'] = 50 和 roman_numerals['V'] = 'five' 语法完全一样，行为却分「新增」和「修改」——取决于键在不在。也注意值的类型不必统一（'five' 是字符串，其余是整数），Python 不管这个。这两行都是变异：字典对象被改了，所有指向它的名字都会看到。

键的两条规矩

>>> {1: 'one', 2: 'two', 1: 'ONE'}     # 规矩一：键不能重复
{1: 'ONE', 2: 'two'}
>>> {[1, 2]: 3}                        # 规矩二：键必须可哈希
Traceback (most recent call last):
  ...
TypeError: unhashable type: 'list'
>>> dct = {(1, 2): 3}                  # 元组可以
>>> dct[(1, 2)]
3
>>> dct = {(1, [2, 3]): 4}             # 但装了列表的元组不行
Traceback (most recent call last):
  ...
TypeError: unhashable type: 'list'

第一条：字面量里写重复键不会报错，后写的覆盖先写的——所以 1 的值是 'ONE'；同时 1 保持它第一次出现的位置，所以打印出来 1 在 2 前面。

第二条更重要。可哈希（hashable）的意思是这个对象能算出一个稳定不变的哈希值，字典靠它来决定条目存放在哪。想想如果允许列表当键会怎样：

反过来说，「元组能当键」这件事非常有用——你可以用 (标题, 类型) 这样的复合键，这正是第 11 节 film_appearances 那道题的数据长相。

遍历

>>> pokemon = {'charizard': 'fire', 'squirtle': 'water', 'pikachu': 'electric'}
>>> for name in pokemon.keys():
...     print(name)
...
charizard
squirtle
pikachu
>>> for pokemon_type in pokemon.values():
...     print(pokemon_type)
...
fire
water
electric
>>> for name, pokemon_type in pokemon.items():
...     print(f"{name}: {pokemon_type}")
...
charizard: fire
squirtle: water
pikachu: electric

items() 给出的每一项都是一个 (键, 值) 二元组，所以 for name, pokemon_type in ... 用的正是第 2 节的元组解包——每轮循环把当前那个二元组拆成两个名字。

取值：方括号 vs. get

>>> pokemon['bulbasaur']
Traceback (most recent call last):
  ...
KeyError: 'bulbasaur'
>>> pokemon.get('bulbasaur')            # 键不存在时返回 None，不报错
>>> pokemon.get('bulbasaur', 'grass')   # 也可以指定一个兜底值
'grass'
>>> pokemon.pop('squirtle')             # 删除并返回被删掉的值
'water'
>>> pokemon
{'charizard': 'fire', 'pikachu': 'electric'}

第二行在交互式解释器里什么都不显示——因为返回值是 None，而 Python 的 REPL 对 None 不打印任何东西。这一点在 WWPD 题里是个高频考点：「什么都不显示」和「显示 None」是两种不同的答案，前者对应表达式求值为 None，后者对应你显式调用了 print(None)。

字典推导式

和列表推导式同一个套路，只是花括号里要写 键: 值 两部分：

>>> {x: x * x for x in range(4)}
{0: 0, 1: 1, 2: 4, 3: 9}
>>> d = {'a': 1, 'b': 2}
>>> {v: k for k, v in d.items()}       # 键值互换
{1: 'a', 2: 'b'}
>>> {x % 3: x for x in range(7)}       # 键会重复！
{0: 6, 1: 4, 2: 5}

最后一行值得手推一遍。x 依次取 0..6，产生的键值对是 0:0, 1:1, 2:2, 0:3, 1:4, 2:5, 0:6。键重复时后写的覆盖先写的，所以 0 最后是 6、1 最后是 4、2 最后是 5；而顺序按各个键第一次出现的先后，即 0、1、2。

>>> d = {'a': 1, 'b': 2}
>>> for k in d:
...     d[k + '!'] = 0
...
Traceback (most recent call last):
  ...
RuntimeError: dictionary changed size during iteration

6. 什么是抽象

课上给抽象下的定义只有一行：知道它做什么，不必知道它怎么做（know what it does, not how it works）。结论是：我们可以在完全不了解实现的情况下使用它。

你其实一直在享受抽象。max([1, 3, 2]) 返回 3，可你从来没读过 max 的源码：它是遍历一遍取最大，还是先排序再取最后一个？不知道，也不需要知道。你只知道它的行为契约：给我一个可迭代对象，还我里面最大的那个元素。

这带来两个好处，两个都很实在：

• 使用方省心：脑子里要装的东西少了。写代码时你只需要记住「max 给最大值」，而不是一整套实现细节。
• 实现方自由：只要行为契约不变，实现随便换。Python 明天把 max 改成更快的算法，你的代码一个字都不用动。

到目前为止，你用的抽象都是函数抽象（functional abstraction）：函数名 + 参数 + 返回值构成契约，函数体是被藏起来的实现。本讲要做的，是把同一套思想用到数据上：怎么把「一个有理数长什么样」这件事也藏起来？

7. 用可变类型做「原型 ADT」：一个会记账的函数

先看一个课上给出的、还没抽象化的做法：怎么在代码里表示「一个银行账户」？一个想法是把「函数」和「可变类型」拼起来。

def create_account(balance):
    account = [balance]
    def withdraw(amount):
        if amount > account[0]:
            return 'Insufficient funds'
        account[0] -= amount
        return account[0]
    return withdraw

>>> withdraw = create_account(100)
>>> withdraw(25)
75
>>> withdraw(5)
70

注意这个 withdraw 有记忆：第二次调用知道余额已经是 75 了。它是怎么记住的？必须画环境图才说得清。

Global frame
    create_account ──→ func create_account(balance) [parent=Global]
    withdraw ────────→ func withdraw(amount) [parent=f1]   ┐
                                                            │ 同一个函数对象
f1: create_account [parent=Global]                          │
    balance  ──→ 100        ← 从头到尾没被用过第二次        │
    account  ──→ A: [70]    ← 真正的余额住在这里            │
    withdraw ───────────────────────────────────────────────┘
    返回值 ──→ func withdraw

f3: withdraw [parent=f1]     （已执行完，仅示意）
    amount ──→ 5
    返回值 ──→ 70

这个方案能跑，但课上马上指出它的两个问题：

• 多个属性很难受。账户还要有户主名、开户日期、利率……全塞进 account[0]、account[1]、account[2]，谁记得住哪个下标是什么？
• 换实现就崩。哪天你想把账户从列表换成字典（{'owner': ..., 'balance': ...}），那么所有写了 account[0] 的代码——包括 withdraw——统统要改。而现实中「所有代码」可能散落在几十个文件里。

第二条才是致命伤。解决它的办法叫「关注点分离」，也就是下一节的 ADT。

8. 抽象数据类型：构造器与选择器

如果你学过面向对象编程（OOP），可能会觉得这写法很别扭——用类不是更自然吗？但要记住：不是所有语言都有 OOP，比如这门课后半学期要学的 Scheme 就没有。而构造器 + 选择器这套东西，只需要「函数」这一个概念就能实现，任何语言都做得到。

def create_account(owner, balance):
    return [owner, balance]

def get_owner(account):
    return account[0]

def get_balance(account):
    return account[1]

# ------- abstraction barrier -------
def withdraw(account, amount):
    balance = get_balance(account)
    if amount > balance:
        return 'Insufficient funds'
    return create_account(get_owner(account), balance - amount)

把它和第 7 节的版本对照，三个变化：

第三行值得多说一句。这个 withdraw 走的是不可变风格：它不动传进来的那个账户，而是用构造器造一个余额更少的新账户返回。手动追踪一遍：

>>> acct = create_account('Alice', 100)
>>> acct2 = withdraw(acct, 25)
>>> acct
['Alice', 100]
>>> acct2
['Alice', 75]
>>> withdraw(acct2, 1000)
'Insufficient funds'

9. 抽象屏障：违反它的代码应该被烧掉

「做假设」具体指什么？指你的代码里出现了任何只有知道底层表示才写得出来的东西：

为什么这么严格？看一个具体的爆炸现场。假设你写了这么一个「聪明」的加法，绕过选择器直接读字典：

# 屏障之外，违反了抽象屏障
def bad_add(x, y):
    return {'numer': x['numer'] * y['denom'] + y['numer'] * x['denom'],
            'denom': x['denom'] * y['denom']}

只要有理数还是用字典实现的，它能跑：

>>> bad_add(rational(1, 2), rational(1, 3))
{'numer': 5, 'denom': 6}

现在有人（可能就是三个月后的你）决定把有理数改成元组实现——这是完全合法的重构，构造器和选择器同步改好，行为一模一样：

def rational(n, d):
    return (n, d)

def numer(x):
    return x[0]

def denom(x):
    return x[1]

>>> bad_add(rational(1, 2), rational(1, 3))
Traceback (most recent call last):
  ...
TypeError: tuple indices must be integers or slices, not str

10. 有理数 ADT：换掉实现，调用方一行不改

课上用有理数把整套思路完整走了一遍。为什么要自己造有理数？Python 明明有浮点数。因为浮点数没有无限精度：

>>> 1 / 3
0.3333333333333333
>>> 1 / 3 + 1 / 3 + 1 / 3
1.0
>>> 0.1 + 0.2
0.30000000000000004

而一个有理数可以精确地表示成「分子 + 分母」两个整数。整数在 Python 里是任意精度的，所以只要我们自己管好这两个数，就能做到零误差。

屏障之内：构造器与选择器

def rational(n, d):
    return {'numer': n, 'denom': d}

def numer(x):
    return x['numer']

def denom(x):
    return x['denom']

就这三个函数，构成了「有理数」这个 ADT 的全部实现细节。字典只在这三个函数体里出现过，别处不许再出现。

屏障之外：用有理数干活

# ------- abstraction barrier -------
def add_rationals(x, y):
    nx, dx = numer(x), denom(x)
    ny, dy = numer(y), denom(y)
    return rational(nx * dy + ny * dx, dx * dy)

def mul_rationals(x, y):
    return rational(numer(x) * numer(y), denom(x) * denom(y))

def print_rational(x):
    print(numer(x), '/', denom(x))

def rationals_are_equal(x, y):
    return numer(x) * denom(y) == numer(y) * denom(x)

这四个函数背后是四个中学数学公式。加法通分：

乘法分子分母各自相乘：

相等判断用交叉相乘而不是分别比较分子分母——因为 rational(1, 2) 和 rational(2, 4) 是同一个数，但两个字典并不相等：

请把这四个函数体逐字扫一遍：没有一个方括号字符串下标，没有一个花括号字面量。它们只通过 rational、numer、denom 三个函数与有理数打交道。这就是「没有违反抽象屏障」的样子。

跑一遍

>>> half = rational(1, 2)
>>> print_rational(half)
1 / 2
>>> third = rational(1, 3)
>>> print_rational(mul_rationals(half, third))
1 / 6
>>> print_rational(add_rationals(third, third))
6 / 9

加上约分：换实现的时刻

from math import gcd

def rational(n, d):
    g = gcd(n, d)
    return {'numer': n // g, 'denom': d // g}

>>> print_rational(add_rationals(third, third))
2 / 3
>>> print_rational(rational(42, 100))
21 / 50

停下来看清楚发生了什么：add_rationals、mul_rationals、print_rational、rationals_are_equal 一个字符都没改，结果却自动变成约分过的了。原因是它们造有理数时用的是 rational(...)，而 rational 的新版本顺手把约分做了。

11. 实战一：film_appearances

随堂练习的第一题，起始代码在 08.py：

def film_appearances(movies: dict[tuple[str], list[str]],
                     target_actor: str, target_genre: str) -> int:
    """
    Given a dictionary mapping a tuple of the movie's title and genre
    to a list of the actors in that movie, the name of a target actor,
    and a target genre, return the number of times the target actor appears
    in movies of the target genre.
    """

题目到底要什么

先把数据结构看清楚——这道题一大半难度在这里。movies 是一个字典，它的

• 键是一个二元组 (电影标题, 类型)；
• 值是一个列表，里面装着这部电影的演员名字。

movies = {
    ('Star Wars: Episode IV - A New Hope', 'Sci-Fi'): [
        'Mark Hamill',
        'Harrison Ford',
        'Carrie Fisher',
    ],
    ('Blade Runner 2049', 'Sci-Fi'): [
        'Harrison Ford',
        'Ryan Gosling',
        'Ana de Armas',
    ],
    ('No Time to Die', 'Action'): [
        'Daniel Craig',
        'Ana de Armas',
    ],
}

要返回的是：在类型等于 target_genre 的电影里，target_actor 出现了几次。四条 doctest 覆盖了四种情况：

后两条是边界情况，它们其实在告诉你：不要试图用 movies[某个键] 去查，因为查不到会 KeyError。老老实实遍历。

怎么想到的

「数一数满足条件的东西有几个」这类问题的固定套路是计数器 + 遍历 + 条件判断：设一个 total = 0，遍历所有候选，符合条件就 += 1，最后 return total。骨架直接就能写出来。真正要想的只有两个问题：

问题一：遍历什么？判断条件同时需要「类型」（在键里）和「演员表」（在值里），所以必须同时拿到键和值——用 movies.items()。如果只写 for movie in movies:，拿到的只有键（那个二元组），还得再 movies[movie] 取值，绕。

问题二：键怎么拆？items() 的每一项是 ((标题, 类型), 演员列表)——一个二元组，它的第一项本身又是个二元组。可以写 for key, cast in movies.items(): 再用 key[1] 取类型，但更清楚的是嵌套解包：

for (title, genre), cast in movies.items():

左边的形状和右边每一项的形状一模一样，Python 会一层层拆下去。这就是第 2 节元组解包在真实场景里的用法。

条件怎么写？两件事同时成立：类型对得上（genre == target_genre），并且演员在这部片的演员表里（target_actor in cast）。in 用在列表上就是「有没有这个元素」，正是我们要的。

代码逐行讲

    total = 0
    for (title, genre), cast in movies.items():
        if genre == target_genre and target_actor in cast:
            total += 1
    return total

验证

12. 实战二：Coordinate ADT

第二题要求实现一个表示二维坐标 (x, y) 的 ADT，以及一个求两点距离的函数 distance。可以用已经导入的 sqrt。附加挑战：不用任何内建数据结构（列表 / 元组 / 字典），只用高阶函数（HOF）实现。

from math import sqrt

def coordinate(x, y):
    """
    >>> coord1 = coordinate(1, 2)
    >>> coord2 = coordinate(4, 6)
    >>> get_x(coord1)
    1
    >>> get_x(coord2)
    4
    >>> get_y(coord1)
    2
    >>> get_y(coord2)
    6
    >>> distance(coord1, coord2)
    5.0
    """

题目到底要什么

doctest 里没有一行暴露坐标的内部长相——这是刻意的。它只规定了接口：coordinate(x, y) 造一个坐标，get_x / get_y 取出两个分量，distance(a, b) 返回欧几里得距离。注意最后一条期望是 5.0 而不是 5：sqrt 返回浮点数，doctest 是逐字符比较的，返回整数 5 就算错。

怎么想到的

最直接的实现只要三行：

def coordinate(x, y):
    return [x, y]

def get_x(coord):
    return coord[0]

def get_y(coord):
    return coord[1]

用元组 (x, y) 或字典 {'x': x, 'y': y} 也一样好。三种实现互相替换时，distance 一个字都不用改——只要它老老实实走选择器。这就是我们要的效果，先把它写出来：

def distance(a, b):
    ax, ay = get_x(a), get_y(a)
    bx, by = get_x(b), get_y(b)
    return sqrt((ax - bx) ** 2 + (ay - by) ** 2)

现在来看挑战版：不许用列表、元组、字典，怎么把两个数存起来？

这时候要回想第 7 节那个闭包账户。它教了一件事：函数可以记住东西。create_account 返回的 withdraw 之所以记得余额，是因为它的 parent 指向 create_account 那一帧，而余额就在那一帧里。同样的机制：如果 coordinate(x, y) 返回一个在自己体内定义的函数，那个函数就自动「记住」了 x 和 y。

接下来的问题是：返回的函数拿什么参数？我们需要一个函数既能给出 x 又能给出 y。那就让它接受一个「你要哪个属性」的参数——传 "x" 给你 x，传 "y" 给你 y。这个想法一旦有了，代码就是官方解答的样子：

def coordinate(x, y):
    def select(attribute):
        if attribute == "x":
            return x
        elif attribute == "y":
            return y
    return select

def get_x(coord):
    return coord("x")

def get_y(coord):
    return coord("y")

注意此时一个「坐标」在 Python 眼里就是一个函数对象：

>>> coord1 = coordinate(1, 2)
>>> coord1
<function coordinate.<locals>.select at 0x7f3c5d1c60e0>

看起来很荒谬，但只要选择器工作正常，屏障之外的代码根本不在乎。distance 一个字都不用改，因为它从来没假设过坐标是什么。

代码逐行讲

Global frame
    coordinate ──→ func coordinate(x, y) [parent=Global]
    get_x      ──→ func get_x(coord)     [parent=Global]
    coord1     ──→ func select(attribute) [parent=f1]  ← 「坐标」就是这个函数对象
    coord2     ──→ func select(attribute) [parent=f2]  ← 另一个 select，parent 不同

f1: coordinate [parent=Global]
    x      ──→ 1
    y      ──→ 2
    select ──→ func select(attribute) [parent=f1]
    返回值 ──→ func select [parent=f1]

f2: coordinate [parent=Global]
    x      ──→ 4
    y      ──→ 6
    select ──→ func select(attribute) [parent=f2]
    返回值 ──→ func select [parent=f2]

关键在于 coord1 和 coord2 是两个不同的函数对象，虽然都是同一个 def 语句造出来的。每次调用 coordinate 都会新建一帧，也都会执行一次 def select，造出一个 parent 指向那一帧的新函数对象。两个坐标各自记着各自的 x、y，互不干扰。

验证

本讲小结

动手练习

练习 1（WWPD）：元组与可变性

>>> lst = [1, 2]
>>> t = (lst, 3)
>>> lst.append(9)
>>> t
______
>>> t[0] = [1, 2]
______
>>> d = {}
>>> d[t] = 'hi'
______

>>> t
([1, 2, 9], 3)
>>> t[0] = [1, 2]
TypeError: 'tuple' object does not support item assignment
>>> d[t] = 'hi'
TypeError: unhashable type: 'list'

练习 2（WWPD）：默认参数与字典

>>> def tally(item, counts={}):
...     if item in counts:
...         counts[item] += 1
...     else:
...         counts[item] = 1
...     return counts
...
>>> tally('a')
______
>>> tally('a')
______
>>> tally('b', {})
______
>>> tally('b')
______

>>> tally('a')
{'a': 1}
>>> tally('a')
{'a': 2}
>>> tally('b', {})
{'b': 1}
>>> tally('b')
{'a': 2, 'b': 1}

练习 3（WWPD）：字典推导式与遍历

>>> d = {'a': 1, 'b': 2, 'c': 1}
>>> {v: k for k, v in d.items()}
______
>>> 1 in d
______
>>> 'a' in d
______
>>> len({x // 2: x for x in range(5)})
______

>>> {v: k for k, v in d.items()}
{1: 'c', 2: 'b'}
>>> 1 in d
False
>>> 'a' in d
True
>>> len({x // 2: x for x in range(5)})
3

练习 4：递归 + ADT

用第 10 节的有理数 ADT，写一个 sum_rationals(rats)，把一个元组里的所有有理数加起来。空元组返回 rational(0, 1)。要求：用递归，且不许违反抽象屏障。

def sum_rationals(rats):
    """
    >>> r = (rational(1, 2), rational(1, 3), rational(1, 6))
    >>> print_rational(sum_rationals(r))
    36 / 36
    """

def sum_rationals(rats):
    if len(rats) == 0:
        return rational(0, 1)
    return add_rationals(rats[0], sum_rationals(rats[1:]))

sum_rationals((1/2, 1/3, 1/6))
= add_rationals(1/2, sum_rationals((1/3, 1/6)))
= add_rationals(1/2, add_rationals(1/3, sum_rationals((1/6,))))
= add_rationals(1/2, add_rationals(1/3, add_rationals(1/6, sum_rationals(()))))
= add_rationals(1/2, add_rationals(1/3, add_rationals(1/6, rational(0, 1))))   ← 触底

第 4 层：add_rationals(1/6, 0/1)
        分子 = 1 * 1 + 0 * 6 = 1
        分母 = 6 * 1 = 6            →  1/6

第 3 层：add_rationals(1/3, 1/6)
        分子 = 1 * 6 + 1 * 3 = 9
        分母 = 3 * 6 = 18           →  9/18

第 2 层：add_rationals(1/2, 9/18)
        分子 = 1 * 18 + 9 * 2 = 36
        分母 = 2 * 18 = 36          →  36/36

第 1 层：返回 36/36

练习 5：找出违反抽象屏障的地方

下面四行代码都在第 8 节那个银行账户 ADT（构造器 create_account(owner, balance)，选择器 get_owner / get_balance）的屏障之外。哪些违反了屏障？怎么改？

a) def is_rich(account):
       return get_balance(account) > 1000000

b) def rename(account, new_owner):
       account[0] = new_owner

c) def deposit(account, amount):
       return [get_owner(account), get_balance(account) + amount]

d) def transfer(src, dst, amount):
       return (withdraw(src, amount), deposit(dst, amount))

def rename(account, new_owner):
    return create_account(new_owner, get_balance(account))

def deposit(account, amount):
    return create_account(get_owner(account), get_balance(account) + amount)