Python 中的列表（List）、元组（Tuple）、字典（Dict）和集合（Set）是四种最常用的核心数据结构。掌握它们的基础操作只是第一步，真正发挥威力的是那些高级用法和技巧。

首先我们先看一下这4种类型的详细对比，确定我们在开发的时候怎么选择使用哪一种类型。

总结与选择建议：

• 需要存储一个有序且可能变化的序列吗？ -> 选择 列表。
• 需要存储一组不可变的、作为键或保证安全的数据吗？ -> 选择 元组。
• 需要通过唯一的键来快速查找和关联值吗？ -> 选择 字典。
• 需要保证元素的唯一性，或进行集合运算（如去重、求交集并集）吗？ -> 选择 集合。

列表 (List) 的高级用法

列表的强大远超基础的增删改查。

1. 列表推导式 (List Comprehension)。

这是编写 Pythonic 代码的利器，它用简洁的语法快速生成新列表

# 基础：快速生成平方数列表 
squares = [x**2 for x in range(10)]# [0, 1, 4, 9, ..., 81] 

# 带条件过滤：生成偶数的平方 
even_squares = [x**2 for x in range(10) if x % 2 == 0]# [0, 4, 16, 36, 64] 

# 多重循环：模拟嵌套循环，生成全排列 
pairs = [(x, y) for x in ['A', 'B'] for y in [1, 2]] 
# 结果: [('A', 1), ('A', 2), ('B', 1), ('B', 2)]

2. 切片赋值与高级切片。

切片不仅可以取数据，还可以批量修改、删除甚至插入数据

my_list = [1, 2, 3, 4, 5] 

# 批量替换子序列 my_list[1:4] = [20, 30, 40]# my_list 变为 [1, 20, 30, 40, 5] 

# 批量删除子序列 (用空列表替换) my_list[1:4] = []# my_list 变为 [1, 5] 

# 使用步长进行间隔替换（数量必须匹配） my_list[::2] = [100, 200]# 将第1、3个元素替换为100, 200

3. 与 map, filter, zip等函数式工具结合

这些内置函数让列表处理更高效和声明式。

numbers = ['1', '2', '3'] 

# map: 将函数应用于列表每个元素 int_list = list(map(int, numbers))  # [1, 2, 3] 

# filter: 过滤列表中满足条件的元素 even_list = list(filter(lambda x: x % 2 == 0, [1,2,3,4]))  # [2, 4] 

# zip: 将多个列表对应位置的元素"打包"成元组 
names = ['Alice', 'Bob'] 
scores = [85, 92] 
zipped = list(zip(names, scores))  # [('Alice', 85), ('Bob', 92)] 

# 用zip优雅地同步遍历多个列表 
for name, score in zip(names, scores): 
		print(f"{name}: {score}")

4. 性能注意事项

• 列表在尾部进行 append和 pop操作很快（O(1)时间复杂度）。
• 在头部或中部进行 insert或 pop操作可能较慢（O(n)时间复杂度），因为需要移动后续元素。
• 对于需要频繁在两端进行添加或删除操作的场景，可以考虑使用 collections.deque（双端队列），它在队列两端都有出色的性能表现。

元组 (Tuple) 的高级用法

元组的“不可变性”是其核心优势，带来了安全、高效和可哈希的特性。

1. 解包 (Unpacking)。

这是元组最优雅的特性之一，可以一次性将元组元素赋值给多个变量

# 基本解包 
point = (10, 20) 
x, y = point# x=10, y=20 

# 使用 * 进行可变长度解包 (Python 3) 
numbers = (1, 2, 3, 4, 5) 
first, *middle, last = numbers# first=1, middle=[2,3,4], last=5 
a, *b, c, d = numbers# a=1, b=[2,3], c=4, d=5 

# 在循环中解包 
for name, score in zipped:# 接上文zip的例子 
		print(f"{name}'s score is {score}") 

# 使用下划线 _ 忽略不需要的值 
name, _, salary = ("Alice", "Engineer", 50000)  # 忽略职位

2. 作为字典的键或集合的元素。

由于元组是不可变的、可哈希的，它可以作为字典的键，这是列表无法做到的

# 用元组表示坐标，作为字典的键 
location_map = {
      (40.7128, -74.0060): "New York",
      (34.0522, -118.2437): "Los Angeles"
} 
print(location_map[(40.7128, -74.0060)])# 输出: New York 

# 元组也可以放入集合中（需确保所有元素都可哈希） 
unique_points = {(1, 2), (3, 4), (1, 2)}    # {(1, 2), (3, 4)}

3. 命名元组 (Named Tuple)。

collections.namedtuple让元组不仅有序号，还有了名字，极大提升了代码的可读性

from collections import namedtuple 

# 定义一个命名元组类型 'Person' 
Person = namedtuple('Person', ['name', 'age', 'job']) 

# 创建命名元组实例 
alice = Person(name="Alice", age=30, job="Engineer") 

# 通过字段名访问，意义明确 
print(alice.name)    # Alice 
print(alice.job)    # Engineer 

# 仍然支持索引访问 
print(alice[0])    # Alice

4. 函数返回多个值。

本质上，Python 函数返回多个值就是返回一个元组

def calculate_stats(data): 
		total = sum(data)
		count = len(data) 
		average = total / count return total, count, average    # 返回一个元组 (total, count, average) 

