Python 札记 (4) - 初五的小窝

NOTE
目录骨架来自菜鸟教程 Python3 数据结构章节，表述与细节对照 Python 官方文档与相关 PEP 核对。基于 Python 3。完整出处见文末参考。

序列共性#

Common Sequence Operations 对 list、tuple、range（以及 str、bytes、bytearray）大多适用：

操作	含义	备注
`x in s` / `x not in s`	成员测试
`s + t`	拼接	得到新序列
`s * n` / `n * s`	重复	元素是引用，不是深拷贝
`s[i]`	下标访问	从 0 起；负索引从末尾数
`s[i:j]` / `s[i:j:k]`	切片	左闭右开；步长 `k` 不可为 0
`len(s)`	长度
`min(s)` / `max(s)`	最小 / 最大	元素需可比较

1
fruits = ["apple", "banana", "cherry"]
2
print(fruits[0])       # apple
3
print(fruits[-1])      # cherry
4
print(fruits[1:3])     # ['banana', 'cherry']
5
print("banana" in fruits)  # True
6
print(len(fruits))     # 3
7
print(min(fruits), max(fruits))

索引与切片细节#

负索引 i 等价于 len(s) + i。切片 [i:j] 在 i >= j 时为空；省略 i 视为 0，省略 j 视为 len(s)。带步长 [i:j:k] 时，k 为负则方向反向，且 i、j 会被截断到合法范围（见官方「Common Sequence Operations」Notes）。

1
nums = [0, 1, 2, 3, 4, 5]
2
print(nums[::2])    # [0, 2, 4]
3
print(nums[::-1])   # 新 list，原 list 不变
4
print(nums[4:1:-1]) # [4, 3, 2]

拼接、重复与陷阱#

s + t 与 s * n 都产生新对象。对可变序列反复 += 拼接，官方提醒总长度呈二次方开销；大量拼接应改用 extend 或 str.join 等线性方案。

[[]] * 3 会让三个元素指向同一个内层 list——改一个，三个一起变。要三个独立空 list，用 [[] for _ in range(3)]（官方 FAQ 有说明）。

count 与 index#

序列还支持（部分类型对 start/stop 有限制）：

1
letters = ["a", "b", "c", "b"]
2
print(letters.count("b"))   # 2
3
print(letters.index("c"))   # 2
4
# letters.index("z")        # ValueError

列表 list：可变序列#

list 可原地增删改。除共性操作外，还支持赋值、删除、扩展等（Mutable Sequence Types）：

操作	效果
`s[i] = x`	替换下标 `i`
`del s[i]`	删除下标 `i`
`s[i:j] = t`	用可迭代对象 `t` 替换切片
`del s[i:j]`	删除切片（同 `s[i:j] = []`）
`s += t`	原地扩展，大致同 `s[len(s):len(s)] = t`
`s *= n`	原地重复 `n` 次

创建列表#

1
empty = []
2
from_literal = [1, 2, 3]
3
from_iter = list("abc")          # ['a', 'b', 'c']
4
from_comp = [x * 2 for x in range(3)]  # 推导式第 6 篇详讲

list(iterable) 若参数已是 list，会返回浅拷贝（类似 iterable[:]）。

常用方法（入门优先）#

下面几个日常最常用；完整签名与语义见文末附录。

append(x) — 在末尾追加一个元素（不是展开可迭代对象）：

1
stack = [1, 2]
2
stack.append(3)       # [1, 2, 3]
3
stack.append([4, 5])  # [1, 2, 3, [4, 5]]

extend(iterable) — 把可迭代对象里的元素逐个追加：

1
a = [1, 2]
2
a.extend([3, 4])      # [1, 2, 3, 4]
3
# 等价于 a[len(a):len(a)] = [3, 4]

insert(index, x) — 在指定位置插入；等价于 s[index:index] = [x]。

pop([index=-1]) — 取出并删除元素，默认最后一个；空序列或越界会 IndexError。

remove(value) — 删除第一个等于 value 的项；找不到则 ValueError（按 == 比较）。

sort(*, key=None, reverse=False) — 原地排序，只使用 < 比较；返回 None。稳定排序。要新列表用内置 sorted(s)。

reverse() — 原地反转，返回 None。

copy() — 浅拷贝，等价于 s[:]（Python 3.3+）。

1
items = [3, 1, 4, 1, 5]
2
items.sort()
3
print(items)              # [1, 1, 3, 4, 5]
4
items.sort(reverse=True)
5
print(items)              # [5, 4, 3, 1, 1]
6

7
dup = items.copy()
8
dup.reverse()
9
print(dup)                # [1, 1, 3, 4, 5]

