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

NOTE
基于 Python 3。

列表#

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)
6
print(len(fruits))

list 有序、可变。下标从 0 起，负数从末尾数。切片左闭右开。

list、tuple、字符串都能做这些事（Common Sequence Operations）：in、+、*、[]、切片、len、min / max。

索引与切片#

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

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)]。

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 可原地增删改（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_range = list(range(3))      # [0, 1, 2]

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()。

元组 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']

调用函数时，* 把列表展开成多个参数：print(*[1, 2, 3]) 相当于 print(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
Tuples and Sequences

PEP：

菜鸟教程：

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