Python四大容器核心操作速查表（全面版·v1.7 - 2025年11月7日修订）
📌 使用说明
- 时间复杂度：O(1)=常数级（快），O(n)=线性级（随数据量增长），O(k)=取决于传入可迭代对象长度
- 🔴 不可变容器 （元组）的增删改操作均为"间接实现"，直接操作会报错
- 🔵 可变容器 （列表/字典/集合）支持原地修改，部分方法带
_update后缀为"原地操作"
- ⚠️ 通用警告：可变容器嵌套结构需注意浅拷贝陷阱，建议使用
copy.deepcopy()处理多层嵌套
一、容器特性总览表
| 容器类型 |
核心特性 |
增删改查效率 |
适用场景 |
可哈希性 |
有序性说明 |
| 列表(list) |
可变、允许重复 |
末尾O(1)/中间O(n)、查索引O(1)/inO(n) |
动态有序数据、频繁修改 |
❌ 不可哈希 |
✅ 索引有序：通过0-based索引访问，顺序固定 |
| 元组(tuple) |
不可变、允许重复 |
增删改受限、查索引O(1) |
静态数据、函数返回值、字典键 |
✅ 可哈希（前提是所有元素均为可哈希类型；含嵌套可变对象时不可哈希，如(1, [2])） |
✅ 索引有序：创建后顺序不可变，可作字典键 |
| 字典(dict) |
可变、键唯一 |
O(1)平均（哈希表），最坏哈希冲突O(n) |
键值映射、快速查找 |
❌ 不可哈希 |
✅ 3.7+插入序：按键值对插入顺序保存，但不支持索引访问 |
| 集合(set) |
可变、元素唯一 |
O(1)平均（哈希表），最坏哈希冲突O(n) |
去重、集合关系判断 |
❌ 不可哈希 |
❌ 无序：底层哈希表实现，无固定顺序 |
二、列表（list）操作速查
| 操作类型 |
具体操作 |
语法示例 |
功能描述 |
时间复杂度 |
注意事项 |
| 增 |
append() |
lst.append(x) |
末尾添加单个元素 |
O(1) |
🔵 原地修改；支持嵌套 |
|
extend() |
lst.extend(iterable) |
批量添加可迭代对象元素 |
O(k) |
🔵 原地修改；与append()关键区别：append([4,5])添加后长度+1（嵌套列表），extend([4,5])添加后长度+2（拆解元素）；传入字符串会拆分为单个字符（append("ab") 新增元素 "ab"，extend("ab") 新增 'a' 和 'b'） |
|
insert() |
lst.insert(i, x) |
指定位置插入元素 |
O(n) |
🔵 后续元素后移；索引越界插入末尾 |
|
拼接 |
lst1 + lst2 |
返回新列表（原列表不变） |
O(n+k) |
⚠️ 非原地操作，内存开销大 |
| 删 |
remove() |
lst.remove(x) |
删除第一个匹配元素 |
O(n) |
🔵 元素不存在报错ValueError |
|
pop() |
lst.pop(i=-1) |
删除并返回指定位置元素 |
O(n) |
🔵 默认删末尾；空列表报错 |
|
del |
del lst[i] / del lst[s:e] |
按索引/切片删除 |
O(n) |
🔵 无返回值；支持批量删除 |
|
clear() |
lst.clear() |
清空所有元素 |
O(n) |
🔵 保留列表对象；不同 Python 解释器实现可能有差异，通用标注为 O(n)，实际部分环境（如 CPython）中效率更高 |
|
推导式过滤 |
[x for x in lst if cond] |
条件筛选保留元素 |
O(n) |
⚠️ 非原地，创建新列表 |
| 改 |
索引赋值 |
lst[i] = x |
修改指定位置元素 |
O(1) |
🔵 支持负索引 |
|
切片赋值 |
lst[s:e] = iterable |
批量替换元素 |
O(k) |
🔵 可改变长度；步长≠1时长度需匹配；示例：lst[::2] = [5,6] 正确，lst[::2] = [5] 错误（ValueError） |
| 查 |
索引访问 |
lst[i] / lst[-1] |
获取指定位置元素 |
O(1) |
负索引表示倒数 |
|
切片访问 |
lst[s:e:step] |
获取子列表 |
O(k) |
返回新列表；[::-1]反转 |
|
index() |
lst.index(x, start, end) |
查找元素首次出现索引 |
O(n) |
不存在报错；支持范围查找 |
|
count() |
lst.count(x) |
统计元素出现次数 |
O(n) |
不存在返回0 |
|
in |
x in lst |
判断元素是否存在 |
O(n) |
效率低于dict/set |
| 进阶 |
sort() |
lst.sort(key, reverse) |
原地排序（升序默认） |
O(n log n) |
🔵 修改原列表；元素需同类型 |
|
sorted() |
sorted(lst, key, reverse) |
返回新排序列表 |
O(n log n) |
⚠️ 原列表不变 |
|
reverse() |
lst.reverse() |
原地反转列表 |
O(n) |
🔵 修改原列表 |
|
浅拷贝 |
lst.copy() / lst[:] |
复制外层元素 |
O(n) |
⚠️ 嵌套容器共享引用；copy()是内置方法调用，切片通过新建对象复制元素，两者实现机制略有差异但效率相近 |
|
深拷贝 |
copy.deepcopy(lst) |
完全独立复制 |
O(n) |
需导入copy模块 |
|
enumerate() |
for i, x in enumerate(lst) |
遍历索引+元素 |
O(n) |
start参数控制索引起始值 |
三、元组（tuple）操作速查
| 操作类型 |
具体操作 |
语法示例 |
功能描述 |
时间复杂度 |
注意事项 |
| 增 |
拼接 |
tup1 + tup2 |
🔴 生成新元组（原元组不变） |
O(n+k) |
不可原地添加 |
|
重复 |
tup * n |
🔴 重复拼接生成新元组 |
O(n*k) |
边界值说明：n=0 时返回空元组，n=1 时返回原元组副本，n<0 报错 ValueError |
|
拆包 |
a, b, *rest = tup |
🔴 批量赋值变量 |
O(k) |
*接收剩余元素；_可忽略 |
| 删 |
del |
del tup |
🔴 删除整个元组对象 |
O(1) |
不支持删除单个元素 |
| 改 |
可变元素修改 |
tup[i][j] = x |
🔴 仅可修改内部可变对象内容 |
O(1) |
⚠️ 副作用警告：修改会影响所有引用该可变对象的变量，需谨慎 |
| 查 |
索引访问 |
tup[i] / tup[-1] |
获取指定位置元素 |
O(1) |
与列表完全一致 |
|
切片访问 |
tup[s:e:step] |
获取子元组 |
O(k) |
返回新元组 |
|
index() |
tup.index(x, start, end) |
查找元素首次索引 |
O(n) |
不存在报错 |
|
count() |
tup.count(x) |
统计元素出现次数 |
O(n) |
不存在返回0 |
|
in |
x in tup |
判断元素是否存在 |
O(n) |
同列表 |
| 进阶 |
namedtuple |
Point = namedtuple('Point', ['x', 'y'])
p = Point(1, 2) |
创建命名字段元组 |
O(1) |
通过属性访问：p.x返回1；p.y返回2，比索引更清晰 |
|
类型转换 |
list(tup) / tuple(lst) |
与list/set互转 |
O(n) |
转set会丢失顺序 |
|
作字典键 |
dic = {(1,2): "A点"} |
利用不可变性 |
O(1) |
需确保元组为可哈希类型（参考容器特性总览表） |
四、字典（dict）操作速查
| 操作类型 |
具体操作 |
语法示例 |
功能描述 |
时间复杂度 |
注意事项 |
| 增 |
键赋值 |
dic[k] = v |
添加/更新键值对（键存在则覆盖） |
O(1)平均 |
🔵 最常用方式；键必须可哈希（不可变类型，如数字/字符串/元组；列表/集合等可变类型会报错TypeError: unhashable type） |
|
update() |
dic.update(dic2) / dic.update([(k,v)]) / dic.update(k=v) |
批量添加/更新（支持字典/可迭代对象/关键字参数） |
O(k) |
🔵 灵活性高；后传入的相同键覆盖前值 |
|
|= |
dic1 |= dic2 |
🔵 合并字典（原地） |
O(k) |
Python 3.9+；相同键取后者 |
|
setdefault() |
dic.setdefault(k, default) |
键不存在时添加并返回默认值 |
O(1)平均 |
键已存在则返回原值 |
|
推导式 |
{k:v for k,v in iter} |
批量生成键值对 |
O(n) |
支持条件过滤 |
|
fromkeys() |
dict.fromkeys(seq, v) |
创建键来自序列的字典 |
O(k) |
⚠️ 可变值会共享引用所有键；避免方法：{k: [] for k in seq} |
| 删 |
pop() |
dic.pop(k, default) |
删除键并返回值（可设默认值） |
O(1)平均 |
🔵 不存在且无default报错KeyError |
|
popitem() |
dic.popitem() |
删除并返回最后插入的键值对 |
O(1)平均 |
🔵 Python 3.7+有序；空字典报错 |
|
del |
del dic[k] |
删除指定键 |
O(1)平均 |
🔵 键不存在报错KeyError |
|
clear() |
dic.clear() |
清空所有键值对 |
O(n) |
🔵 保留字典对象 |
|
推导式过滤 |
{k:v for k,v in dic.items() if cond} |
条件保留键值对 |
O(n) |
⚠️ 创建新字典 |
| 改 |
键赋值 |
dic[k] = 新值 |
修改已存在键的值 |
O(1)平均 |
🔵 键不存在则为新增 |
|
update() |
dic.update({k:新值}) |
批量修改值 |
O(k) |
🔵 键存在则更新 |
|
改键名 |
dic[新k] = dic.pop(旧k) |
间接修改键名（值不变） |
O(1)平均 |
🔵 先删后增，原子操作 |
| 查 |
键访问 |
dic[k] |
获取键对应的值 |
O(1)平均 |
不存在报错KeyError |
|
get() |
dic.get(k, default) |
安全获取值（可设默认值） |
O(1)平均 |
推荐用法；不存在不报错 |
|
in |
k in dic |
判断键是否存在（底层调用dic.__contains__(k)，等价但前者更常用） |
O(1)平均 |
只查键，不查值 |
|
items() |
items_view = dic.items() / for k,v in dic.items() |
获取键值对视图的引用 |
O(1) |
获取视图对象本身为O(1)；遍历视图的时间复杂度为O(n) |
|
keys() |
keys_view = dic.keys() / for k in dic.keys() |
获取键的视图引用 |
O(1) |
获取视图对象本身为O(1)；遍历视图的时间复杂度为O(n) |
|
values() |
values_view = dic.values() / for v in dic.values() |
获取值的视图引用 |
O(1) |
获取视图对象本身为O(1)；遍历视图的时间复杂度为O(n) |
|
查值存在 |
v in dic.values() |
判断值是否存在（需遍历） |
O(n) |
效率低；原字典值唯一时适用反向字典：{v:k for k,v in dic.items()}；若值重复需保留所有键，可使用 from collections import defaultdict; rev_dic = defaultdict(list); for k, v in dic.items(): rev_dic[v].append(k) |
| 进阶 |
遍历 |
for k in dic: / for k,v in dic.items(): |
多种遍历方式 |
O(n) |
默认遍历键；items()最常用 |
|
sorted() |
sorted(dic, key=lambda k: dic[k]) |
按键/值排序 |
O(n log n) |
返回键列表；需指定key |
|
深拷贝 |
copy.deepcopy(dic) |
完全独立复制 |
O(n) |
⚠️ 嵌套结构必须深拷贝 |
|
defaultdict |
defaultdict(list) |
自动初始化默认值 |
O(1)平均 |
需导入 from collections import defaultdict；示例：统计单词频率时dd['apple'] += 1无需提前判断键是否存在；场景：需自动初始化键对应的值（如列表、计数器） |
|
视图特性 |
view = dic.items() |
动态关联原字典 |
O(1) |
修改原字典，视图同步更新 |
五、集合（set）操作速查
| 操作类型 |
具体操作 |
语法示例 |
功能描述 |
时间复杂度 |
注意事项 |
| 增 |
add() |
s.add(x) |
添加单个元素（去重） |
O(1)平均 |
🔵 重复元素自动忽略 |
|
update() |
s.update(iterable) |
批量添加元素（自动去重） |
O(k)平均 |
🔵 字符串会被拆分字符 |
|
推导式 |
{x for x in iter if cond} |
条件生成集合 |
O(n) |
自动去重 |
| 删 |
discard() |
s.discard(x) |
删除元素（不存在不报错） |
O(1)平均 |
🔵 推荐优先使用 |
|
remove() |
s.remove(x) |
删除元素（不存在报错） |
O(1)平均 |
🔵 报错KeyError |
|
pop() |
s.pop() |
随机删除并返回一个元素 |
O(1)平均 |
🔵 空集合报错；无法指定位置 |
|
clear() |
s.clear() |
清空所有元素 |
O(n) |
🔵 保留集合对象 |
| 改 |
间接修改 |
s.discard(x); s.add(y) |
先删后增实现修改 |
O(1)平均 |
🔴 无直接修改方法 |
| 查 |
in |
x in s |
判断元素是否存在 |
O(1)平均 |
核心优势，远快于list |
|
遍历 |
for x in s: |
遍历所有元素 |
O(n) |
顺序不确定 |
| 集合运算 |
交集 |
s1 & s2 / s1.intersection(s2) |
返回共同元素 |
O(min(len)) |
支持多集合：s1 & s2 & s3；最坏情况O(n)；原地方法：s1.intersection_update(s2)（修改s1） |
|
并集 |
s1 | s2 / s1.union(s2) |
返回所有元素（去重） |
O(len(s1)+len(s2)) |
支持多集合；原地方法：s1.update(s2) 或 `s1 |
|
差集 |
s1 - s2 / s1.difference(s2) |
返回仅在s1的元素 |
O(len(s1)) |
s2 - s1结果不同；原地方法：s1.difference_update(s2) |
|
对称差集 |
s1 ^ s2 / s1.symmetric_difference(s2) |
返回仅在一个集合的元素 |
O(len(s1)+len(s2)) |
即并集减交集；原地方法：s1.symmetric_difference_update(s2) |
|
子集判断 |
s1 <= s2 / s1.issubset(s2) |
判断s1是否为s2子集 |
O(len(s1)) |
<为真子集（s1≠s2） |
|
超集判断 |
s1 >= s2 / s1.issuperset(s2) |
判断s1是否为s2超集 |
O(len(s2)) |
>为真超集（s1≠s2） |
|
无交集判断 |
s1.isdisjoint(s2) |
判断两集合是否无交集 |
O(min(len)) |
有交集返回False，无交集返回True |
| 进阶 |
frozenset |
fs = frozenset({1,2,3}) |
创建不可变集合 |
O(n) |
✅ 可哈希，可作字典键 |
|
类型转换 |
list(s) / tuple(s) |
转列表/元组（无序） |
O(n) |
⚠️ 顺序不确定，每次可能不同 |
|
去重应用 |
set(lst) |
列表去重最高效方式 |
O(n)平均 |
转回列表需用list(set(lst))，但会丢失原顺序；保留原顺序的去重可使用 list(dict.fromkeys(lst))（Python 3.7+，时间复杂度 O(n)） |
|
空集合 |
s = set() |
创建空集合 |
O(1) |
⚠️ {}是空字典，不是集合 |
六、通用操作与最佳实践
| 操作类型 |
语法示例 |
适用范围 |
说明 |
| 长度 |
len(container) |
list/tuple/dict/set |
O(1)获取元素个数 |
| 最值 |
max(c) / min(c) |
list/tuple/set |
元素需可比较；dict只比较键 |
| 求和 |
sum(c) |
list/tuple/set |
仅限数字元素；dict只累加键 |
| 迭代器 |
iter(c) + next() |
所有容器 |
手动控制迭代过程 |
| 空判断 |
if not c: |
list/tuple/dict/set |
空容器为False，推荐方式 |
| 浅拷贝陷阱 |
c.copy() / c[:] |
list/tuple/dict/set |
⚠️ 嵌套结构示例：lst=[1,[2]]; lst2=lst.copy(); lst2[1][0]=99会导致lst也被修改 |
|
深拷贝解决 |
copy.deepcopy(c) |
完全独立复制 |
| 元素类型限制 |
- |
dict键/set元素 |
必须可哈希（数字/字符串/元组/frozenset等不可变类型） |
七、选型决策树与性能优先级
需要存储数据？
├── 是否需要键值对映射？
│ ├── 是 → 字典(dict)
│ └── 否 → 是否需要去重？
│ ├── 是 → 集合(set)
│ └── 否 → 是否需要修改？
│ ├── 是 → 列表(list)
│ └── 否 → 元组(tuple)（更省内存、安全）
性能优先级：
- 查找最多：字典 > 集合 > 列表（O(1) vs O(n)）
- 修改最多：按位置修改场景：列表 > 字典 > 集合（列表支持索引直接修改）；按查找后修改场景：字典 > 集合 > 列表（哈希表查找效率更高）
- 内存最省：元组 > 列表 > 字典/集合（哈希表额外开销）
- 安全性：
- 结构安全性（避免容器本身被意外修改）：元组（不可变）> 深拷贝后的可变容器
- 数据独立性（避免嵌套对象跨引用修改）：深拷贝后的容器 > 元组（含嵌套可变对象时）
最坏情况提醒：
- 字典/集合：哈希冲突严重时，操作可能退化为O(n)
- 集合运算：集合大小差异极大时，交集运算接近O(min(len))
浙公网安备 33010602011771号