原地方法（sort、reverse、append 等）为提醒「有副作用」，多数返回 None；不要写 x = lst.sort()。

浅拷贝与嵌套#

copy() 与 [:] 只复制一层。内层可变对象仍共享：

1
matrix = [[1], [2]]
2
shadow = matrix.copy()
3
shadow[0].append(9)
4
print(matrix)   # [[1, 9], [2]] — 内层 list 共用

需要独立嵌套结构时，用 copy.deepcopy()（copy 模块，超出本篇）。

元组 tuple：不可变序列#

tuple 创建后不能通过 t[i] = x 改元素，也没有 append、sort 等原地方法。优势：可哈希（元素都哈希时）、占内存通常更小、语义上表达「固定字段组合」。

创建与「逗号才是 tuple」#

1
empty = ()
2
singleton = (42,)      # 单元素必须带逗号
3
not_tuple = (42)     # 这是 int，括号只是分组
4
pair = 1, 2          # 逗号构成 tuple，括号可省略
5
from_iter = tuple([1, 2, 3])

官方说明：真正构成 tuple 的是逗号，括号常可省略；空 tuple 必须是 ()，单元素时 (a,) 避免与表达式分组混淆。

不可变 ≠ 内容全不可变#

tuple 不能换引用，但若元素是可变对象，对象内部仍可改：

1
t = ([1, 2], "ok")
2
t[0].append(3)   # 合法
3
print(t)         # ([1, 2, 3], 'ok')
4
# t[0] = []      # TypeError: 不能改 tuple 里的引用

含不可哈希元素的 tuple 不能作 dict 键或 set 元素。

哈希与 dict 键#

不可变且元素均可哈希的 tuple 可 hash()，能当 dict 键：

1
point_index = {(0, 0): "origin", (1, 0): "east"}
2
print(point_index[(0, 0)])

解包#

平行赋值#

1
a, b, c = [1, 2, 3]
2
a, b = b, a          # 交换，无需临时变量

左侧变量个数须与右侧可迭代对象长度一致，否则 ValueError。

带 * 的扩展解包#

PEP 3132 / PEP 448：一个带 * 的目标收集「剩余」元素为 list：

1
first, *middle, last = [1, 2, 3, 4, 5]
2
print(first, middle, last)   # 1 [2, 3, 4] 5
3

4
head, *tail = "Python"
5
print(head, tail)            # P ['y', 't', 'h', 'o', 'n']

函数调用里 *args 把可迭代对象展开为位置参数；定义处 *args 则收集多余位置参数——与解包方向相反，别混。

1
def show(a, b, c):
2
    print(a, b, c)
3

4
show(*[1, 2, 3])   # 1 2 3

忽略部分值#

用 _ 作占位（约定俗成，不是语法）：

1
name, _, city = ("Alice", 28, "Seoul")

list 与 tuple 怎么选#

场景	倾向
长度或内容会变	`list`
固定字段、函数多返回值	`tuple`
作 dict 键 / set 元素	元素可哈希的 `tuple`
大量只读数据	`tuple` 略省内存

需要「命名访问」时，官方推荐 collections.namedtuple 或 dataclass。

附录：list 可变序列方法全集#

以下摘自 Mutable Sequence Types 与 Lists。list 另独有 sort()。

方法	说明	返回值
`append(value)`	末尾追加一项	`None`
`clear()`	删除全部（同 `del s[:]`）	`None`
`copy()`	浅拷贝（同 `s[:]`）	新 `list`
`extend(iterable)`	追加 iterable 中各项	`None`
`insert(index, value)`	在 index 处插入	`None`
`pop(index=-1)`	取出并删除 index 处项	被删元素
`remove(value)`	删除首个等于 value 的项	`None`
`reverse()`	原地反转	`None`
`sort(*, key=None, reverse=False)`	原地排序（仅 list）	`None`

序列共有的 count(value)、index(value[, start[, stop]]) 见上文。

tuple 可用操作小结#

tuple 仅实现不可变序列操作：+、*、in、len、min、max、索引切片、count、index。无 append、sort 等。

参考#

官方文档（中文版可对照阅读）：

Sequence Types — list, tuple, range — 共性操作、可变/不可变区分
Common Sequence Operations — 索引、切片、拼接、重复
Mutable Sequence Types — 原地赋值、删除、方法表
Lists — 构造、sort() 关键字参数
Tuples — 单元素逗号、括号与逗号
More on Lists — 教程视角的 list 用法
Tuples and Sequences — 教程中的 tuple 示例

PEP：

目录来源（骨架，不以它为准改语法）：

菜鸟教程 · 数据结构 — list / tuple 章节