序列与容器

0. 本讲导读

到上一讲为止，你手里的值都是一个一个的：一个数、一个布尔值、一个字符串、一个函数。写 count_partitions 这种树递归时，你能算出「有多少种分法」，但没法把那些分法本身留下来——因为你没有任何办法让一个名字同时指向多个值。

这个限制比看上去严重。想一想「求这组数的平均值」：你不知道这组数有几个，所以没法写 def average(a, b, c)；想一想「把这句话里每个词都翻译一遍」：句子的长度是运行时才知道的。凡是数据的个数在写代码时还不确定的问题，用目前的工具都写不出来。

本讲补上的是容器（container）：一个值，内部装着别的值。有了它，「一组数据」本身成了可以命名、可以传参、可以返回的一个值，而「数据有几个」变成了运行时才回答的问题。CS 61A 的下半场——数据抽象、树、链表、Scheme 里的表——全部建立在这一讲上。

但容器带来的不只是方便。列表是可变（mutable）的，这意味着从今天起，「两个名字指向同一个值」这件事第一次会产生可观察的后果：改了一边，另一边跟着变。本讲的切片、浅拷贝、is 与 ==，讲的都是同一个问题的不同侧面——到底有几个对象，谁在指着谁。这个问题下一讲（可变性与数据抽象）会正面展开，本讲先把它摆到台面上。

往回看：本讲的 sum_list_rec 用的还是第 5、6 讲的递归骨架，只不过「更小的问题」从「更小的数」变成了「更短的列表」。往前看：Lab 03 的主题就是 Sequences 与 Recursion，而项目 Cats 从头到尾都在切列表、切字符串。

1. 容器、序列与列表基础

两个定义，先分清

容器（container）：一个装着若干个值的值。
序列（sequence）：有顺序的容器——每个元素有确定的位置，你可以问「第 0 个是谁」。

「有顺序」这三个字是关键。下一讲会遇到集合（set）和字典（dict），它们是容器但不是序列：你不能问一个 set 的「第 0 个元素」，因为它根本没有第 0 个。本讲的所有语法——索引、切片、for 的遍历顺序——都依赖「有顺序」这个前提。

Python 里最常见的三个序列类型：

本讲讲列表的语法时，请随时记着：其中很大一部分对字符串同样成立。len、索引、切片、in、for 遍历，字符串全都支持。真正的分水岭只有一条——字符串不能改。

造一个列表

用方括号把若干个表达式逗号分隔起来，就是一个列表字面量（list literal）：

>>> lst = [1, 'abc', True]   # can mix and match data types
>>> len(lst)
3

第一行发生的事，用第 1 讲的求值规则拆开是这样的：

第 3 步值得多想一秒。lst 这个名字在当前帧里只占一格，它指向的是一个整体。列表内部装着三个指向元素的引用，但那是列表的事，不是环境的事。这个区分在讲别名时会变得性命攸关。

len(lst) 返回元素个数 3。注意 len 数的是顶层的格子数，不管格子里装的是什么——哪怕某个格子里装的是另一个有 100 个元素的列表，它也只算 1 个。

索引：方括号是函数调用的语法糖

>>> lst[0]      # zero-indexed
1
>>> from operator import getitem
>>> getitem(lst, 2)     # equivalent to square bracket notation
True

幻灯片特意把 getitem 拿出来讲，不是为了让你以后写 getitem(lst, 2)——没人这么写。它想说的是一件观念上的事：

为什么从 0 开始？把下标理解成「离开头有多远」就顺了：第 0 个元素离开头 0 步，第 1 个离开头 1 步。长度为 3 的列表，合法下标是 0、1、2；最后一个元素的下标是 len(lst) - 1。

下标越界会得到一个非常明确的错误：

>>> lst = [1, 'abc', True]
>>> lst[3]
Traceback (most recent call last):
  ...
IndexError: list index out of range

Python 还支持负数下标，从右边数起：lst[-1] 是最后一个，lst[-2] 是倒数第二个。等价关系是 lst[-k] 就是 lst[len(lst) - k]。这个特性在本讲最后的凯撒密码练习里会被用得很巧妙。

>>> lst['0']
Traceback (most recent call last):
  ...
TypeError: list indices must be integers or slices, not str
>>> lst[1.0]
Traceback (most recent call last):
  ...
TypeError: list indices must be integers or slices, not float

下标赋值：本课程第一次「改动一个值」

>>> lst = [1, 'abc', True]
>>> lst[1] = 'def'      # mutation: reassignment
>>> lst
[1, 'def', True]

这两行值得停下来。lst[1] = 'def' 是一条赋值语句，但它跟你见过的所有赋值都不一样：

「帧里一个字都没变」是理解可变性的钥匙。画个图看看 lst[1] = 'def' 前后：

执行前
  Global frame
    lst ──┐
          ▼
        列表对象 @id1
        ┌─────┬───────┬──────┐
        │  0  │   1   │  2   │
        ├─────┼───────┼──────┤
        │  1  │ 'abc' │ True │
        └─────┴───────┴──────┘

执行 lst[1] = 'def' 之后
  Global frame
    lst ──┐          ← 绑定没动，还是指向 @id1
          ▼
        列表对象 @id1  ← 还是同一个对象，只是 1 号格换了内容
        ┌─────┬───────┬──────┐
        │  0  │   1   │  2   │
        ├─────┼───────┼──────┤
        │  1  │ 'def' │ True │
        └─────┴───────┴──────┘

字符串则完全不给你这个机会：

>>> s = 'hello'
>>> s[0]
'h'
>>> s[0] = 'j'
Traceback (most recent call last):
  ...
TypeError: 'str' object does not support item assignment

