一、为什么切片老是差一个

  • 这一篇对应官方 Lecture 11(Sequences)与 Lecture 12(Containers),把 Python 的三类「装东西」的容器一次讲清:

第一次见 digits[1:3],几乎所有人都会猜它取「第 1 到第 3 个」,也就是三个元素。

实际它取两个。这不是 Python 任性——左闭右开是刻意的设计,好处是 a[:i] + a[i:] == a 恒成立,切分点不需要加减一。

这条规则是最常见的错误来源,先把它确定下来。

二、索引与切片

1
2
3
4
5
6
7
8
9
10
digits = [7, 8, 9]
print(digits[1:3]) # 下标 1、2,不含 3
print(digits[:2])
print(digits[-1])
print(digits[1:])
print(digits + [10])
print(list(range(3, 8, 2)))

s = "abc"
print(s[0], s[1:])

输出:

1
2
3
4
5
6
7
[8, 9]
[7, 8]
9
[8, 9]
[7, 8, 9, 10]
[3, 5, 7]
a bc

几个要点一次说清:

写法 含义 digits = [7, 8, 9] 的结果
digits[i] 单元素 digits[0] → 7
digits[i:j] 左闭右开 digits[1:3] → [8, 9]
digits[i:j:k] 带步长 digits[::2] → [7, 9]
digits[-1] 从尾部数 9
seq + seq 拼接同类序列 [7, 8, 9, 10]
seq * n 重复 [1] * 3 → [1, 1, 1]

字符串和列表的切片语法完全一致,因为它们是同一种抽象——序列。这也是抽象屏障的又一次体现:len、in、for、切片,对所有序列都成立,不必关心底层是 str 还是 list。

三、for 与 range:一个常见误解

1
2
3
4
5
6
7
8
print(range(5) == [0, 1, 2, 3, 4])
print(list(range(5)))
print(type(range(5)).__name__)

total = 0
for x in [3, 4, 5]:
total += x
print(total)

输出:

1
2
3
4
False
[0, 1, 2, 3, 4]
range
12

range(5) 不是列表,它是一个惰性的序列对象。它只在需要第 i 个元素时才现算,所以 list(range(10**9)) 会耗尽内存,而 range(10**9) 本身只占几十字节。第二处是 range(5) == [0,1,2,3,4] 为 False——类型不同,相等就是不成立。

四、切片是浅拷贝:一次实测

1
2
3
4
5
6
7
a = [1, 2, [3, 4]]
b = a[:]
print(a is b)
print(a[0] is b[0])

b[2].append(5)
print(a)

输出:

1
2
3
False
True
[1, 2, [3, 4, 5]]

这是一段必须实际运行验证的代码:

  • a is b 是 False —— 切片新建了一个外层列表;
  • a[0] is b[0] 是 True —— 元素本身没有被复制,两个列表指向同一批对象;
  • 于是 b[2].append(5) 改的是共用的那个内层列表,a 也跟着变了。

浅拷贝只复制一层。 改 b[0] = 99 不会影响 a(那是改引用),改 b[2] 里的内容会影响 a(那是改共用对象)。分不清这两种,环境图必然画错。

五、列表推导式:map + filter 压成一行

1
2
3
4
5
sq_evens = [x**2 for x in range(10) if x % 2 == 0]
print(sq_evens)

m = [[1, 2, 3], [4, 5, 6]]
print([[row[i] for row in m] for i in range(3)])

输出:

1
2
[0, 4, 16, 36, 64]
[[1, 4], [2, 5], [3, 6]]

推导式的结构是 [表达式 for 变量 in 序列 if 条件],读作「对每个满足条件的元素,取它的表达式值」。它等价于:

1
2
3
4
sq_evens = []
for x in range(10):
if x % 2 == 0:
sq_evens.append(x**2)

第二段是矩阵转置:外层 for i 遍历列号,内层 for row 遍历行,row[i] 取出第 i 列。两层推导式已经接近可读性上限——再套一层,可读性会明显下降。能写一行不代表该写一行。

六、字典与集合

1
2
3
4
5
6
7
8
d = {'a': 1, 'b': 2}
print(d['a'], 'a' in d, len(d))
print(list(d))

print({1, 2, 3} | {3, 4})
print({1, 2, 3} & {3, 4})
print({1, 2, 3} - {3, 4})
print({1, 2, 3} == {3, 2, 1})

输出:

1
2
3
4
5
6
1 True 2
['a', 'b']
{1, 2, 3, 4}
{3}
{1, 2}
True
容器 取值方式 查找复杂度 特点
list 下标 a[i] O(n) 按值找 有序、可重复、可变
dict 键 d[k] 平均 O(1) 键值映射、键须不可变
set 不支持下标 平均 O(1) 唯一、无序、支持集合代数

三处需要留意的:

  • for k in d 拿到的是键。要拿到键值对,写 for k, v in d.items()。
  • 集合无序:{1,2,3} == {3,2,1} 为 True,但 {1,2,3}[0] 直接报错。
  • 字典的键必须是不可变类型。

最后这条值得实测一下:

1
2
3
4
5
6
print({(1, 2): 'ok'})

try:
bad = {[1, 2]: 'bad'}
except TypeError as e:
print("TypeError:", e)

输出:

1
2
{(1, 2): 'ok'}
TypeError: unhashable type: 'list'

元组可以当键,列表不行。 原因不在于「元组的名字更正式」,而在于字典要靠哈希定位,哈希要求对象在生命周期内不可变;列表随时能改,哈希值就不稳定了。这条区别是理解字典键约束的关键。

七、小结

陷阱 错误直觉 真相 证据
切片边界 [1:3] 取三个 左闭右开,取两个 digits[1:3] → [8, 9]
range 类型 以为是列表 惰性序列对象 range(5) == [0,1,2,3,4] → False
切片拷贝 以为是深拷贝 只复制一层 改 b[2] 影响 a
字典键 以为列表也能当键 键必须可哈希 {[1,2]: 'x'} → TypeError
for k in d 以为遍历键值对 遍历的是键 用 d.items()

三条能带走的:

  1. 切片左闭右开,i 取、j 不取。 记不住就背 a[:i] + a[i:] == a。
  2. 浅拷贝只复制一层。 判断「改这个会不会影响那个」,先问「改的是引用本身,还是共用对象的内容」。
  3. 选容器看操作:要顺序用 list,要映射用 dict,要去重和集合运算用 set。 选错容器,代码多写一半,性能还差一截。