Python教程

Appearance

Python 推导式 ​

推导式是 Python 中一种简洁、强大的语法结构，用于快速创建数据结构（如列表、字典、集合等）。本章节将详细介绍 Python 中的各种推导式。

列表推导式 ​

列表推导式是最常用的推导式，用于快速创建列表。

基本语法 ​

python
[expression for item in iterable if condition]
  • expression：对每个元素执行的表达式
  • item：可迭代对象中的元素
  • iterable：可迭代对象（如列表、元组、字符串等）
  • condition：可选的条件，只有满足条件的元素才会被包含

示例 ​

python
# 列表推导式示例

# 基本用法：创建一个包含 0 到 9 的平方的列表
squares = [i**2 for i in range(10)]
print(squares)  # 输出：[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# 添加条件：创建一个包含 0 到 9 的偶数的列表
evens = [i for i in range(10) if i % 2 == 0]
print(evens)  # 输出：[0, 2, 4, 6, 8]

# 复杂表达式：创建一个包含字符串长度的列表
words = ["hello", "world", "python"]
word_lengths = [len(word) for word in words]
print(word_lengths)  # 输出：[5, 5, 6]

# 嵌套表达式：创建一个包含两个列表元素组合的列表
list1 = [1, 2, 3]
list2 = [4, 5, 6]
combined = [x + y for x in list1 for y in list2]
print(combined)  # 输出：[5, 6, 7, 6, 7, 8, 7, 8, 9]

# 带条件的嵌套表达式：创建一个包含两个列表元素组合的列表，只包含和为偶数的组合
combined_even = [x + y for x in list1 for y in list2 if (x + y) % 2 == 0]
print(combined_even)  # 输出：[6, 8, 8]

# 使用函数：创建一个包含字符串首字母大写的列表
names = ["alice", "bob", "charlie"]
capitalized_names = [name.capitalize() for name in names]
print(capitalized_names)  # 输出：['Alice', 'Bob', 'Charlie']

列表推导式 vs 传统循环 ​

列表推导式比传统的 for 循环更简洁、更易读，并且执行速度更快。

传统循环示例：

python
# 传统循环创建列表
squares = []
for i in range(10):
    squares.append(i**2)
print(squares)  # 输出：[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

列表推导式示例：

python
# 列表推导式创建列表
squares = [i**2 for i in range(10)]
print(squares)  # 输出：[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

字典推导式 ​

字典推导式用于快速创建字典。

基本语法 ​

python
{key_expression: value_expression for item in iterable if condition}
  • key_expression：键的表达式
  • value_expression：值的表达式
  • item：可迭代对象中的元素
  • iterable：可迭代对象
  • condition：可选的条件

示例 ​

python
# 字典推导式示例

# 基本用法：创建一个包含 0 到 9 的平方的字典
squares = {i: i**2 for i in range(10)}
print(squares)  # 输出：{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}

# 添加条件：创建一个包含 0 到 9 的偶数的平方的字典
even_squares = {i: i**2 for i in range(10) if i % 2 == 0}
print(even_squares)  # 输出：{0: 0, 2: 4, 4: 16, 6: 36, 8: 64}

# 从列表创建字典：将列表中的元素作为键，索引作为值
fruits = ["apple", "banana", "cherry"]
fruit_indices = {fruit: index for index, fruit in enumerate(fruits)}
print(fruit_indices)  # 输出：{'apple': 0, 'banana': 1, 'cherry': 2}

# 转换字典：将字典中的值转换为大写
person = {"name": "alice", "age": 30, "city": "new york"}
uppercase_person = {key: value.upper() if isinstance(value, str) else value for key, value in person.items()}
print(uppercase_person)  # 输出：{'name': 'ALICE', 'age': 30, 'city': 'NEW YORK'}

# 合并两个字典：使用字典推导式合并两个字典
 dict1 = {"a": 1, "b": 2}
dict2 = {"c": 3, "d": 4}
merged_dict = {**dict1, **dict2}
print(merged_dict)  # 输出：{'a': 1, 'b': 2, 'c': 3, 'd': 4}

# 或者使用字典推导式
merged_dict2 = {k: v for d in [dict1, dict2] for k, v in d.items()}
print(merged_dict2)  # 输出：{'a': 1, 'b': 2, 'c': 3, 'd': 4}