这条报错信息要记住——它是「你想改一个不可变对象」的标准信号。想要「改过的字符串」，只能造一个新的：s = 'j' + s[1:]。本讲末尾的凯撒密码正是因为这个限制，才要先把字符攒进一个列表、最后再 join 成字符串。

2. for 循环与 range

用 while 遍历列表有什么不好

有了列表和 len，你其实已经能用第 2 讲的 while 遍历它了：

lst = ['a', 'b', 'c']
i = 0
while i < len(lst):
    print(lst[i])
    i += 1

这段代码能跑，但四行里有三行跟「打印每个元素」这件事毫无关系：i = 0 是初始化、i < len(lst) 是边界、i += 1 是更新。三行样板代码，每一行都是一个能出错的地方——i 从 1 开始就漏掉第一个，条件写成 <= 就 IndexError，忘了 i += 1 就死循环。

for 循环把这三行全部收进语法里：

for <var> in <iterable>:
    <suite>

>>> lst = ['a', 'b', 'c']
>>> for elem in lst:
...     print(elem)
...
a
b
c

执行 for 循环时到底发生了什么

for 是一条复合语句，和 if、while 一样由 header 加缩进的 suite 组成。它的执行过程是：

第 2 步里「跟普通赋值一样」这句话有两个后果，都很重要。

后果一：for 不新建帧。 和 while 一样，循环变量就是当前帧里的一个普通名字。所以循环结束之后它还在，值是最后一次绑定的那个：

>>> for elem in ['a', 'b', 'c']:
...     pass
...
>>> elem
'c'

后果二：改循环变量不会影响原列表。 这是初学者最常摔的一跤：

>>> lst = [1, 2, 3]
>>> for elem in lst:
...     elem = elem * 2
...
>>> lst
[1, 2, 3]

第 2 轮开始时（elem 被绑定到列表的 1 号元素）
  Global frame
    lst  ──┐
    elem ──┼──┐
           ▼  │
        列表 @id1
        ┌───┬───┬───┐
        │ 1 │ 2 │ 3 │
        └───┴─▲─┴───┘
              └───────┘   elem 和列表的 1 号格 指向同一个值 2

执行 elem = elem * 2 之后
  Global frame
    lst  ──┐
    elem ──── 4      ← 只是把 elem 改指到新算出来的 4
           ▼
        列表 @id1
        ┌───┬───┬───┐
        │ 1 │ 2 │ 3 │   ← 列表一个字没变
        └───┴───┴───┘

道理和 x = 5 一模一样：elem = ... 改的是名字的绑定，而列表的格子是另一处存放引用的地方。要真的改列表，必须走下标赋值 lst[i] = ...——也就是说你需要下标，而 for elem in lst 恰恰不给你下标。这就引出了 range。

range：一串按需生成的整数

range(end)               # 从 0 开始
range(start, end)        # 从 start 开始
range(start, end, step)  # 步长为 step

后两行值得留意：range 为空时，for 循环体一次都不执行，而且不会报错。程序「什么也没干就结束了」的时候，先怀疑 range 是不是空的。

还要说清一件事：range(1000000) 不会在内存里造一百万个整数。range 对象只记住 start、end、step 三个数，用到第几个才算第几个。所以它在交互式解释器里直接显示自己是这样：

>>> range(5)
range(0, 5)
>>> list(range(5))
[0, 1, 2, 3, 4]

想看到里面的数，得用 list(...) 把它铺开。（这和后面 map / filter 的显示是同一回事。）

按下标遍历

>>> lst = ['a', 'b', 'c']
>>> for i in range(len(lst)):
...     print(i)
...
0
1
2

这就是「需要下标时」的标准写法。回到刚才那个「把每个元素翻倍」的需求，现在能写对了：

>>> lst = [1, 2, 3]
>>> for i in range(len(lst)):
...     lst[i] = lst[i] * 2
...
>>> lst
[2, 4, 6]

区别只在于赋值语句的左边：elem = ... 改名字，lst[i] = ... 改列表。

序列解包：一次绑定多个名字

如果被遍历的每个元素本身是一个序列，可以在 for 的变量位置写多个名字，一次拆开：

>>> lst = [[1, 2], [3, 4], [5, 6]]
>>> for x, y in lst:     # sequence unpacking
...     print(x, y)
...
1 2
3 4
5 6

每一轮做的事是：取出一个元素（比如 [1, 2]），然后同时把 x 绑到它的第 0 个、y 绑到第 1 个。这叫序列解包（sequence unpacking）。它要求每个元素的长度恰好等于名字的个数，否则报错：

>>> for x, y in [[1, 2], [3, 4, 5]]:
...     print(x, y)
...
1 2
Traceback (most recent call last):
  ...
ValueError: too many values to unpack (expected 2)

注意它是跑到第二轮才炸的——第一轮已经打印出 1 2。这是循环里所有类型错误的共同特征：前面几轮的副作用已经发生了。

enumerate 把「值」和「下标」一起给你，正好配合解包使用：

>>> lst = ['a', 'b', 'c']
>>> for i, elem in enumerate(lst):    # sequence unpacking
...     print(i, elem)
...
0 a
1 b
2 c

enumerate(lst) 概念上产生 (0, 'a')、(1, 'b')、(2, 'c') 这一串成对的东西，解包后 i 拿下标、elem 拿值。这是「既要值又要下标」时最干净的写法——比 for i in range(len(lst)) 再 lst[i] 好读，也少一次索引。

>>> lst = [10, 20, 30]
>>> total = 0
>>> for elem, i in enumerate(lst):   # 写反了！
...     total += elem
...
>>> total
3

下划线：一个不打算用的名字

>>> for _ in range(3):    # _ is convention for an unused variable
...     print('Go bears!')
...
Go bears!
Go bears!
Go bears!

