Python基础：推导式（Comprehensions）详解_python comprehension

1. 推导式概念

  Python推导式（comprehensions）是一种简洁而强大的语法，用于从已存在的数据（列表、元组、集合、字典等）中创建新的数据结构。推导式包括：

• 列表推导式
• 元组推导式
• 字典推导式
• 集合推导式

2. 列表推导式

  列表推导式创建列表的方式更简洁。常见的用法为，对序列或可迭代对象中的每个元素应用某种操作，用生成的结果创建新的列表；或用满足特定条件的元素创建子序列。
  例如：创建平方值的列表

squares = []
for x in range(10):
    squares.append(x**2)
print(squares)
1
2
3
4

  这段代码创建（或覆盖）变量 x，该变量在循环结束后仍然存在。
  下述方法可以无副作用地计算平方列表：

# 1）第一种方式
squares = list(map(lambda x : x**2 in range(10)))

# 2) 第二种方式
squares = [x**2 for x in range(10)]
1
2
3
4
5

2.1 语法格式

  列表推导式（List comprehension）是一种在一行代码中创建和操作列表的简洁方式。
  它的基本语法形式如下：

[expression for item in iterable if condition]
1

1. expression是对 item的操作或表达式，可以是有返回值的函数。
   2.item是迭代变量，表示可迭代对象中的每个元素。
2. iterable是可迭代对象，如列表、元组、字符串等。
3. condition是一个可选的条件，用于过滤元素。

  注意：列表推导式的方括号内包含以下内容：一个表达式，后面为一个 for 子句，然后，是零个或多个for或 if 子句。结果是由表达式依据 for 和if 子句求值计算而得出一个新列表。

