Python 基础：容器公共操作与推导式详解

性能提示：对于大列表，使用 extend() 或切片赋值通常比多次 + 更高效。

3. 成员资格测试 (in / not in)

这两个运算符用于判断某个元素是否存在于容器中，返回布尔值。

# 字符串检查
print('a' in 'abcd')      # True
print('z' not in 'abcd')  # True

# 列表检查
my_list = ['apple', 'banana', 'cherry']
print('apple' in my_list)       # True
print('grape' not in my_list)   # True

# 字典检查 (默认检查 Key)
dict_data = {'name': 'Tom', 'age': 25}
print('name' in dict_data)      # True
print('age' in dict_data.values()) # False (需显式调用 values)

二、常用内置函数

Python 提供了一系列针对序列的通用内置函数，无需导入额外模块即可使用。

1. 统计与极值

numbers = [10, 5, 8, 20, 2]
print(len(numbers))     # 5
print(max(numbers))     # 20
print(min(numbers))     # 2
print(sum(numbers))     # 45

2. 枚举 (enumerate)

在遍历列表时，如果需要同时获取索引和值，enumerate 是最佳选择。

items = ['a', 'b', 'c']
for index, value in enumerate(items):
    print(f'索引 {index}: {value}')

# 指定起始索引
for index, value in enumerate(items, start=1):
    print(f'第 {index} 项: {value}')

3. 压缩 (zip)

zip 将多个可迭代对象打包成元组列表，常用于并行处理。

names = ['Alice', 'Bob']
ages = [25, 30]
for name, age in zip(names, ages):
    print(f'{name} is {age} years old')

三、容器类型转换

Python 允许在不同序列类型之间进行转换，但需注意顺序保留和唯一性限制。

1. 转换为列表 (list)

列表是可变的，适合需要频繁修改数据的场景。

tup = (1, 2, 3)
lst = list(tup)
print(lst)          # [1, 2, 3]
print(type(lst))    # <class 'list'>

2. 转换为元组 (tuple)

元组是不可变的，适合存储不应被修改的数据。

lst = [1, 2, 3]
tup = tuple(lst)
print(tup)          # (1, 2, 3)

3. 转换为集合 (set)

集合会自动去除重复元素，且无序（Python 3.7+ 插入有序，但语义上视为无序）。

lst = [1, 2, 2, 3]
unique_set = set(lst)
print(unique_set)   # {1, 2, 3}

注意：如果列表中包含不可哈希的元素（如嵌套列表），则无法转换为集合。

四、推导式 (Comprehensions)

推导式是一种简洁的语法结构，用于基于现有序列创建新序列。它比传统的 for 循环更紧凑，可读性更强。

1. 列表推导式

语法：[表达式 for 变量 in 可迭代对象 if 条件]

# 生成 1 到 10 的平方
squares = [x**2 for x in range(1, 11)]
print(squares) # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

# 过滤偶数
evens = [x for x in range(10) if x % 2 == 0]
print(evens) # [0, 2, 4, 6, 8]

2. 字典推导式

语法：{键：值 for 变量 in 可迭代对象 if 条件}

# 生成键值对
num_dict = {i: i**2 for i in range(1, 6)}
print(num_dict) # {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

# 过滤字典数据
sales = {'A': 100, 'B': 200, 'C': 50}
high_sales = {k: v for k, v in sales.items() if v >= 100}
print(high_sales) # {'A': 100, 'B': 200}

3. 集合推导式

语法：{表达式 for 变量 in 可迭代对象 if 条件}

# 去重并计算平方
nums = [1, 2, 2, 3, 3, 3]
sq_set = {x**2 for x in nums}
print(sq_set) # {1, 4, 9}

4. 元组推导式 (生成器表达式)

元组推导式实际上返回的是生成器对象，节省内存。

# 生成器对象
gen = (x for x in range(5))
print(gen) # <generator object <genexpr> at ...>

# 转换为元组
tup_gen = tuple(x for x in range(5))
print(tup_gen) # (0, 1, 2, 3, 4)

五、进阶技巧与最佳实践

1. 嵌套推导式

可以处理多维数据结构，但应避免过度嵌套导致难以阅读。

matrix = [[1, 2], [3, 4]]
flat = [num for row in matrix for num in row]
print(flat) # [1, 2, 3, 4]

2. 性能考量

• 列表推导式：立即构建列表，占用更多内存。
• 生成器表达式：惰性求值，适合处理大数据流。
• 字典/集合推导式：通常比循环添加更快，因为底层优化。

3. 常见错误

• 修改正在迭代的列表：不要在遍历列表时删除元素，应使用列表推导式创建新列表。
• 可变默认参数：定义函数时避免使用列表作为默认参数，会导致状态共享。

# 错误示范
def add_item(item, container=[]):
    container.append(item)
    return container

# 正确示范
def add_item_safe(item, container=None):
    if container is None:
        container = []
    container.append(item)
    return container

六、实战练习

题目

给定一个包含多个字符串的列表，筛选出长度大于 3 且不包含字符 'e' 的单词。

words = ['hello', 'python', 'love', 'you', 'code', 'java']
result = [w for w in words if len(w) > 3 and 'e' not in w]
print(result) # ['python', 'you']

解析

1. 使用列表推导式遍历 words。
2. 第一个条件 len(w) > 3 确保长度要求。
3. 第二个条件 'e' not in w 排除包含特定字符的项。
4. 最终生成符合条件的新列表。

七、总结

本文系统讲解了 Python 容器的公共操作符、内置函数及推导式用法。通过对比传统循环与推导式的差异，强调了代码简洁性与性能优化的重要性。在实际开发中，建议优先使用推导式处理简单转换逻辑，同时注意内存消耗与可读性的平衡。掌握这些基础技能，将为后续学习数据分析、Web 开发等高级主题打下坚实基础。

附录：相关资源推荐

如需进一步深入学习 Python 数据结构，建议参考官方文档或权威书籍。实践中多编写小脚本巩固记忆，遇到问题查阅官方文档是最准确的解决途径。