_ 在 Python 里就是一个普通的合法名字，没有任何特殊语法含义。用它纯粹是一种约定：告诉读代码的人「这个循环我只关心重复三次，根本不在乎当前是第几轮」。你写成 for i in range(3) 完全等价，只是读者会花半秒钟去找 i 在哪用了，然后发现没用。

3. 成员判断：in 比你想的浅

<value> in <sequence> 是一个表达式，求值成 True 或 False，问的是「这个值是不是该序列的某一个元素」。

>>> lst = [1, 2, [3, 4]]
>>> 2 in lst
True
>>> 3 in lst
False
>>> [3, 4] in lst
True
>>> len(lst)
3

中间那行是整段的重点：3 in lst 是 False，尽管 3 明明「在里面」。原因是 lst 只有三个元素：1、2、[3, 4]。3 不是其中任何一个，它是第三个元素的元素。

既然比较用的是 ==，那 [3, 4] in lst 为真就顺理成章：lst[2] == [3, 4] 成立（两个列表内容相同），所以 in 认账。注意它不要求是同一个对象——右边那个 [3, 4] 是刚刚新建的列表，和 lst 里装的根本不是一个东西，但 == 为真就够了。这一点在下一节 is vs == 里会再提。

字符串上的 in 不一样

字符串是唯一的例外：对 str 来说，in 判断的是子串（substring），不是「某个字符」：

>>> 'b' in 'abc'
True
>>> 'bc' in 'abc'      # 子串也算
True
>>> 'ac' in 'abc'      # 必须连续
False
>>> 'bc' in ['a', 'b', 'c']    # 列表就不吃这一套
False

另外，in 在 for 语句里的那个 in 跟这个 in 是两个完全不同的东西：前者是 for 语法的一部分（关键字），后者是一个运算符。看到 in 先看它前面是不是 for。

4. 切片：取出一段，顺手复制一份

索引一次只能拿一个元素。想拿「第 1 到第 3 个」，用切片（slicing）：

>>> lst = ['a', 'b', 'c', 'd', 'e']
>>> lst[1:3]      # end is exclusive
['b', 'c']
>>> lst[1:]       # default end is len(lst)
['b', 'c', 'd', 'e']
>>> lst[:2]       # default start is 0
['a', 'b']
>>> lst[::2]      # default step is 1
['a', 'c', 'e']

语法是 lst[start:end:step]，三个部分各有默认值：

和 range 一样，end 不含。所以 lst[1:3] 拿的是下标 1 和 2，两个元素，长度恰好是 3 - 1 = 2。

   'a'   'b'   'c'   'd'   'e'
  0     1     2     3     4     5

切片永远不越界

这是切片和索引最大的行为差异，也是它好用的原因之一：

>>> lst = [1, 2]
>>> lst[5]
Traceback (most recent call last):
  ...
IndexError: list index out of range
>>> lst[1:5]      # 切片不报错，能拿多少拿多少
[2]
>>> lst[5:9]
[]

切片超出范围只会给你一个更短（甚至为空）的列表，永远不会 IndexError。 这个性质对写递归极其友好：lst[1:] 哪怕在 lst 只有一个元素、甚至是空列表时，也安安静静地返回 []，不需要你先判断长度。第 9 节的 sum_list_rec 就靠这一点。

切片赋值：这是变异

>>> lst = ['a', 'b', 'c', 'd', 'e']
>>> lst[1:3] = ['go', 'bears']    # slicing assignment mutates
>>> lst
['a', 'go', 'bears', 'd', 'e']

把切片写在赋值号左边，效果是「把这一段整个换成右边那些元素」。它改的是原列表，跟 lst[1] = 'def' 一样属于变异。

有意思的是，新旧长度不必相等——列表会自己伸缩：

>>> z = [1, 2, 3, 4, 5]
>>> z[1:3] = [9]          # 两个换一个，列表变短
>>> z
[1, 9, 4, 5]
>>> z = [1, 2, 3]
>>> z[1:2] = [7, 8, 9]    # 一个换三个，列表变长
>>> z
[1, 7, 8, 9, 3]

切片取值：造出一个新列表

切片写在赋值号右边时，行为完全不同——它不碰原列表，而是新建一个：

>>> lst
['a', 'go', 'bears', 'd', 'e']
>>> temp = lst[1:3]       # slicing creates a (shallow) copy
>>> temp[1] = 'stanford'
>>> lst
['a', 'go', 'bears', 'd', 'e']
>>> temp
['go', 'stanford']

temp = lst[1:3] 之后
  Global frame
    lst  ──▶ 列表 @A ['a', 'go', 'bears', 'd', 'e']
                       │      │
                       │      │      (只是内容上巧合相同的引用)
    temp ──▶ 列表 @B ['go', 'bears']
                       ▲
                       └── @B 是一个全新的对象，@A 和 @B 是两个列表

temp[1] = 'stanford' 之后
    lst  ──▶ 列表 @A ['a', 'go', 'bears', 'd', 'e']   ← 没动
    temp ──▶ 列表 @B ['go', 'stanford']               ← 只有 @B 的 1 号格变了

由此得到两条一定要背下来的惯用法（幻灯片上的 Tip 1 和 Tip 2）：

lst[::-1] 之所以能反转，是因为 step 为 -1 表示从右往左走，而 start / end 省略时会自动取「最右」和「最左之外」。这是个惯用法，记住形状即可，不必每次现推。

5. 嵌套列表与浅拷贝：copy 到底复制了什么

列表的元素可以是任意值——包括另一个列表。这叫嵌套列表（nested list），是后面「树」「矩阵」「链表」的物质基础。

访问嵌套元素就是连着写两次索引：

>>> lst = [1, 2, [3, 4]]
>>> lst[2]
[3, 4]
>>> lst[2][0]
3

