Python 列表、字典与生成器推导式详解

这里的逻辑是：遍历 numbers 中的每一个 num，如果 num 能被 2 整除，那么就计算它的立方，并将其加入新列表。

嵌套循环的优雅表达

列表推导式甚至可以处理嵌套循环，这进一步展示了其强大的表达能力。

应用案例：矩阵扁平化

将一个二维列表（矩阵）转换为一维列表。

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flattened_list = [elem for row in matrix for elem in row]
# flattened_list -> [1, 2, 3, 4, 5, 6, 7, 8, 9]

这行代码的阅读顺序与嵌套 for 循环的顺序一致：对于 matrix 中的每一个 row，再对于 row 中的每一个 elem…

字典推导式 (Dictionary Comprehensions)

如果说列表推导式是创作有序的篇章，那么字典推导式就是构建精准的索引。它以一种同样简洁的方式，用于创建字典。

从列表到字典的华丽转身

我们有一个单词列表，现在想创建一个字典，其中键是单词，值是单词的长度。

传统 for 循环写法：

words = ['python', 'is', 'awesome', 'comprehension']
word_lengths = {}
for word in words:
    word_lengths[word] = len(word)
# word_lengths -> {'python': 6, 'is': 2, 'awesome': 7, 'comprehension': 13}

字典推导式写法：

word_lengths = {word: len(word) for word in words}
# word_lengths -> {'python': 6, 'is': 2, 'awesome': 7, 'comprehension': 13}

结构上，字典推导式与列表推导式非常相似，只是用 {} 包围，并且需要同时提供 key: value 对。

字典推导式的语法图解

核心结构如下：

• 核心循环部分：for 元素 in 可迭代对象
• key 表达式 : value 表达式
• 可选的过滤条件
• 最终生成的新字典

应用案例：快速转换与过滤数据

假设我们有一个包含学生分数的字典，我们想创建一个新字典，只包含分数及格（大于等于 60）的学生，并将分数转换为等级（Pass/Fail）。

student_scores = {'Alice': 85, 'Bob': 42, 'Charlie': 73, 'David': 59}
passed_status = {
    name: 'Pass' if score >= 60 else 'Fail'
    for name, score in student_scores.items()
    if score >= 60
}
# passed_status -> {'Alice': 'Pass', 'Charlie': 'Pass'}

请注意这里的两个要点：

1. 我们遍历的是 student_scores.items()，它同时返回键和值。
2. if score >= 60 在末尾，起到了过滤的作用，所以'Bob'和'David'甚至不会进入 key: value 的生成过程。
3. 'Pass' if score >= 60 else 'Fail' 是一个三元表达式，用于动态计算 value。

生成器表达式 (Generator Expressions)

当数据量变得庞大时，列表推导式的一个潜在缺点就暴露了出来：它会一次性在内存中生成整个列表。如果我们处理的是数百万个数据项，内存消耗将是巨大的。

这时，生成器表达式便登上了舞台。它看起来和列表推导式几乎一模一样，唯一的区别是使用 () 而不是 []。

'惰性求值'的魔法

生成器表达式返回的不是一个列表，而是一个生成器对象。这个对象非常'懒'，它不会立即计算任何值，只有当你需要它的时候（例如，通过 for 循环迭代或调用 next()），它才会去计算并'吐出'一个值，然后等待下一次请求。

这种'按需生产'的模式，使得其内存占用极小，因为它永远只保留一个待处理的元素在内存中。

列表推导式 vs. 生成器表达式：内存之别

# 列表推导式：立即创建包含 100 万个元素的列表
list_comp = [i for i in range(1_000_000)]
# 此时，list_comp 占用了大量内存

# 生成器表达式：创建一个生成器对象，几乎不占内存
gen_exp = (i for i in range(1_000_000))
# gen_exp 是一个 generator object，非常轻量

应用案例：处理大文件日志

想象一个场景：你需要从一个几百 GB 的日志文件中，提取所有包含'ERROR'的行号。如果你用列表推导式，Python 可能会因为内存不足而崩溃。但生成器表达式则游刃有余。

# 假设 'huge_log.txt' 是一个非常大的文件
def find_error_lines(log_file_path):
    with open(log_file_path, 'r') as f:
        # 使用生成器表达式，逐行读取并检查，内存友好
        error_line_numbers = (
            i for i, line in enumerate(f, 1) if 'ERROR' in line
        )
        # 我们可以进一步处理这个生成器，比如写入另一个文件或统计总数
        for line_num in error_line_numbers:
            print(f"Found error on line: {line_num}")
        # 或者将其收集起来（如果结果不多的话）
        # errors.append(line_num)
        # find_error_lines('huge_log.txt')

在这个例子中，生成器表达式 (i for i, line in enumerate(f, 1) if 'ERROR' in line) 配合文件的逐行读取，构成了一个完美的大数据处理流水线。我们无需一次性加载所有内容到内存。

三者之辨：何时该用谁？

为了更直观地理解它们的差异，我们来一个简单的对比总结。

选择指南

• 需要一个可以重复访问、索引或切片的列表吗？
  • 数据量可控 ➜ 列表推导式 🥇
• 需要构建一个键值对的映射关系吗？
  • 数据量可控 ➜ 字典推导式 🥇
• 处理的数据量非常大，或者数据流是无限的？
  • 你只需要遍历一次结果 ➜ 生成器表达式 🥇

结语：不止于语法，更在于思想

Python 的推导式，远不止是语法糖这么简单。它代表了一种编程思想的转变：从'告诉计算机如何一步步做'（How），转向'告诉计算机我想要什么'（What）。

当你写下 [x*x for x in my_list] 时，你描述的是一个结果的集合，而不是一个累加的过程。这种声明式的风格，不仅让代码更短、更易读，也常常更高效（因为其内部实现经过了高度优化）。

从列表的有序之美，到字典的索引之妙，再到生成器的轻盈之舞，这三种推导式共同构成了 Python 数据处理工具箱中的'三叉戟'。掌握它们，意味着你手中握住了编写简洁、优雅、高效 Python 代码的钥匙。

下一次，当你发现自己写下一个 for 循环，仅仅是为了填充一个列表或字典时，不妨停顿一下，问问自己：'这里，是否可以用推导式来表达？'

这个小小的思考，或许就是通往 Python 大师之路的又一步。🚀