Python 核心内置容器（四大基础容器）

Python 最常用的基础容器有 4 种：列表（List）、元组（Tuple）、字典（Dictionary）、集合（Set），各自有明确的设计定位和使用场景。

1. 列表（List）：有序可变的动态数组

核心特性

• 有序性：元素按插入顺序排列，支持通过索引访问（索引从 0 开始）
• 可变性：允许添加、删除、修改元素（原地修改，无需创建新对象）
• 元素特性：可存储不同类型的元素（如整数、字符串、列表等），允许重复元素
• 语法标识：使用方括号 [] 定义

常用用法

# 1. 定义列表
empty_list = []  # 空列表
num_list = [1, 2, 3, 4, 5]  # 同类型元素列表
mix_list = [1, "Python", 3.14, [6, 7]]  # 不同类型元素列表

# 2. 索引访问与修改
print(num_list[0])  # 访问第一个元素，输出：1
print(num_list[-1])  # 反向索引，访问最后一个元素，输出：5
num_list[2] = 30  # 修改索引2的元素
print(num_list)  # 输出：[1, 2, 30, 4, 5]

# 3. 常用操作（增删改查）
num_list.append(6)  # 末尾添加元素，输出：[1, 2, 30, 4, 5, 6]
num_list.insert(1, 1.5)  # 在索引1处插入元素，输出：[1, 1.5, 2, 30, 4, 5, 6]
num_list.remove(30)  # 删除指定元素，输出：[1, 1.5, 2, 4, 5, 6]
num_list.pop()  # 删除末尾元素，输出：[1, 1.5, 2, 4, 5]
del num_list[1]  # 删除指定索引的元素，输出：[1, 2, 4, 5]

# 4. 其他常用方法
print(len(num_list))  # 获取长度，输出：4
print(sorted(num_list))  # 排序（返回新列表），输出：[1, 2, 4, 5]
num_list.reverse()  # 反转列表（原地修改），输出：[5, 4, 2, 1]

适用场景

• 存储需要频繁修改的有序数据（如用户列表、商品列表、成绩列表等）
• 需要按索引访问、排序、筛选的场景

2. 元组（Tuple）：有序不可变的静态数组

核心特性

• 有序性：元素按插入顺序排列，支持索引访问（与列表一致）
• 不可变性：一旦创建，无法添加、删除、修改元素（不可原地修改）
• 元素特性：可存储不同类型元素，允许重复元素
• 语法标识：使用圆括号 () 定义，单个元素的元组需加逗号（如 (1,)）

常用用法

# 1. 定义元组
empty_tuple = ()  # 空元组
num_tuple = (1, 2, 3, 4, 5)  # 同类型元素元组
mix_tuple = (1, "Python", 3.14, (6, 7))  # 不同类型元素元组
single_tuple = (1,)  # 单个元素元组（必须加逗号，否则视为普通变量）

# 2. 索引访问（无法修改）
print(num_tuple[0])  # 输出：1
print(num_tuple[-2])  # 输出：4
# num_tuple[2] = 30  # 报错：TypeError，元组不可修改

# 3. 常用操作
print(len(num_tuple))  # 获取长度，输出：5
print(sorted(num_tuple))  # 排序（返回列表，非原地修改），输出：[1, 2, 3, 4, 5]
print(num_tuple.count(3))  # 统计元素出现次数，输出：1
print(num_tuple.index(4))  # 查找元素索引，输出：3

# 4. 元组解包
a, b, c, d, e = num_tuple
print(a, b, c)  # 输出：1 2 3

适用场景

• 存储无需修改的有序数据（如坐标 (x, y)、配置信息、函数返回多值等）
• 作为字典的键（不可变类型才可作为字典键）、集合的元素
• 追求数据安全性和执行效率的场景（元组比列表更轻量、速度更快）

3. 字典（Dictionary，Dict）：无序（Python3.7 + 有序）的键值对集合

核心特性

• 键值对结构：每个元素由「键（key）」和「值（value）」组成，通过键访问值
• 键的特性：键必须是不可变类型（字符串、数字、元组），唯一不重复；值可以是任意类型，允许重复
• 有序性：Python3.7 及以上版本按插入顺序保存，Python3.6 及以下无序
• 可变性：允许添加、删除、修改键值对
• 语法标识：使用大括号 {} 定义，格式为 {key1: value1, key2: value2}

常用用法

# 1. 定义字典
empty_dict = {}  # 空字典
student_dict = {
    "name": "小明",
    "age": 18,
    "score": 92.5,
    "subjects": ["语文", "数学"]
}  # 常规字典

# 2. 访问与修改值
print(student_dict["name"])  # 通过键访问，输出：小明
print(student_dict.get("age"))  # 推荐：get方法访问（键不存在返回None，不报错）
student_dict["age"] = 19  # 修改值
student_dict["gender"] = "男"  # 添加新的键值对
print(student_dict)  # 输出：{'name': '小明', 'age': 19, 'score': 92.5, 'subjects': ['语文', '数学'], 'gender': '男'}

# 3. 常用操作（增删改查）
del student_dict["score"]  # 删除指定键值对
student_dict.pop("gender")  # 删除指定键值对（返回值）
student_dict.clear()  # 清空字典