lst[2][0] 依然只是普通的表达式求值：先算 lst[2] 得到那个内层列表，再对结果取 [0]。和 f(x)(y) 是完全同一个道理——上一步的结果就是下一步的操作对象。

浅拷贝的真面目

现在把切片拷贝和嵌套列表放到一起，本讲最关键的一段就出现了：

>>> lst = [1, 2, [3, 4]]
>>> copy = lst[:]      # careful, this is a shallow copy!
>>> lst[1] = 'go'
>>> lst
[1, 'go', [3, 4]]
>>> copy
[1, 2, [3, 4]]
>>> lst[2][0] = 'bears'
>>> lst
[1, 'go', ['bears', 4]]
>>> copy
[1, 2, ['bears', 4]]

这个不对称让所有人第一次都看不懂。画出来就一目了然了：

① lst = [1, 2, [3, 4]]

  lst ──▶ 列表 @A
          ┌───┬───┬─────┐
          │ 1 │ 2 │  ·──┼──▶ 列表 @C  ┌───┬───┐
          └───┴───┴─────┘             │ 3 │ 4 │
                                      └───┴───┘

② copy = lst[:]     ← 新建列表 @B，把 @A 每个格子里的「引用」原样抄一份

  lst  ──▶ 列表 @A
           ┌───┬───┬─────┐
           │ 1 │ 2 │  ·──┼──┐
           └───┴───┴─────┘  │
                            ├──▶ 列表 @C  ┌───┬───┐
  copy ──▶ 列表 @B          │             │ 3 │ 4 │
           ┌───┬───┬─────┐  │             └───┴───┘
           │ 1 │ 2 │  ·──┼──┘
           └───┴───┴─────┘

   关键：@A 和 @B 是两个不同的列表对象，
        但它们的 2 号格 指向的是「同一个」 @C。

③ lst[1] = 'go'    ← 只改 @A 的 1 号格

  lst  ──▶ @A [1, 'go', ·──▶@C]
  copy ──▶ @B [1,  2 ,  ·──▶@C]     ← @B 完全不受影响