集合推导式 ​

集合推导式用于快速创建集合。

基本语法 ​

python
{expression for item in iterable if condition}
  • expression：对每个元素执行的表达式
  • item：可迭代对象中的元素
  • iterable：可迭代对象
  • condition：可选的条件

示例 ​

python
# 集合推导式示例

# 基本用法：创建一个包含 0 到 9 的平方的集合
squares = {i**2 for i in range(10)}
print(squares)  # 输出：{0, 1, 4, 9, 16, 25, 36, 49, 64, 81}

# 添加条件：创建一个包含 0 到 9 的奇数的集合
odds = {i for i in range(10) if i % 2 == 1}
print(odds)  # 输出：{1, 3, 5, 7, 9}

# 去重：从列表中创建集合，自动去重
list_with_duplicates = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
unique_numbers = {x for x in list_with_duplicates}
print(unique_numbers)  # 输出：{1, 2, 3, 4}

# 字符串去重：从字符串中创建集合，自动去重
text = "hello"
unique_chars = {char for char in text}
print(unique_chars)  # 输出：{'h', 'e', 'l', 'o'}

# 复杂表达式：创建一个包含字符串长度的集合
words = ["hello", "world", "python", "programming"]
word_lengths = {len(word) for word in words}
print(word_lengths)  # 输出：{5, 6, 11}

生成器表达式 ​

生成器表达式与列表推导式类似，但它创建的是一个生成器对象，而不是列表。生成器表达式更节省内存，因为它不会一次性创建所有元素，而是按需生成。

基本语法 ​

python
(expression for item in iterable if condition)
  • expression：对每个元素执行的表达式
  • item：可迭代对象中的元素
  • iterable：可迭代对象
  • condition：可选的条件

示例 ​

python
# 生成器表达式示例

# 基本用法：创建一个生成器对象
squares = (i**2 for i in range(10))
print(squares)  # 输出：<generator object <genexpr> at 0x...>

# 遍历生成器
for square in squares:
    print(square, end=" ")  # 输出：0 1 4 9 16 25 36 49 64 81
print()

# 再次遍历生成器（生成器只能遍历一次）
for square in squares:
    print(square, end=" ")  # 无输出
print()

# 添加条件：创建一个包含 0 到 9 的偶数的生成器
evens = (i for i in range(10) if i % 2 == 0)
for even in evens:
    print(even, end=" ")  # 输出：0 2 4 6 8
print()

# 转换为列表
numbers = list((i for i in range(5)))
print(numbers)  # 输出：[0, 1, 2, 3, 4]

# 转换为元组
numbers_tuple = tuple((i for i in range(5)))
print(numbers_tuple)  # 输出：(0, 1, 2, 3, 4)

# 转换为集合
numbers_set = set((i for i in range(5)))
print(numbers_set)  # 输出：{0, 1, 2, 3, 4}

生成器表达式 vs 列表推导式 ​

生成器表达式与列表推导式的主要区别：

  1. 语法：生成器表达式使用圆括号 ()，而列表推导式使用方括号 []。
  2. 内存：生成器表达式按需生成元素，更节省内存；列表推导式一次性创建所有元素，占用更多内存。
  3. 迭代：生成器表达式只能遍历一次；列表推导式可以多次遍历。

示例：

python
# 生成器表达式 vs 列表推导式

# 列表推导式：一次性创建所有元素
list_comp = [i**2 for i in range(1000000)]
print(f"列表推导式占用内存：{len(list_comp) * 4} 字节（约）")  # 假设每个整数占用 4 字节

# 生成器表达式：按需生成元素
gen_expr = (i**2 for i in range(1000000))
print(f"生成器表达式占用内存：很小（按需生成）")

# 遍历生成器
print("\n遍历生成器：")
for i, square in enumerate(gen_expr):
    if i < 5:
        print(square, end=" ")
    else:
        break
print()

嵌套推导式 ​

推导式可以嵌套，用于处理更复杂的数据结构。

嵌套列表推导式 ​

示例：

python
# 嵌套列表推导式示例

