Python 字典推导式

基本语法

字典推导式的基本结构为：

{key_expression: value_expression for item in iterable}

• key_expression：生成字典 key 的表达式。
• value_expression：生成字典 value 的表达式。
• item：迭代变量，代表可迭代对象中的每个元素。
• iterable：可迭代对象，如列表、字符串或范围。

示例：创建数字-平方字典

squares = {x: x**2 for x in range(5)}
print(squares)  # 输出: {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

此代码遍历 range(5)，以数字为键，平方为值，生成字典。

添加条件逻辑

字典推导式支持在迭代时添加条件，语法为：

{key_expression: value_expression for item in iterable if condition}

• condition：筛选条件，只有满足条件的元素才会生成键值对。

示例：筛选偶数的平方

even_squares = {x: x**2 for x in range(10) if x % 2 == 0}
print(even_squares)  # 输出: {0: 0, 2: 4, 4: 16, 6: 36, 8: 64}

此代码从 range(10) 中筛选偶数，生成键为偶数、值为平方的字典。

使用多个可迭代对象

字典推导式可以通过嵌套循环处理多个可迭代对象，类似列表推导式的嵌套循环。语法为：

{key_expression: value_expression for item1 in iterable1 for item2 in iterable2}

示例：生成键值对组合

pairs = {f"{x}-{y}": x * y for x in [1, 2] for y in [3, 4]}
print(pairs)  # 输出: {'1-3': 3, '1-4': 4, '2-3': 6, '2-4': 8}

此代码遍历两个列表，生成键为字符串组合、值为乘积的字典。

使用条件表达式

字典推导式支持条件表达式（三元运算符），用于动态生成键或值。语法为：

{key_expression: value_if_true if condition else value_if_false for item in iterable}

示例：分类数字

labels = {x: 'even' if x % 2 == 0 else 'odd' for x in range(5)}
print(labels)  # 输出: {0: 'even', 1: 'odd', 2: 'even', 3: 'odd', 4: 'even'}

此代码根据数字的奇偶性生成键为数字、值为标签的字典.

从现有字典创建新字典

字典推导式常用于转换或过滤现有字典。

示例：转换字典值

original = {'a': 1, 'b': 2, 'c': 3}
doubled = {k: v * 2 for k, v in original.items()}
print(doubled)  # 输出: {'a': 2, 'b': 4, 'c': 6}

此代码将字典的值加倍，生成新字典。

示例：过滤字典

scores = {'Alice': 85, 'Bob': 92, 'Charlie': 78}
passed = {k: v for k, v in scores.items() if v >= 80}
print(passed)  # 输出: {'Alice': 85, 'Bob': 92}

此代码筛选出值大于或等于 80 的键值对。

使用 zip() 函数

zip() 函数可以同时迭代多个可迭代对象，常用于字典推导式中生成键值对。

示例：从两个列表创建字典

keys = ['name', 'age', 'city']
values = ['Alice', 25, 'New York']
info = {k: v for k, v in zip(keys, values)}
print(info)  # 输出: {'name': 'Alice', 'age': 25, 'city': 'New York'}

此代码将两个列表配对，生成字典。

嵌套字典推导式

字典推导式可以嵌套，用于生成复杂嵌套字典。

示例：生成嵌套字典

matrix = [[1, 2], [3, 4]]
nested_dict = {i: {j: matrix[i][j] for j in range(len(matrix[0]))} for i in range(len(matrix))}
print(nested_dict)  # 输出: {0: {0: 1, 1: 2}, 1: {0: 3, 1: 4}}

此代码将矩阵转换为嵌套字典结构。

实际应用场景

统计数据：基于可迭代对象统计信息。

text = 'hello'
counts = {char: text.count(char) for char in set(text)}
print(counts)  # 输出: {'h': 1, 'e': 1, 'l': 2, 'o': 1}

创建映射表：从数据生成键值映射。

words = ['cat', 'dog', 'bird']
lengths = {word: len(word) for word in words}
print(lengths)  # 输出: {'cat': 3, 'dog': 3, 'bird': 4}

数据过滤：从大型数据集中提取符合条件的键值对。

inventory = {'pen': 50, 'notebook': 20, 'eraser': 0}
in_stock = {k: v for k, v in inventory.items() if v > 0}
print(in_stock)  # 输出: {'pen': 50, 'notebook': 20}

数据转换：快速转换字典的键或值。

prices = {'apple': 1.5, 'banana': 0.5, 'orange': 0.8}
discounted = {k: v * 0.9 for k, v in prices.items()}
print(discounted)  # 输出: {'apple': 1.35, 'banana': 0.45, 'orange': 0.72}

注意事项

• 可读性：字典推导式适合简单逻辑，复杂逻辑建议使用传统循环以提高代码清晰度。
• 性能：字典推导式通常比等效的 for 循环更快，但会一次性生成整个字典，占用内存。

字典推导式仅用于创建字典，无法直接生成其他数据结构，但可通过类型转换实现。

pairs = [(1, 'one'), (2, 'two')]
dict_from_pairs = {k: v for k, v in pairs}
print(dict_from_pairs)  # 输出: {1: 'one', 2: 'two'}

键的唯一性：字典键必须唯一，若推导式生成重复键，后者会覆盖前者。

numbers = [1, 2, 2, 3]
result = {x: x**2 for x in numbers}
print(result)  # 输出: {1: 1, 2: 4, 3: 9}