④ lst[2][0] = 'bears'
   先算 lst[2] → 拿到 @C 本身；再把 @C 的 0 号格改成 'bears'

  lst  ──▶ @A [1, 'go', ·──┐
                           ├──▶ @C ['bears', 4]   ← 被改的是这里
  copy ──▶ @B [1,  2 ,  ·──┘

   于是 copy 显示为 [1, 2, ['bears', 4]] —— 它并没有「被改」，
   它只是一直指着那个 @C，而 @C 变了。

验证「共享」这件事，可以直接问 Python：

>>> lst = [1, 2, [3, 4]]
>>> copy = lst[:]
>>> lst is copy
False
>>> lst[2] is copy[2]
True

外层不是同一个，内层是同一个。这两行把「浅拷贝」四个字彻底说清了。

def deep_copy(lst):
    result = []
    for elem in lst:
        if type(elem) == list:
            result.append(deep_copy(elem))
        else:
            result.append(elem)
    return result

>>> grid = [[0, 0, 0]] * 3
>>> grid
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
>>> grid[0][0] = 'X'
>>> grid
[['X', 0, 0], ['X', 0, 0], ['X', 0, 0]]

>>> grid = [[0, 0, 0] for _ in range(3)]
>>> grid[0][0] = 'X'
>>> grid
[['X', 0, 0], [0, 0, 0], [0, 0, 0]]

6. 身份与相等：is 和 == 问的不是同一个问题

>>> a = [1, 2, 3]
>>> b = [1, 2, 3]
>>> a == b
True
>>> a is b
False

为什么每写一次 [1, 2, 3] 就得到一个新对象？因为列表可变。如果 Python 偷懒让两个字面量共用一个列表，那 a.append(4) 就会莫名其妙地把 b 也改了——没有人能接受这种事。所以每一次求值列表字面量，都必然新建一个对象。

那么什么时候 is 才为真？只有当两个名字确实指着同一个对象时：

>>> a = [1, 2, 3]
>>> b = a            # 只是给同一个列表起了第二个名字
>>> a is b
True
>>> b.append(4)
>>> a
[1, 2, 3, 4]
>>> c = a[:]         # 切片造新对象
>>> a is c
False
>>> a == c
True

b = a 这行没有造任何列表，它只是让 b 和 a 指向同一处。这种「一个对象两个名字」的情况叫别名（aliasing），是下一讲的主角。is 就是检测别名的工具。

b = a  之后（别名）          c = a[:] 之后（拷贝）

  a ──┐                        a ──┐
      ├──▶ 列表 @X                 ├──▶ 列表 @X  [1,2,3,4]
  b ──┘                        b ──┘
                               c ────▶ 列表 @Y  [1,2,3,4]

  a is b → True                a is c → False
  改 @X，a 和 b 都看得见        a == c → True（内容碰巧一样）
                               改 @Y，a 和 b 都看不见

>>> x = 1000
>>> y = int('1000')
>>> x is y
False
>>> x == y
True
>>> s1 = 'hello'
>>> s2 = ''.join(['h', 'e', 'l', 'l', 'o'])
>>> s1 is s2
False
>>> s1 == s2
True

7. 列表推导式：把「造一个新列表」写成一个表达式

「对列表里每个元素做点什么，得到一个新列表」这个模式出现的频率高到离谱。用 for 循环写出来永远是同一副骨架：

squares = []
for x in range(5):
    squares.append(x ** 2)

列表推导式（list comprehension）把这三行压成一个表达式：

[<map_expression> for <var> in <iterable>]

>>> [x for x in range(5)]
[0, 1, 2, 3, 4]
>>> [x ** 2 for x in range(5)]
[0, 1, 4, 9, 16]

求值过程

注意第 3 步：<map_expression> 写在最前面，但它是最后才被求值的——每一轮都要先有 x 才能算 x ** 2。读推导式的正确顺序是先读中间的 for，再回头读开头的表达式。

加过滤条件

>>> [x ** 2 for x in range(5) if x % 2 == 0]
[0, 4, 16]

在最后加 if <condition>，含义是：条件为假的元素直接跳过，连算都不算。所以结果列表比原来短——这里 5 个变成了 3 个。手动展开一遍：

另一个 if：条件表达式

>>> [x ** 2 if x % 2 == 0 else x + 1 for x in range(5)]
[0, 2, 4, 4, 16]

逐个元素算一遍 [x ** 2 if x % 2 == 0 else x + 1 for x in range(5)]：

<a> if <cond> else <b> 这个条件表达式（conditional expression）不是推导式专有的语法，它在任何地方都能用：y = 1 if x > 0 else -1。它和 if 语句的区别是老问题——表达式求值成一个值，语句只产生效果。

>>> [x for x in range(5) if x % 2 == 0 else 0]
  File "<stdin>", line 1
    [x for x in range(5) if x % 2 == 0 else 0]
                                       ^^^^
SyntaxError: invalid syntax

什么时候不该用

推导式还能用在字典、集合等其它容器上（下一讲会见到）。但幻灯片提醒的那句话值得认真对待：可读性 vs 简洁性。

下面这种就已经过头了：

[y for x in lst for y in x if y > 0 and y % 3 != 1]

它是合法的，但没人能一眼看懂。真需要这种复杂度时，要么拆成多行写，要么老老实实用 for 循环。推导式是为了让代码更好读才存在的；如果它让代码更难读，那就用错地方了。

8. 列表方法：增、删，以及那个要命的 None

方法（method）是「绑在某个对象上的函数」，用点号调用：lst.append(7)。现在只需要知道它的行为，机制（面向对象）在后面的课里讲。

添加元素

>>> lst = [1, 2, 3]
>>> lst.append(7)
>>> lst
[1, 2, 3, 7]
>>> lst.extend([4, 5])
>>> lst
[1, 2, 3, 7, 4, 5]
>>> lst.insert(1, 'a')
>>> lst
[1, 'a', 2, 3, 7, 4, 5]
>>> [1, 2, 3] + [4, 5]
[1, 2, 3, 4, 5]

append 和 extend 的差别是必考点，看清楚：

>>> a = [1, 2]
>>> a.append([3, 4])
>>> a
[1, 2, [3, 4]]        # 长度 3，末尾多了一个「列表元素」
>>> b = [1, 2]
>>> b.extend([3, 4])
>>> b
[1, 2, 3, 4]          # 长度 4，多了两个元素

一句话：append 加的是「一个东西」，extend 加的是「一批东西」。 lst.extend(s) 的效果等价于 for x in s: lst.append(x)。

顺带一个后果：extend 的参数必须可迭代，否则报错；而 append 什么都收：

>>> [1, 2].extend(3)
Traceback (most recent call last):
  ...
TypeError: 'int' object is not iterable

删除元素

>>> lst = [1, 'a', 2, 3, 7, 4, 5]
>>> lst.remove('b')
Traceback (most recent call last):
  ...
ValueError: list.remove(x): x not in list
>>> lst.remove('a')
>>> lst
[1, 2, 3, 7, 4, 5]
>>> lst.pop()
5
>>> lst
[1, 2, 3, 7, 4]
>>> lst.pop(2)
3
>>> lst
[1, 2, 7, 4]

pop 是这一组里唯一有返回值的方法——它既改列表又给你东西，所以 x = lst.pop() 是完全正常的写法。而 x = lst.append(7) 就是个 bug。

>>> lst = [1, 2, 3]
>>> lst = lst.append(4)     # ✗ 想「更新 lst」，实际把它变成了 None
>>> lst
>>> print(lst)
None
>>> lst.append(5)
Traceback (most recent call last):
  ...
AttributeError: 'NoneType' object has no attribute 'append'

>>> lst = [1, 2, 3]
>>> lst.append(4)        # ✓ 它直接改了 lst 指向的那个列表
>>> lst
[1, 2, 3, 4]

>>> v = [1, 2, 3, 4]
>>> for e in v:
...     if e % 2 == 0:
...         v.remove(e)
...
>>> v
[1, 3]

>>> v = [2, 4, 6]
>>> for e in v:
...     if e % 2 == 0:
...         v.remove(e)
...
>>> v
[4]

9. 序列的真假性与一批常用函数

空容器是 falsy

第 2 讲的 falsy 名单里有一项叫「空容器」，现在可以坐实了：

>>> not []      # empty list is falsy
True
>>> not [1]
False
>>> not ''
True
>>> not [0]     # 里面装着 falsy 的东西，但列表本身非空
False

最后一行要看清：[0] 是非空列表，所以它 truthy，尽管它唯一的元素是 falsy 的 0。容器的真假性只取决于「空不空」，与内容毫无关系。

直接后果是判断空列表的惯用写法：

list() 与 sum()

>>> list('abc')      # convert things into lists
['a', 'b', 'c']
>>> sum([1, 2, 3])
6
>>> sum([1, 2, 3], 10)      # optional start
16

list(x) 把任何可迭代对象铺开成列表。对字符串它按字符拆；对 range 它把整数全算出来；对已有列表它做一次浅拷贝（list(lst) 和 lst[:] 效果一样）。

sum 的第二个参数是起始值，默认 0。所以 sum([1,2,3], 10) 算的是 10 + 1 + 2 + 3 = 16。这个参数在「累加时要有个初值」的场合有用。

all() 与 any()

>>> is_even = [x % 2 == 0 for x in range(5)]
>>> is_even
[True, False, True, False, True]
>>> all(is_even)
False
>>> all([])
True
>>> any(is_even)
True
>>> any([])
False

all(s)：s 里每一个元素都 truthy 吗？any(s)：至少有一个吗？两者判断的都是真假性，不是「等于 True」，所以 all([1, 'hi', [0]]) 也是 True。

max() 与 min()，以及 key

>>> max([1, 2, 3])
3
>>> min([1, 2, 3])
1
>>> max(['apple', 'pear', 'banana'])      # alphabetically highest
'pear'
>>> max(['apple', 'pear', 'banana'], key=lambda s: len(s))
'banana'

字符串之间的大小是字典序比较：先比第一个字符，相同再比第二个……'pear' 的 'p' 排在 'apple' 的 'a' 和 'banana' 的 'b' 之后，所以它最大。

key 参数是本讲和高阶函数的接口。它的含义是：不要直接比较元素本身，先把每个元素喂给 key，比较返回的结果；但最终返回的仍是原元素。

注意 key=lambda s: len(s) 里传的是函数本身，不是调用结果。写成 key=len(s) 会直接报 NameError: name 's' is not defined——这里根本没有叫 s 的名字。其实这个例子写成 key=len 更干净，len 本身就是一个函数。

map / filter / reduce

这三个是第 3 讲高阶函数在序列上的具体化身，也是「用函数处理一整个序列」的经典三件套。

>>> map(lambda x: x * x, [1, 2, 3])
<map object ...>
>>> list(map(lambda x: x * x, [1, 2, 3]))
[1, 4, 9]
>>> filter(lambda x: x > 2, [1, 2, 3, 4, 5])
<filter object ...>
>>> list(filter(lambda x: x > 2, [1, 2, 3, 4, 5]))
[3, 4, 5]
>>> from functools import reduce
>>> reduce(lambda x, y: x + y, [1, 2, 3, 4, 5])
15
>>> reduce(lambda x, y: x + y, [1, 2, 3, 4, 5], 10)   # optional start
25

reduce 的展开过程值得写清楚，因为它和前两个不是一类东西：

累积值 = 1                （直接取第一个元素）
累积值 = f(1, 2)  = 3     （折进 2）
累积值 = f(3, 3)  = 6     （折进 3）
累积值 = f(6, 4)  = 10    （折进 4）
累积值 = f(10, 5) = 15    （折进 5）
                  → 15

累积值 = 10
累积值 = f(10, 1) = 11
累积值 = f(11, 2) = 13
累积值 = f(13, 3) = 16
累积值 = f(16, 4) = 20
累积值 = f(20, 5) = 25
                  → 25

>>> len(map(lambda x: x * x, [1, 2, 3]))
Traceback (most recent call last):
  ...
TypeError: object of type 'map' has no len()

>>> m = map(lambda x: x * x, [1, 2, 3])
>>> list(m)
[1, 4, 9]
>>> list(m)      # 第二次就空了
[]

>>> from functools import reduce
>>> reduce(lambda x, y: x + y, [])
Traceback (most recent call last):
  ...
TypeError: reduce() of empty iterable with no initial value

10. 随堂练习一：sum_list，一个问题的两种解法

随堂代码 07.py 的第一题，要求把同一个功能用迭代写一遍、再用递归写一遍。这不是凑数——它是本讲最有价值的一次对照实验：同一个「遍历序列」的需求，迭代靠下标推进，递归靠切片缩短。

def sum_list_iter(lst: list) -> int:
    """
    Given a list of integers, return the sum of
    all the elements iteratively (don't just use `sum`).

    >>> sum_list_iter([])
    0
    >>> sum_list_iter([1, 2, 3])
    6
    >>> sum_list_iter([4, 6434, 16, 20, 46, 7])
    6527
    """

顺便认识一下签名里的 lst: list 和 -> int，它们叫类型注解（type hint）：写给人看的说明，Python 运行时完全不检查。你传个字符串进去它照样跑（然后在别的地方炸）。

迭代版

思路是累加器（accumulator）模式，第 2 讲的老朋友：设一个变量存「到目前为止的和」，扫一遍列表，每见到一个元素就加进去。

def sum_list_iter(lst):
    total = 0
    for elem in lst:
        total += elem
    return total

三个决定，每一个都值得说明为什么：

追踪 sum_list_iter([1, 2, 3])：

while 版本，以及官方参考解答里的一个坑

题目鼓励你「用另一种循环再写一遍」。while 版本长这样：

def sum_list_iter(lst):
    total = 0
    i = 0
    while i < len(lst):
        total += lst[i]
        i += 1          # ← 这一行不能少
    return total

# ALTERNATE SOLUTION:
total = 0
i = 0
while i < len(lst):
    total += lst[i]
return total

递归版

递归的关键一步永远是同一句话：怎么把这个问题变成一个「同构但更小」的问题？

之前几讲里，「更小」意味着更小的数字（n - 1、n // 10）。在列表上，「更小」意味着更短的列表。而第 4 节已经给了现成的工具：lst[1:] 是「去掉第一个元素之后的那截」，而且它在任何长度上都不会越界。

于是分解方式自己就冒出来了：

列表的和 = 第一个元素 + 剩下那截的和

def sum_list_rec(lst):
    if len(lst) == 0:
        return 0
    else:
        return lst[0] + sum_list_rec(lst[1:])

现在真的展开一遍 sum_list_rec([1, 2, 3])，一层一层下到底再回代：

sum_list_rec([1, 2, 3])
  len([1,2,3]) == 0 ?  否
  → 1 + sum_list_rec([2, 3])
        │
        │  sum_list_rec([2, 3])
        │    len([2,3]) == 0 ?  否
        │    → 2 + sum_list_rec([3])
        │          │
        │          │  sum_list_rec([3])
        │          │    len([3]) == 0 ?  否
        │          │    → 3 + sum_list_rec([])
        │          │          │
        │          │          │  sum_list_rec([])
        │          │          │    len([]) == 0 ?  是  ← base case
        │          │          │    → return 0
        │          │          ▼
        │          │    → 3 + 0 = 3
        │          ▼
        │    → 2 + 3 = 5
        ▼
  → 1 + 5 = 6

对应的帧长这样（每次调用都新建一帧，parent 都是 Global，因为 sum_list_rec 定义在全局）：

Global frame
    sum_list_rec ──▶ func sum_list_rec(lst) [parent=Global]

f1: sum_list_rec   [parent=Global]
      lst   ──▶ [1, 2, 3]
      正在算: 1 + sum_list_rec([2, 3])      ← 挂起，等 f2

f2: sum_list_rec   [parent=Global]
      lst   ──▶ [2, 3]        ← 注意：这是切片造出来的「新列表」
      正在算: 2 + sum_list_rec([3])         ← 挂起，等 f3

f3: sum_list_rec   [parent=Global]
      lst   ──▶ [3]
      正在算: 3 + sum_list_rec([])          ← 挂起，等 f4

f4: sum_list_rec   [parent=Global]
      lst   ──▶ []
      len(lst) == 0 成立 → 返回 0           ← 第一个真正返回的帧

回代：f4 返回 0 → f3 得 3+0=3 → f2 得 2+3=5 → f1 得 1+5=6

def f(lst):
    if not lst:          # 或 len(lst) == 0
        return <空列表时的答案>
    else:
        return <用 lst[0] 和 f(lst[1:]) 的结果拼出答案>

TypeError: object of type 'int' has no len()

>>> sum_list_rec([])
Traceback (most recent call last):
  ...
IndexError: list index out of range

TypeError: unsupported operand type(s) for +: 'int' and 'NoneType'

11. 随堂练习二：凯撒密码 decode 与 encode

第二题把本讲的东西全用上了：字符串遍历、index 查位置、模运算绕圈、列表 append 攒结果、join 拼回字符串——外加一个漂亮的负数索引小技巧。

题目要什么

ALPHABET = 'abcdefghijklmnopqrstuvwxyz'

凯撒密码（Caesar cipher），移位 3：加密时每个字母在字母表上右移 3 位（a → d，b → e，……，z 绕回到 c），解密就是反过来左移 3 位。空格保持不变，输入只含小写字母和空格。

>>> encode('hello')
'khoor'
>>> decode('khoor')
'hello'
>>> decode('pdb wkh irufh eh zlwk brx')
'may the force be with you'
>>> 'go bears' == decode(encode('go bears'))
True

先解决「怎么表示一个字母的位置」

字母本身没法直接做算术（'a' + 3 会报 TypeError: can only concatenate str (not "int") to str）。所以要先把字母换成数字，算完再换回来。ALPHABET 这个字符串就是那张对照表：

>>> ALPHABET.index('d')     # 字母 → 位置
3
>>> ALPHABET[3]            # 位置 → 字母
'd'

index 返回第一次出现的下标。ALPHABET 里每个字母只出现一次，所以这个「第一次」就是唯一一次，映射是一一对应的。（找不到时报 ValueError: substring not found，本题保证输入合法，不会遇到。）

于是整个流程固定为三步：字母 → 位置 → 移位后的位置 → 字母。

另一个约束：字符串不能改

直觉上你想写 result = result + new_char 一路拼。这能跑，但 starter code 给的骨架不是这样——它先建一个列表 decoded_chars = []，把字符一个个 append 进去，最后：

return "".join(decoded_chars)

sep.join(iterable) 把可迭代对象里的字符串用 sep 连起来。','.join(['a','b','c']) 得到 'a,b,c'；这里 sep 是空字符串 ""，所以就是原样粘在一起。

为什么绕这一圈？因为字符串不可变——result = result + c 每次都要造一个全新的字符串并把已有内容整个复制过去，n 个字符总共复制 Θ(n²) 次。而列表可变，append 是直接往末尾塞，最后 join 一次成型，总共 Θ(n)。「用可变的列表攒中间结果，最后转成不可变的字符串」是标准套路，Cats 项目里会反复用到。

encode：模运算处理绕圈

def encode(message):
    encoded_chars = []

    for char in message:
        if char == " ":
            encoded_chars.append(" ")
        else:
            original_index = ALPHABET.index(char)
            encoded_index = (original_index + 3) % len(ALPHABET)
            encoded_chars.append(ALPHABET[encoded_index])

    return "".join(encoded_chars)

decode：为什么可以不写 %

def decode(message):
    decoded_chars = []

    for char in message:
        if char == " ":
            decoded_chars.append(" ")
        else:
            encoded_index = ALPHABET.index(char)
            # This is fine even for encoded_index < 3
            # because Python supports negative indexing
            decoded_index = encoded_index - 3
            decoded_chars.append(ALPHABET[decoded_index])

    return "".join(decoded_chars)

结构和 encode 一模一样，只是 +3 换成 -3。但注意——这里没有取模，却依然正确。这是本题最巧的一处。

encoded_index = ALPHABET.index('a') = 0
decoded_index = 0 - 3 = -3
ALPHABET[-3]  = ?

  ALPHABET = 'abcdefghijklmnopqrstuvwxyz'
  正下标：   0  1  2  ...        23 24 25
  负下标：                      -3 -2 -1
                                 x  y  z

ALPHABET[-3] = 'x'

完整验证一条：decode('pdb wkh irufh eh zlwk brx')。取前三个字符和那个空格：

攒出 ['m','a','y',' ','t', ...]，join 之后开头是 'may t...'，正是 'may the force be with you'。

最后一条 doctest 'go bears' == decode(encode('go bears')) 检验的是互逆性：先 encode 得到 'jr ehduv'，再 decode 应当原样回来。这种「往返测试（round-trip test）」是检验一对互逆函数的最佳手段——它不需要你手算出中间结果就能查出错。

>>> ALPHABET.index(' ')
Traceback (most recent call last):
  ...
ValueError: substring not found

>>> (0 - 3) % 26
23
>>> -3 % 26
23

def shift(message, k):
    chars = []
    for char in message:
        if char == " ":
            chars.append(" ")
        else:
            i = ALPHABET.index(char)
            chars.append(ALPHABET[(i + k) % len(ALPHABET)])
    return "".join(chars)

def encode(message):
    return shift(message, 3)

def decode(message):
    return shift(message, -3)

本讲小结

序列操作速查

函数速查

四个必须分清的对子

三条最容易踩的线

1. lst = lst.append(x) —— 变异方法返回 None，这行把列表弄丢了。下次用它就是 AttributeError: 'NoneType' object has no attribute ...。
2. 浅拷贝只拷一层 —— copy = lst[:] 之后 lst[2] is copy[2] 仍为 True。[[0]*3]*3 造出来的三行是同一行。
3. 边遍历边增删 —— 元素会被跳过或永远循环。要过滤就用列表推导式造新列表。

与前后讲的接口

第 5、6 讲的递归骨架在本讲换了一副皮：「更小的问题」从更小的数变成了更短的列表，lst[1:] 就是这一讲的 n - 1。第 3 讲的高阶函数在本讲有了具体用武之地：map、filter、max(key=...) 全都靠「把函数当参数」。

下一讲会把本讲最后按下不表的那件事挑明：可变性。别名到底怎么产生、函数参数传的是什么、可变默认参数为什么是陷阱，以及怎么用数据抽象把这些危险关进笼子里。本讲的浅拷贝、is、变异方法，是那一讲的全部前置知识。

动手练习

练习 1：Python 会显示什么

逐行写出输出（没有输出就写「无」）：

>>> lst = [1, [2, 3], 4]
>>> len(lst)
>>> 2 in lst
>>> [2, 3] in lst
>>> lst[1][1]
>>> lst[1:]
>>> lst[3:]
>>> lst.append([5])
>>> lst

>>> len(lst)
3
>>> 2 in lst
False
>>> [2, 3] in lst
True
>>> lst[1][1]
3
>>> lst[1:]
[[2, 3], 4]
>>> lst[3:]
[]
>>> lst.append([5])
（无输出，返回 None）
>>> lst
[1, [2, 3], 4, [5]]

练习 2：别名与拷贝

下面这段执行完，a、b、c 各是什么？

>>> a = [1, 2, [3, 4]]
>>> b = a
>>> c = a[:]
>>> b.append(5)
>>> c[0] = 'x'
>>> a[2].append(6)

>>> a
[1, 2, [3, 4, 6], 5]
>>> b
[1, 2, [3, 4, 6], 5]
>>> c
['x', 2, [3, 4, 6]]

初始
  a ──┐
      ├──▶ @A [1, 2, ·──▶ @C [3, 4]]
  b ──┘        （b = a 是别名，没有新建对象）
  c ────▶ @B [1, 2, ·──▶ @C]     （c = a[:] 新建 @B，但 2 号格还是指 @C）

b.append(5)  → 改的是 @A         → a、b 都看到 5；c 看不到
c[0] = 'x'   → 改的是 @B 的 0 号格 → 只有 c 变
a[2].append(6) → 先算 a[2] 拿到 @C，再改 @C
               → @A 和 @B 的 2 号格都指着 @C，所以 a、b、c 全都看到 6

练习 3：两个 if 的位置

写出下面三个表达式的值：

>>> [x * 2 for x in [1, 2, 3, 4] if x > 2]
>>> [x * 2 if x > 2 else 0 for x in [1, 2, 3, 4]]
>>> [x * 2 for x in [1, 2, 3, 4] if x > 2 if x % 2 == 0]

[6, 8]
[0, 0, 6, 8]
[8]

练习 4：写代码

实现 count_occurrences(lst, x)，返回 x 在 lst 里出现的次数。要求写两版：一版迭代，一版递归，都不许用 lst.count。

>>> count_occurrences([1, 2, 1, 3, 1], 1)
3
>>> count_occurrences([], 5)
0
>>> count_occurrences([[1], [1], 2], [1])
2

def count_occurrences_iter(lst, x):
    count = 0
    for elem in lst:
        if elem == x:
            count += 1
    return count


def count_occurrences_rec(lst, x):
    if len(lst) == 0:
        return 0
    elif lst[0] == x:
        return 1 + count_occurrences_rec(lst[1:], x)
    else:
        return count_occurrences_rec(lst[1:], x)

count([1,2,1], 1)   lst[0]=1 == 1  → 1 + count([2,1], 1)
  count([2,1], 1)   lst[0]=2 != 1  →     count([1], 1)
    count([1], 1)   lst[0]=1 == 1  → 1 + count([], 1)
      count([], 1)  空             → 0
    回代：1 + 0 = 1
  回代：      1
回代：1 + 1 = 2

练习 5：这段代码错在哪

下面这个函数想「把列表里所有奇数删掉」，但它有 bug。指出 bug、说清为什么，并给出两种改法。

def remove_odds(lst):
    for elem in lst:
        if elem % 2 == 1:
            lst.remove(elem)
    return lst

>>> remove_odds([1, 3, 5])
[3]
>>> remove_odds([1, 3, 2, 5])
[3, 2]

def remove_odds(lst):
    return [elem for elem in lst if elem % 2 == 0]

def remove_odds(lst):
    for elem in lst[:]:      # 遍历拷贝，删的是原列表
        if elem % 2 == 1:
            lst.remove(elem)
    return lst