容器操作与解包

append、extend 与加法

items = [1, 2]
items.append([3, 4])
print(items)  # [1, 2, [3, 4]]

append(x) 把 x 作为一个元素追加；extend(iterable) 遍历参数，把其中元素逐个追加：

items = [1, 2]
items.extend([3, 4])
print(items)  # [1, 2, 3, 4]

items.extend("ab")
print(items)  # [1, 2, 3, 4, "a", "b"]

写法	是否原地修改	返回值	参数含义
a.append(x)	是	None	单个对象
a.extend(xs)	是	None	任意 Iterable
a += xs	通常是	修改后的对象	Iterable，List 上近似 extend
a + b	否	新 List	两边必须是 List
[*a, *xs]	否	新 List	xs 为 Iterable

不要写：

items = items.append(3)  # items 变成 None

可变容器的方法通常原地修改并返回 None，用于阻止误以为它们创建了新对象的链式写法。

切片赋值

切片读取创建浅层新 List，切片赋值修改原 List，长度还可以变化：

values = [0, 1, 2, 3]
copy_values = values[:]
values[1:3] = [10, 11, 12]

print(values)       # [0, 10, 11, 12, 3]
print(copy_values)  # [0, 1, 2, 3]

del values[:]、values.clear() 都会清空原对象；values = [] 只是把当前变量重新绑定到新 List，其他引用仍指向旧对象。

重复运算的共享引用

matrix = [[0] * 3] * 2
matrix[0][0] = 9
print(matrix)  # [[9, 0, 0], [9, 0, 0]]

* 2 复制的是内部 List 的引用。应为每一行创建独立对象：

matrix = [[0] * 3 for _ in range(2)]

字典更新与合并

base = {"timeout": 1, "retries": 2}
override = {"timeout": 5}

merged = {**base, **override}
also_merged = base | override
base.update(override)

后出现的同名 Key 覆盖前值。{**a, **b} 和 a | b 创建新字典，update 与 |= 修改左侧字典。

setdefault 只有 Key 不存在时才写入，但默认值表达式会在调用前求值：

cache.setdefault(key, expensive())  # 即使 key 已存在，expensive() 仍会执行

需要避免无效计算时先判断 Key，或使用 defaultdict、显式工厂逻辑。

星号解包

* 在容器字面量和函数调用中展开 Iterable，** 展开 Mapping：

head = [1, 2]
tail = (3, 4)
values = [0, *head, *tail]  # [0, 1, 2, 3, 4]

options = {"timeout": 3}
request("/orders", **options)

赋值中的 *rest 会收集为 List：

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

函数调用中重复传递同一个关键字会抛出 TypeError；字典字面量中的重复 Key 则由后值覆盖。这两个 ** 场景不能混为一谈。

排序

values.sort()          # 原地修改，返回 None
ordered = sorted(values)  # 返回新 List，可接收任意 Iterable

key 函数对每个元素计算一次排序键：

users = sorted(users, key=lambda user: (user.age, user.name))

Python 排序是稳定的，相同 Key 的元素保持原相对顺序。不要写 sorted(items, key=lambda x: compare(x)) 模拟两两比较；遗留 Comparator 可用 functools.cmp_to_key 适配。