# 4. 遍历字典
student_dict = {"name": "小明", "age": 18, "score": 92.5}
for key in student_dict:  # 遍历键（默认）
    print(key, student_dict[key])
for value in student_dict.values():  # 遍历值
    print(value)
for key, value in student_dict.items():  # 遍历键值对（推荐）
    print(f"{key}：{value}")

适用场景

• 存储具有映射关系的数据（如用户信息、配置项、商品属性等）
• 需要通过唯一标识（键）快速查找数据的场景（字典查找效率远高于列表）

4. 集合（Set）：无序不重复的元素集合

核心特性

• 无序性：元素无固定顺序，不支持索引访问
• 唯一性：自动去重，不允许重复元素
• 元素特性：元素必须是不可变类型（字符串、数字、元组），不支持列表、字典等可变类型
• 可变性：允许添加、删除元素
• 语法标识：使用大括号 {} 定义（空集合需用 set()，不可用 {}）

常用用法

# 1. 定义集合
empty_set = set()  # 空集合（不可用{}，{}是空字典）
num_set = {1, 2, 3, 4, 5}  # 常规集合
mix_set = {1, "Python", 3.14, (6, 7)}  # 元素为不可变类型
duplicate_set = {1, 2, 2, 3, 3, 3}  # 自动去重，实际为 {1, 2, 3}

# 2. 常用操作（增删）
num_set.add(6)  # 添加单个元素
num_set.update([7, 8])  # 添加多个元素（可迭代对象）
num_set.remove(3)  # 删除指定元素（元素不存在报错）
num_set.discard(10)  # 删除指定元素（元素不存在不报错）
num_set.pop()  # 随机删除一个元素（无序性）
num_set.clear()  # 清空集合

# 3. 集合运算（交集、并集、差集等）
set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}
print(set1 & set2)  # 交集（共同元素），输出：{3, 4}
print(set1 | set2)  # 并集（所有元素，去重），输出：{1, 2, 3, 4, 5, 6}
print(set1 - set2)  # 差集（set1有，set2无），输出：{1, 2}
print(set1 ^ set2)  # 对称差集（互不相同的元素），输出：{1, 2, 5, 6}

适用场景

• 去重操作（如列表去重 list(set(lst))）
• 集合运算（如查找两个列表的共同元素、差异元素）
• 快速判断元素是否存在（集合的查找效率远高于列表）

二、四大基础容器核心对比

容器类型	有序性	可变性	元素特性	访问方式	语法标识	核心用途
列表（List）	是	是	可重复、支持任意类型	索引	[]	存储可变有序数据
元组（Tuple）	是	否	可重复、支持任意类型	索引	()	存储不可变有序数据
字典（Dict）	Python3.7 + 是	是	键唯一（不可变类型）、值任意	键	{key:value}	存储键值对映射数据
集合（Set）	否	是	不可重复、元素为不可变类型	成员判断	{}/set()	去重、集合运算

三、Python 进阶容器（collections 模块）

除了基础容器，Python 的 collections 模块提供了更多专用容器，用于解决特定场景的问题，提升开发效率。

1. 有序字典（OrderedDict）

• 特性：Python3.7 前字典无序，OrderedDict 保证键值对按插入顺序排列（Python3.7+ 普通字典已支持有序，使用场景减少）
• 用法：

from collections import OrderedDict

od = OrderedDict()
od["a"] = 1
od["b"] = 2
od["c"] = 3
for key, value in od.items():
    print(key, value)  # 按插入顺序输出：a 1、b 2、c 3

2. 默认字典（defaultdict）

• 特性：访问不存在的键时，会自动创建该键并赋予默认值（无需手动判断键是否存在）
• 用法：

from collections import defaultdict

# 默认值为列表
dd = defaultdict(list)
dd["subjects"].append("语文")
dd["subjects"].append("数学")
print(dd)  # 输出：defaultdict(<class 'list'>, {'subjects': ['语文', '数学']})

# 默认值为整数
dd2 = defaultdict(int)
dd2["count"] += 1
print(dd2["count"])  # 输出：1

3. 双端队列（deque）

• 特性：支持从两端快速添加 / 删除元素（列表的头部操作效率低，deque 更高效）
• 用法：

from collections import deque

dq = deque([1, 2, 3])
dq.append(4)  # 右端添加
dq.appendleft(0)  # 左端添加
print(dq)  # 输出：deque([0, 1, 2, 3, 4])
dq.pop()  # 右端删除
dq.popleft()  # 左端删除
print(dq)  # 输出：deque([1, 2, 3])

4. 计数器（Counter）

• 特性：快速统计可迭代对象中元素的出现次数
• 用法：

from collections import Counter

lst = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
cnt = Counter(lst)
print(cnt)  # 输出：Counter({4: 4, 3: 3, 2: 2, 1: 1})
print(cnt.most_common(2))  # 获取出现次数最多的2个元素，输出：[(4, 4), (3, 3)]

总结

1. 基础容器是 Python 核心：列表（可变有序）、元组（不可变有序）、字典（键值对映射）、集合（无序去重），覆盖绝大多数常规场景。
2. 容器选择依据：是否有序、是否可变、是否需要映射关系、是否需要去重，对应选择合适的容器类型。
3. 进阶容器（collections 模块）：针对特定场景优化，如 defaultdict 解决键不存在问题、deque 提升两端操作效率、Counter 快速统计元素次数。