Python基本复合类型对比指南¶
1. 类型概述¶
想象你有一个神奇的工具箱！这个工具箱有四个特别的抽屉： - 列表抽屉：可以放任何东西，随时调整（List） - 元组抽屉：放好后就锁住，不能改（Tuple） - 字典抽屉：每个物品都有标签（Dict） - 集合抽屉：不允许重复的物品（Set）
2. 基本特性对比¶
2.1. 核心特性总览¶
| 特性 | 列表（List） | 元组（Tuple） | 字典（Dict） | 集合（Set） |
|---|---|---|---|---|
| 定义语法 | [1, 2, 3] |
(1, 2, 3) |
{"a": 1, "b": 2} |
{1, 2, 3} |
| 是否可变 | ✓ | × | ✓ | ✓ |
| 是否有序 | ✓ | ✓ | ✓ (Python 3.7+) | × |
| 元素唯一性 | 允许重复 | 允许重复 | 键唯一 | 元素唯一 |
| 索引访问 | ✓ | ✓ | × (用键访问) | × |
| 内存效率 | 中等 | 高 | 较高 | 高 |
| 查找效率 | O(n) | O(n) | O(1) | O(1) |
2.2. 创建方式对比¶
# 列表创建
list1 = [1, 2, 3] # 直接创建
list2 = list((1, 2, 3)) # 转换创建
list3 = [x for x in range(3)] # 推导式创建
# 元组创建
tuple1 = (1, 2, 3) # 直接创建
tuple2 = tuple([1, 2, 3]) # 转换创建
tuple3 = 1, 2, 3 # 省略括号
# 字典创建
dict1 = {"a": 1, "b": 2} # 直接创建
dict2 = dict(a=1, b=2) # 关键字创建
dict3 = dict([("a", 1)]) # 转换创建
# 集合创建
set1 = {1, 2, 3} # 直接创建
set2 = set([1, 2, 2, 3]) # 转换创建（自动去重）
set3 = {x for x in range(3)} # 推导式创建
3. 操作方法对比¶
3.1. 添加和删除元素¶
# 列表操作
lst = [1, 2]
lst.append(3) # 添加单个元素：[1, 2, 3]
lst.extend([4, 5]) # 添加多个元素：[1, 2, 3, 4, 5]
lst.remove(1) # 删除指定元素：[2, 3, 4, 5]
lst.pop() # 删除并返回最后一个元素：[2, 3, 4]
# 元组操作（不可变，只能重新创建）
t1 = (1, 2)
t2 = t1 + (3,) # 创建新元组：(1, 2, 3)
# 字典操作
d = {"a": 1}
d["b"] = 2 # 添加新键值对：{"a": 1, "b": 2}
d.update({"c": 3}) # 批量更新：{"a": 1, "b": 2, "c": 3}
del d["a"] # 删除键值对：{"b": 2, "c": 3}
d.pop("b") # 删除并返回值：{"c": 3}
# 集合操作
s = {1, 2}
s.add(3) # 添加元素：{1, 2, 3}
s.update({4, 5}) # 添加多个元素：{1, 2, 3, 4, 5}
s.remove(1) # 删除元素：{2, 3, 4, 5}
s.discard(2) # 安全删除：{3, 4, 5}
3.2. 查找和访问元素¶
# 列表访问
lst = [1, 2, 3, 4, 5]
print(lst[0]) # 索引访问：1
print(lst[-1]) # 负索引访问：5
print(lst[1:3]) # 切片访问：[2, 3]
# 元组访问
tup = (1, 2, 3, 4, 5)
print(tup[0]) # 索引访问：1
print(tup[-1]) # 负索引访问：5
print(tup[1:3]) # 切片访问：(2, 3)
# 字典访问
d = {"a": 1, "b": 2}
print(d["a"]) # 键访问：1
print(d.get("c", 0)) # 安全访问：0（默认值）
# 集合访问
s = {1, 2, 3}
print(2 in s) # 成员检查：True
print(4 in s) # 成员检查：False
3.3. 遍历方式¶
# 列表遍历
lst = [1, 2, 3]
for item in lst: # 直接遍历
print(item)
for i, item in enumerate(lst): # 带索引遍历
print(f"索引{i}: {item}")
# 元组遍历
tup = (1, 2, 3)
for item in tup: # 直接遍历
print(item)
for i, item in enumerate(tup): # 带索引遍历
print(f"索引{i}: {item}")
# 字典遍历
d = {"a": 1, "b": 2}
for key in d: # 遍历键
print(key)
for key, value in d.items(): # 遍历键值对
print(f"{key}: {value}")
# 集合遍历
s = {1, 2, 3}
for item in s: # 直接遍历
print(item)
4. 高级特性对比¶
4.1. 推导式¶
# 列表推导式
squares = [x**2 for x in range(5)] # [0, 1, 4, 9, 16]
# 字典推导式
square_dict = {x: x**2 for x in range(5)} # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
# 集合推导式
even_squares = {x**2 for x in range(5) if x % 2 == 0} # {0, 4, 16}
4.2. 特殊操作¶
# 列表排序
lst = [3, 1, 4, 1, 5]
lst.sort() # 原地排序
sorted_lst = sorted(lst) # 创建新的排序列表
# 字典合并（Python 3.9+）
dict1 = {"a": 1}
dict2 = {"b": 2}
merged = dict1 | dict2 # {"a": 1, "b": 2}
# 集合运算
set1 = {1, 2, 3}
set2 = {3, 4, 5}
print(set1 & set2) # 交集：{3}
print(set1 | set2) # 并集：{1, 2, 3, 4, 5}
print(set1 - set2) # 差集：{1, 2}
5. 应用场景对比¶
5.1. 列表应用场景¶
- 有序数据存储
- 数据序列处理
- 栈和队列实现
5.2. 元组应用场景¶
- 不可变数据存储
- 函数返回多个值
- 字典键使用
5.3. 字典应用场景¶
- 键值对映射
- 缓存实现
- 配置信息存储
5.4. 集合应用场景¶
- 去重操作
- 成员资格测试
- 数学集合运算
6. 性能特点对比¶
6.1. 时间复杂度¶
| 操作 | 列表 | 元组 | 字典 | 集合 |
|---|---|---|---|---|
| 查找 | O(n) | O(n) | O(1) | O(1) |
| 插入 | O(1)* | N/A | O(1) | O(1) |
| 删除 | O(n) | N/A | O(1) | O(1) |
| 遍历 | O(n) | O(n) | O(n) | O(n) |
*注：列表末尾插入为O(1)，中间插入为O(n)
6.2. 内存使用¶
- 列表：动态数组实现，额外空间较多
- 元组：静态数组实现，内存紧凑
- 字典：哈希表实现，空间换时间
- 集合：哈希表实现，去重节省空间
7. 选择建议¶
7.1. 使用列表的情况¶
- 需要频繁修改数据
- 需要保持元素顺序
- 需要存储重复元素
7.2. 使用元组的情况¶
- 数据不会被修改
- 作为字典的键
- 多个返回值打包
7.3. 使用字典的情况¶
- 需要键值对映射
- 需要快速查找
- 需要存储配置信息
7.4. 使用集合的情况¶
- 需要去除重复元素
- 需要快速成员检查
- 需要集合运算