[(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
"""
    上述推导式等同于：
        combs = []
        for x in [1,2,3]:
            for y in [3,1,4]:
                if x != y:
                    combs.append((x, y))
        combs
"""
# 输出 [(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
1
2
3
4
5
6
7
8
9
10
11

2.2 示例及应用

"""
筛选和转换数据： 
列表推导式允许你根据特定的条件从一个列表中选择或转换元素，从而创建一个新的列表。例如，你可以过滤出所有的偶数或将列表中的字符串转换为大写。
"""
# 筛选偶数
even_numbers = [x for x in range(10) if x % 2 == 0]
print(even_numbers)

# 过滤出字符串列表中长度大于3的单词
words = ['python', 'is', 'awesome', 'and', 'fun']
long_words = [word for word in words if len(word)>=3]
print(long_words)

# 转换字符串为大写
words = ['hello', 'world', 'python']
upper_words = [word.upper() for word in words]
print(upper_words)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

  运行效果：

"""
生成序列： 
通过列表推导式，你可以用一行代码生成各种序列，如数字序列、字符序列等。
"""
# 生成平方序列
squares = [x**2 for x in range(5)]
print(squares)

# 生成字符序列
chars = [char for char in 'python']
print(chars)
1
2
3
4
5
6
7
8
9
10
11

  运行效果：

"""
嵌套迭代： 
列表推导式支持嵌套，可以用来创建嵌套结构的数据，例如二维列表。
"""
# 创建二维列表
matrix = [[i * j for j in range(1, 4)] for i in range(1, 4)]
print(matrix)

# 生成一个包含 3 行 4 列的二维列表，每个元素都是其行索引和列索引的和
matrix_o = [[row + col for col in range(4)] for row in range(3)]
print(matrix_o)
1
2
3
4
5
6
7
8
9
10
11

  运行效果：

"""
    使用复杂的表达式和嵌套函数
"""
from math import pi
[str(round(pi,i)) for i in range(1,6)] 
1
2
3
4
5

  运行效果：

3. 元组推导式

  在Python中，元组推导式（Tuple Comprehension）是一种用于创建元组的紧凑语法。它的语法结构与列表推导式类似，但使用圆括号（）而不是方括号[]。

3.1 语法格式

tuple_variable = (expression for item in iterable if condition)
1

1.expression 是生成元组元素的表达式。
2.item 是可迭代对象中的每个元素。
3.iterable是一个可迭代对象，例如列表、字符串等。
4. condition是一个可选的条件，用于过滤元素。

3.2 示例及应用

"""
创建元组序列：
当需要生成一个元组序列时，元组推导式是一种简洁的方式。例如，可以使用元组推导式创建包含某种规律的数字、字符串或其他元素的元组序列。
"""
# 生成包含平方数的元组序列
squares_tuple = tuple(x**2 for x in range(5))
print(squares_tuple)
1
2
3
4
5
6
7

  运行效果：

"""
转换数据：
当有一个可迭代的对象，并希望将其转换为元组时，可以使用元组推导式。这在处理数据时很常见。
"""
# 将字符串长度转换为元组
words = ['apple', 'banana', 'orange']
lengths_tuple = tuple(len(word) for word in words)
print(lengths_tuple)
1
2
3
4
5
6
7
8

  运行效果：

"""
过滤数据：通过添加条件语句，可以使用元组推导式从可迭代对象中选择特定的元素。
"""
# 生成包含偶数平方数的元组序列
even_squares_tuple = tuple(x**2 for x in range(5) if x % 2 == 0)
print(even_squares_tuple)
1
2
3
4
5
6

  运行效果：

"""
函数返回多个值：
在某些情况下，可能希望从函数中返回多个值作为元组，而元组推导式可以用于在函数中快速生成这样的元组。
"""
def get_coordinates():
    x_values = [1, 2, 3]
    y_values = [4, 5, 6]
    return tuple((x, y) for x, y in zip(x_values, y_values))

coordinates = get_coordinates()
print(coordinates)
1
2
3
4
5
6
7
8
9
10
11

  运行效果：

3.3 与生成器表达式区别

  元组推导式（Tuple Comprehension）和生成器表达式（Generator Expression）在语法上很相似，但有一些关键的区别。以下是它们之间的主要区别：

3.3.1 返回类型

• 元组推导式返回一个元组（tuple）。
• 生成器表达式返回一个生成器对象（generator）。

3.3.2 语法

• 元组推导式使用圆括号 ()。
• 生成器表达式使用圆括号 ()，但是在语法上可以省略，这与列表推导式不同。

# 元组推导式
tuple_comp = tuple(x**2 for x in range(5))

# 生成器表达式
generator_expr = (x**2 for x in range(5))
1
2
3
4
5

3.3.3 内存占用

• 元组推导式会生成一个完整的元组对象，占用相应的内存。
• 生成器表达式生成一个生成器对象，它是一个惰性计算的序列，只在需要时生成元素，因此在内存上更为高效。

3.3.4 迭代方式

• 元组推导式一次性生成所有元素，可以直接进行索引、切片等操作。
• 生成器表达式是惰性的，只在每次迭代时生成一个元素，因此不能直接进行索引和切片等操作。

  总体而言，如果需要一个一次性的、完整的序列，可以使用元组推导式；而如果想要一个惰性计算的序列，以节省内存，可以使用生成器表达式。选择取决于具体需求。

4. 字典推导式

  字典推导式（Dictionary Comprehension）是一种在一行代码中创建字典的方法，类似于列表推导式。它允许你以简洁的方式从一个可迭代对象中创建一个字典.

4.1 语法格式

  可以有0个或多个条件表达式，根据具体的需求决定是否使用条件。

{key_expression: value_expression for item in iterable if condition}
1

1.key_expression 是用于生成字典键的表达式。
2. value_expression 是用于生成字典值的表达式。
3.item 是可迭代对象中的每个元素。
4. if condition是一个可选的条件表达式，用于过滤元素。

4.2 示例及应用

  字典推导式在许多场景下都是一种方便且简洁的方式来创建和操作字典。以下是一些常见的字典推导式的应用场景：

"""
转换数据格式：
当有一个可迭代对象，想要将其转换为字典形式时，字典推导式是一种便捷的方式。
例如，将元组列表转换为字典：
"""
tuple_list = [('a', 1), ('b', 2), ('c', 3)]
my_dict = {key: value for key, value in tuple_list}
print(tuple_list)
1
2
3
4
5
6
7
8

  运行效果：

"""
过滤数据：
通过在字典推导式中添加条件表达式，可以过滤可迭代对象的元素，从而创建一个满足特定条件的字典。
例如，只选择某个范围内的元素
"""
original_dict = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
filtered_dict = {key: value for key, value in original_dict.items() if value > 2}
print(filtered_dict)
1
2
3
4
5
6
7
8

  运行效果：

"""
键或值的转换：
可以使用字典推导式来对字典的键或值进行某种转换。
例如，将字典的键和值交换：
"""
original_dict = {'a': 1, 'b': 2, 'c': 3}
swapped_dict = {value: key for key, value in original_dict.items()}
print(swapped_dict)
1
2
3
4
5
6
7
8

  运行效果：

"""
处理嵌套结构：
当有一个嵌套的可迭代对象，想要将其展平为字典时，字典推导式也很有用。
例如，展平嵌套的字典：
"""
nested_dict = {'a': {'x': 1, 'y': 2}, 'b': {'x': 3, 'y': 4}}
flattened_dict = {outer_key: inner_value for outer_key, inner_dict in nested_dict.items() for inner_key, inner_value in inner_dict.items()}
print(flattened_dict)
1
2
3
4
5
6
7
8

  运行效果：

"""
默认值处理：
在字典推导式中，可以使用字典的 get 方法或 default 关键字处理不存在的键，从而设置默认值。这在构建字典时非常有用。
"""
original_dict = {'a': 1, 'b': 2, 'c': 3}
keys = ['a', 'b', 'c']
default_value = 0
my_dict = {key: original_dict.get(key, default_value) for key in keys}
print(my_dict)
1
2
3
4
5
6
7
8
9

  运行效果：

5. 集合推导式

  在Python中，可以使用集合推导式来创建集合。集合推导式的语法与列表推导式类似，但是使用大括号{} 表示集合。

5.1 语法格式

{expression for item in iterable if condition}
1

1. expression是一个表达式，用于计算集合中的元素。
   2.item 是可迭代对象（如列表、元组等）中的每个元素。
   3.iterable 是一个可迭代对象，例如 range(1, 11)。
2. condition是一个可选的条件，用于筛选满足条件的元素。

5.2 示例及应用

  集合推导式在Python中是一个强大而灵活的工具，适用于多种应用场景。以下是一些常见的集合推导式的应用场景：

"""
过滤数据：
可以使用集合推导式从一组数据中筛选出满足特定条件的元素。
例如，从一个列表中选择所有大于某个阈值的数字。
"""
numbers = [1, 5, 8, 10, 15, 20]
filtered_numbers = {x for x in numbers if x > 10}
print(filtered_numbers)
1
2
3
4
5
6
7
8

  运行效果：

"""
映射转换：
使用集合推导式可以对数据进行转换，生成一个新的集合。例
如，将字符串列表转换为它们的长度集合。
"""
words = ["apple", "banana", "orange"]
word_lengths = {len(word) for word in words}
print(word_lengths)
1
2
3
4
5
6
7
8

  运行效果：

"""
去重：
创建一个不包含重复元素的集合。这对于从列表或其他可迭代对象中移除重复项非常有用。
"""
numbers_with_duplicates = [1, 2, 2, 3, 4, 4, 5]
unique_numbers = {x for x in numbers_with_duplicates}
print(unique_numbers)
1
2
3
4
5
6
7

  运行效果：

"""
集合运算：
使用集合推导式进行集合运算，如并集、交集等。
例如，找到两个集合的交集。
"""
set1 = {1, 2, 3, 4, 5}
set2 = {3, 4, 5, 6, 7}
intersection = {x for x in set1 if x in set2}
print(intersection)
1
2
3
4
5
6
7
8
9

  运行效果：

"""
条件化处理：
在集合推导式中，可以根据特定条件对元素进行处理。
例如，将列表中的奇数平方加倍。
"""
numbers = [1, 2, 3, 4, 5]
doubled_odd_squares = {x**2 * 2 for x in numbers if x % 2 != 0}
print(doubled_odd_squares)
1
2
3
4
5
6
7
8

  运行效果：

6. 使用推导式的优点

• 简洁性
    推导式允许以一种紧凑的方式表示数据转换和过滤，减少了冗余的代码行数。这使得代码更加简洁、清晰，同时减少了错误的可能性。

• 可读性
    推导式提高了代码的可读性，尤其是对于简单的转换和过滤操作。它们可以帮助将复杂的操作用一行或几行代码清晰地表达出来，使得代码更易于理解。

• 效率
    推导式通常比传统的迭代方式更高效。它们背后的实现在一些情况下可以提供更好的性能，因为它们是由底层的高效数据结构实现的。

• 功能性
    推导式支持丰富的功能，包括条件过滤、多个迭代器的组合、元素的映射转换等。这使得推导式成为一种灵活而强大的工具，适用于各种不同的场景。

• 一致性
    推导式提供了一种统一的语法结构，使得在不同的数据类型（列表、集合、字典等）上进行转换和过滤变得一致。这种一致性使得代码更易于维护和修改。

• 减少临时变量
    使用推导式可以减少在代码中引入不必要的临时变量。这有助于保持代码的简洁性和可读性。

• 支持多种数据结构
    不仅可以在列表中使用推导式，还可以在集合、字典等数据结构上使用，扩展了推导式的适用范围。

7. 参考