一、快速对比

二、各自特点与最常用方法

1. 列表 —— 最灵活的序列

特点：动态数组，支持索引、切片、解包；增删改查功能丰富；常用推导式快速生成。

常用方法（假设 lst = [2, 4, 6]）：

# 增
lst.append(8)           # 尾部追加 -> [2,4,6,8]
lst.insert(1, 3)        # 在索引1处插入3 -> [2,3,4,6,8]
lst.extend([10, 12])    # 扩展多个元素 -> [2,3,4,6,8,10,12]

# 删
lst.remove(6)           # 删除第一个值为6的元素
lst.pop()               # 删除并返回最后一个元素（也可指定索引）
lst.clear()             # 清空列表

# 查与排序
lst.index(4)            # 返回4首次出现的索引
lst.count(2)            # 统计2出现次数
lst.sort()              # 原地升序排序
lst.sort(reverse=True)  # 原地降序
new = sorted(lst)       # 返回新列表，原列表不变
lst.reverse()           # 原地反转

# 复制
b = lst.copy()          # 浅拷贝
# 常用操作：len(lst), 成员判断 in, 切片 lst[1:3], 列表推导式 [x*2 for x in lst]

2. 元组 —— 不可变的“记录”

特点：一旦创建不能修改，因此更安全、可哈希；常用于坐标、数据库记录、函数返回多个值。

常用方法（仅两个）：

t = (1, 2, 2, 3, 2)
t.count(2)   # 统计2的出现次数 -> 3
t.index(3)   # 查找3第一次出现的索引 -> 3
# 支持：len(t), 索引 t[0], 切片 t[1:3], 解包 a, b, c = t
# 注意：单元素元组须加逗号 (42,)

3. 字典 —— 键值对仓库

特点：以键（key）进行超快查找；键必须是不可变且可哈希的类型（如字符串、数字、元组）。3.7+ 版本保持插入顺序。

常用方法：

d = {'a': 1, 'b': 2}
# 增 / 改
d['c'] = 3              # 直接赋值，若键存在则修改
d.update({'b': 20, 'd': 4})  # 批量更新/添加
d.setdefault('e', 5)   # 若键不存在则设为5，返回最终值

# 删
d.pop('a')              # 删除键并返回值（可设默认值防报错）
d.popitem()             # 删除并返回最后插入的键值对（3.7+）
d.clear()

# 查
d.get('x', 0)           # 安全取值，不存在时返回0
d.keys()                # 返回所有键的视图
d.values()              # 返回所有值的视图
d.items()               # 返回所有(键,值)对的视图
# 遍历 for k, v in d.items()

# 合并（Python 3.9+）
d1 | d2                 # 返回合并后的新字典（后者覆盖前者键）
d1 |= d2                # 原地更新合并

4. 集合 —— 不重复元素的容器

特点：无序、不重复，自动去重；支持数学中的交集、并集、差集等操作，适合成员检测和去重。

常用方法：

s = {1, 2, 3}
# 增删（注意重复元素不会加入）
s.add(4)                # 添加单个元素
s.remove(2)             # 删除元素，若不存在会报错
s.discard(2)            # 安全删除，不存在不报错
s.pop()                 # 随机删除并返回一个元素
s.clear()

# 集合运算（返回新集合）
a = {1, 2, 3}
b = {2, 3, 4}
a | b          # 并集 {1,2,3,4}
a & b          # 交集 {2,3}
a - b          # 差集（只在a中） {1}
a ^ b          # 对称差集（只在一边） {1,4}

# 原地更新（修改原集合）
a.update(b)                # a = a | b
a.intersection_update(b)   # a = a & b
a.difference_update(b)     # a = a - b
a.symmetric_difference_update(b)  # a = a ^ b

# 关系判断
a.issubset(b)         # a是不是b的子集
a.issuperset(b)       # a是不是b的超集
a.isdisjoint(b)       # a和b是否没有交集