# 接收返回值时常用解包 
total, count, avg = calculate_stats([1, 2, 3, 4, 5])

字典 (Dict) 的高级用法

字典的核心在于基于键的快速查找（O(1)平均时间复杂度）。

1. 字典推导式 (Dict Comprehension)。

与列表推导式类似，可以快速简洁地创建字典

# 快速创建键值对 
squares = {x: x*x for x in range(5)}# {0: 0, 1: 1, 2: 4, 3: 9, 4: 16} 

# 交换键和值（前提是值都是可哈希的） 
original = {'a': 1, 'b': 2} 
swapped = {v: k for k, v in original.items()}# {1: 'a', 2: 'b'} 

# 带条件的推导式 
even_squares = {x: x*x for x in range(10) if x % 2 == 0}

2. setdefault和 get方法安全访问

这些方法可以优雅地处理键可能不存在的情况，避免 KeyError。

my_dict = {'name': 'Alice', 'age': 30} 
# get(key, default): 键不存在时返回默认值，不会引发异常 
job = my_dict.get('job', 'Unemployed')# 'Unemployed' 
age = my_dict.get('age')# 30 

# setdefault(key, default): 键不存在时，设置键值并返回默认值；键存在则返回对应的值 
# 常用于初始化列表、集合等值，避免重复判断 
data = {} 
for item in ['A', 'B', 'A', 'C']: 
		# 如果键不存在，将键对应的值初始化为空列表，然后追加元素 
    data.setdefault(item, []).append(f"Value_{item}") 
# data: {'A': ['Value_A', 'Value_A'], 'B': ['Value_B'], 'C': ['Value_C']}

3. 字典合并 (Merging Dictionaries)

有多种方式可以将多个字典合并为一个。

d1 = {'a': 1, 'b': 2} 
d2 = {'b': 3, 'c': 4}    # 注意键 'b' 重复 

# 方法1: {**d1, **d2} (Python 3.5+) 
merged = {**d1, **d2}    # {'a': 1, 'b': 3, 'c': 4}，后面的值覆盖前面的 

# 方法2: d1.update(d2) (原地修改d1) 
d1.update(d2)    # d1 变为 {'a': 1, 'b': 3, 'c': 4} 

# 方法3: collections.ChainMap (逻辑合并，不创建新字典) 
from collections import ChainMap 
chain = ChainMap(d1, d2)    # 按顺序查找键

4. 使用 collections模块中的特殊字典

defaultdict: 提供默认值工厂，简化初始化。

from collections import defaultdict 

# 初始化一个默认值为列表的字典 list_dict = defaultdict(list) 
list_dict['fruits'].append('apple')# 无需先判断键是否存在 

# 初始化一个默认值为0的字典（用于计数） 
count_dict = defaultdict(int) 
for word in ['apple', 'banana', 'apple']: 
		count_dict[word] += 1# 第一次遇到'apple'时，初始值就是0 
# count_dict: defaultdict(<class 'int'>, {'apple': 2, 'banana': 1})

5. Counter: 专为计数设计的字典子类。

from collections import Counter 
words = ['apple', 'banana', 'apple', 'orange', 'banana', 'apple'] 
word_count = Counter(words) 
print(word_count)			# Counter({'apple': 3, 'banana': 2, 'orange': 1}) 
print(word_count.most_common(2))			# [('apple', 3), ('banana', 2)]

集合 (Set) 的高级用法

集合的核心是唯一性和数学集合操作。

1. 集合推导式 (Set Comprehension)

与列表推导式类似，用于创建集合，自动去重。

# 创建一个包含平方数的集合（自动去重） 
numbers = [1, 2, 2, 3, 4, 4, 4] 
unique_squares = {x*x for x in numbers}			# {1, 4, 9, 16}

2. 强大的集合运算

集合支持并集、交集、差集、对称差集等数学运算。

set_a = {1, 2, 3, 4} 
set_b = {3, 4, 5, 6} 

# 并集 (Union): 所有在A或B中的元素 
print(set_a | set_b)# {1, 2, 3, 4, 5, 6} 
print(set_a.union(set_b))# 同上 

# 交集 (Intersection): 所有同时在A和B中的元素 
print(set_a & set_b)# {3, 4} 
print(set_a.intersection(set_b))# 同上 

# 差集 (Difference): 在A中但不在B中的元素 
print(set_a - set_b)# {1, 2} 
print(set_a.difference(set_b))# 同上 

# 对称差集 (Symmetric Difference): 在A或B中，但不同时在两者中的元素 
print(set_a ^ set_b)# {1, 2, 5, 6} 
print(set_a.symmetric_difference(set_b))# 同上 

# 子集/超集判断 
print({1, 2}.issubset(set_a))			# True 
print(set_a.issuperset({1, 2}))			# True

3. 从序列中快速去除重复项

这是集合最常用的场景之一。

my_list = [1, 2, 2, 3, 4, 4, 4, 5]
unique_list = list(set(my_list))			# [1, 2, 3, 4, 5] (顺序可能改变)

# 如果需要保持原始顺序，可以使用字典（Python 3.7+字典有序）
unique_list_ordered = list(dict.fromkeys(my_list).keys())			# [1, 2, 3, 4, 5]