# 基本用法：创建一个 3x3 的矩阵
matrix = [[i for i in range(3)] for j in range(3)]
print(matrix)  # 输出：[[0, 1, 2], [0, 1, 2], [0, 1, 2]]

# 创建一个 3x3 的乘法表
multiplication_table = [[i * j for i in range(1, 4)] for j in range(1, 4)]
print(multiplication_table)  # 输出：[[1, 2, 3], [2, 4, 6], [3, 6, 9]]

# 扁平化嵌套列表
nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flattened = [num for sublist in nested_list for num in sublist]
print(flattened)  # 输出：[1, 2, 3, 4, 5, 6, 7, 8, 9]

# 带条件的嵌套列表推导式
nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
even_numbers = [num for sublist in nested_list for num in sublist if num % 2 == 0]
print(even_numbers)  # 输出：[2, 4, 6, 8]

嵌套字典推导式 ​

示例：

python
# 嵌套字典推导式示例

# 创建一个字典，键是外层循环的元素，值是内层循环的元素组成的字典
nested_dict = {i: {j: i * j for j in range(1, 4)} for i in range(1, 4)}
print(nested_dict)  # 输出：{1: {1: 1, 2: 2, 3: 3}, 2: {1: 2, 2: 4, 3: 6}, 3: {1: 3, 2: 6, 3: 9}}

# 从嵌套字典中提取数据
nested_dict = {"Alice": {"age": 30, "city": "New York"}, "Bob": {"age": 25, "city": "London"}}
extracted = {name: info["city"] for name, info in nested_dict.items()}
print(extracted)  # 输出：{'Alice': 'New York', 'Bob': 'London'}

推导式的应用场景 ​

推导式在以下场景中特别有用：

  1. 快速创建数据结构：快速创建列表、字典、集合等数据结构。
  2. 数据转换：将一种数据结构转换为另一种数据结构。
  3. 数据过滤：根据条件过滤数据。
  4. 数据处理：对数据进行简单的处理和转换。
  5. 代码简化：减少代码量，使代码更简洁、更易读。

示例：

python
# 推导式的应用场景

# 1. 快速创建数据结构
print("1. 快速创建数据结构")
# 创建一个包含 0 到 9 的平方的列表
squares = [i**2 for i in range(10)]
print(squares)  # 输出：[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# 2. 数据转换
print("\n2. 数据转换")
# 将列表中的字符串转换为大写
names = ["alice", "bob", "charlie"]
capitalized_names = [name.capitalize() for name in names]
print(capitalized_names)  # 输出：['Alice', 'Bob', 'Charlie']

# 3. 数据过滤
print("\n3. 数据过滤")
# 过滤出列表中的偶数
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
evens = [num for num in numbers if num % 2 == 0]
print(evens)  # 输出：[2, 4, 6, 8, 10]

# 4. 数据处理
print("\n4. 数据处理")
# 计算列表中每个元素的平方
numbers = [1, 2, 3, 4, 5]
squares = [num**2 for num in numbers]
print(squares)  # 输出：[1, 4, 9, 16, 25]

# 5. 代码简化
print("\n5. 代码简化")
# 传统循环
print("传统循环：")
result = []
for i in range(10):
    if i % 2 == 0:
        result.append(i**2)
print(result)  # 输出：[0, 4, 16, 36, 64]

# 列表推导式
print("列表推导式：")
result = [i**2 for i in range(10) if i % 2 == 0]
print(result)  # 输出：[0, 4, 16, 36, 64]

总结 ​

Python 中的推导式是一种简洁、强大的语法结构，包括：

  1. 列表推导式：用于快速创建列表，语法为 [expression for item in iterable if condition]。
  2. 字典推导式：用于快速创建字典，语法为 {key_expression: value_expression for item in iterable if condition}。
  3. 集合推导式：用于快速创建集合，语法为 {expression for item in iterable if condition}。
  4. 生成器表达式：用于创建生成器对象，语法为 (expression for item in iterable if condition)，更节省内存。
  5. 嵌套推导式：用于处理更复杂的数据结构。

推导式可以大大简化代码，提高代码的可读性和执行效率。掌握推导式的使用对于编写 Python 代码非常重要。

Copyright © 2025-2026 京公网安备 11010102000001号 京ICP备2024078128号-1