Python 四大内置容器（list / tuple / dict / set）方法全景图：从入门到进阶的场景实战

前言

列表、元组、字典、集合是 Python 世界里的“四大名捕”。它们各有脾气，却又协同作战。本文以「功能 → 方法 → 场景」为主线，用 20 余段可直接复制运行的代码，带你一次性吃透它们最常用的 API。

一、列表 list：顺序世界的瑞士军刀

1、增

lst = [1, 2]
lst.append(3)            # [1, 2, 3]      尾部追加单个元素
lst.extend([4, 5])       # [1, 2, 3, 4, 5] 批量扩展，等价于 +=
lst.insert(1, 1.5)       # [1, 1.5, 2, 3, 4, 5] 按索引插入

2、删

lst.pop()                # 5  弹出并返回尾部元素
lst.pop(1)               # 1.5 按索引弹出
lst.remove(2)            # 删除首个值等于 2 的元素
lst.clear()              # []  一键清空

3、改 & 查

lst = [10, 20, 30]
lst[1] = 25              # 原地修改
lst.index(25)            # 1  获取值首次出现的位置
lst.count(20)            # 0  统计值出现次数
lst.reverse()            # 原地翻转
lst.sort(key=str)        # 原地排序，支持 key / reverse 参数
sorted_lst = sorted(lst) # 生成新的已排序列表，原列表不变

4、高阶技巧

# 列表解析一行筛偶数
even = [x for x in range(10) if x % 2 == 0]
# 原地洗牌
import random
random.shuffle(lst)

二、元组 tuple：不可变序列的“安全箱”

元组没有增删改方法，核心 API 聚焦在「只读查询」与「拆包」。

t = (5, 3, 5, 7)
t.count(5)      # 2  计数
t.index(7)      # 3  索引

# 拆包交换变量
a, b = 1, 2
a, b = b, a

# 具名元组让只读数据带字段
from collections import namedtuple
Point = namedtuple('Point', ['x', 'y'])
p = Point(4, 5)
print(p.x, p.y)   # 4 5

三、字典 dict：哈希世界的键值王者

1、增 & 改

d = {'a': 1}
d['b'] = 2               # 新增
d.update({'c': 3, 'a': 10})  # 批量更新/新增
d.setdefault('d', 4)     # 不存在才写入，返回最终值

2、删

d.pop('b')               # 2  按 key 删除并返回值
d.popitem()              # 随机弹出一对 (Py3.7 后为 LIFO)
del d['a']

3、查

d = {'name': 'Alice', 'age': 18}
d['name']                # 'Alice'  不存在抛 KeyError
d.get('gender', 'unknown')  # 'unknown'  安全取值
d.keys(); d.values(); d.items()  # 返回视图对象，可迭代

4、进阶玩法

# 字典解析一行统计字符频率
from collections import defaultdict
s = 'mississippi'
freq = defaultdict(int)
for ch in s:
    freq[ch] += 1
# 或直接：freq = {ch: s.count(ch) for ch in set(s)}

# 链式取值，避免多层 if
import os
port = os.environ.get('PORT') or 8000

四、集合 set：去重与关系运算的利器

1、增删

s = {1, 2}
s.add(3)                 # {1, 2, 3}
s.update([3, 4, 5])      # {1, 2, 3, 4, 5}
s.discard(5)             # 删除，不存在不报错
s.remove(2)              # 删除，不存在抛 KeyError

2、关系运算

a = {1, 2, 3}
b = {3, 4, 5}
a | b      # 并集 {1, 2, 3, 4, 5}
a & b      # 交集 {3}
a - b      # 差集 {1, 2}
a ^ b      # 对称差集 {1, 2, 4, 5}
a.issubset(b)   # False  子集判断

3、不可变集合

fs = frozenset([1, 2, 3])  # 可作为 dict 的 key

五、综合场景实战

场景 1：日志去重并按时间排序

logs = [
    {'time': '2025-07-12 10:01', 'msg': 'start'},
    {'time': '2025-07-12 10:02', 'msg': 'run'},
    {'time': '2025-07-12 10:01', 'msg': 'start'},  # 重复
]

# 用 set 去重，list 排序
seen = set()
unique_logs = []
for log in logs:
    key = (log['time'], log['msg'])
    if key not in seen:
        seen.add(key)
        unique_logs.append(log)

unique_logs.sort(key=lambda x: x['time'])

场景 2：使用 defaultdict 分组统计

from collections import defaultdict

data = [
    ('apple', 3),
    ('banana', 2),
    ('apple', 5),
    ('banana', 4),
]

basket = defaultdict(list)
for fruit, qty in data:
    basket[fruit].append(qty)

# {'apple': [3, 5], 'banana': [2, 4]}

场景 3：列表、集合混合实现“标签系统”

class TagSystem:
    def __init__(self):
        self._tag2item = defaultdict(set)
        self._item2tag = defaultdict(set)

    def add(self, item, *tags):
        for tag in tags:
            self._tag2item[tag].add(item)
            self._item2tag[item].add(tag)

    def items(self, tag):
        return list(self._tag2item[tag])

ts = TagSystem()
ts.add('python', 'lang', 'script')
ts.add('rust', 'lang', 'compiled')
print(ts.items('lang'))   # ['python', 'rust'] 或相反顺序

六、性能小贴士

1. 列表按索引访问 O(1)，但按值删除 O(n)；海量数据可考虑 deque 或自建索引。

2. 集合的 in 操作平均 O(1)，远超列表的 O(n)。

3. 字典遍历时增删键会触发「迭代器失效」；如需修改可先 list(d.items()) 冻结。

4. 元组比列表省内存 30%+，小对象可享「驻留机制」，重复字面量不会重复开辟空间。

七、结语

掌握四大容器，就像随身携带四把兵器：

• 列表是长枪，灵活可变；

• 元组是盾牌，坚固可靠；

• 字典是法典，一呼百应；

• 集合是利刃，去重如麻。

总结

把本文代码全部跑一遍，再把常用方法默写三遍，你会发现「官方文档」里那些零散的方法突然有了生命，排列组合出无限可能。Happy Pythoning！加油吧！！！永远相信美好的事情即将发生！