《流畅的Python》学习笔记-第二章 列表推导式和生成器（三）

目录

1.列表推导式

2.笛卡尔积

3.生成器

常用的函数

1.lambda（）函数

2.map()

3. filter()

---

1.列表推导式

列表推导式（List Comprehension）是一种简洁的生成列表的方法，它使用一条简洁的表达式来生成一个新的列表。列表推导式通常由一个表达式和一个for循环构成，可选地还可以包含一个if条件。它是 Python 中非常实用的一个特性，可以帮助你更简洁地书写代码。

列表推导式语法如下：

[expression for item in iterable if condition]

其中

• expression 是根据 item 计算得到的元素值
• item 是迭代对象中的单个元素
• iterable 是一个可迭代对象（如列表、元组、集合、字典等）
• condition 是一个可选的过滤条件，只有满足此条件的 item 才会被包含在新列表中

例如，我们想要得到一个包含 1 到 10 的平方数的列表，可以使用以下的列表推导式：

squares = [x**2 for x in range(1, 11)]

这将得到这样一个列表：[1, 4, 9, 16, 25, 36, 49, 64, 81, 100].

一个更复杂的例子，假设我们只想要获取 1-10 的偶数平方数：

even_squares = [x**2 for x in range(1, 11) if x % 2 == 0]

这将得到这样一个列表：[4, 16, 36, 64, 100]。

2.笛卡尔积

笛卡尔积（Cartesian Product）是集合论中的一个概念，表示两个或多个集合中的元素的所有可能组合。对于两个集合 A 和 B，它们的笛卡尔积记作 AxB，其中每个元素都是一个有序对 (a, b)，其中 a 属于集合 A，b 属于集合 B。

更一般地，对于 n 个集合 A1, A2, ..., An，它们的笛卡尔积表示为A1xA2x...xAn，其中每个元素是一个有序 n 元组 (a1, a2, ..., an)，对应于每个集合的元素。

例如，假设有两个集合 A = {1, 2, 3} 和 B = {4, 5}。它们的笛卡尔积 AxB 为：

{(1, 4), (1, 5), (2, 4), (2, 5), (3, 4), (3, 5)}

在 Python 中，我们可以使用 itertools.product() 函数来生成两个或多个集合的笛卡尔积。以下是一个示例：

import itertools

A = {1, 2, 3}
B = {4, 5}
cartesian_product = list(itertools.product(A, B))
print(cartesian_product)

输出结果：

[(1, 4), (1, 5), (2, 4), (2, 5), (3, 4), (3, 5)]

可以看到，笛卡尔积包含了集合 A 和 B 中元素的所有可能组合。

使用嵌套的列表生成式来表示两个或多个集合的笛卡尔积。以下是一个示例：

假设有两个列表 A 和 B：

A = [1, 2, 3]
B = [4, 5]

你可以使用列表生成式计算它们的笛卡尔积：

cartesian_product = [(a, b) for a in A for b in B]

输出结果：

[(1, 4), (1, 5), (2, 4), (2, 5), (3, 4), (3, 5)]

对于三个列表 A，B 和 C 的笛卡尔积，你可以扩展这个列表生成式：

A = [1, 2, 3]
B = [4, 5]
C = [6, 7]

cartesian_product = [(a, b, c) for a in A for b in B for c in C]

输出结果：

[(1, 4, 6),
 (1, 4, 7),
 (1, 5, 6),
 (1, 5, 7),
 (2, 4, 6),
 (2, 4, 7),
 (2, 5, 6),
 (2, 5, 7),
 (3, 4, 6),
 (3, 4, 7),
 (3, 5, 6),
 (3, 5, 7)]

3.生成器

生成器（Generator）是 Python 中一种特殊的迭代器（Iterator），它能够在迭代过程中动态产生值，这可以有效地节省内存。生成器对象在迭代时只会生成所请求的值，而不是在内存中储存整个序列。这使得生成器非常适合处理大量数据，特别是当我们不需要一次性访问整个数据集时。

生成器的创建可以通过以下两种方法之一实现：

1. 生成器函数（Generator Function）

生成器函数与普通函数非常相似，但是它们使用关键字 yield 而不是 return 来返回值。当生成器函数被调用时，它并不会立即执行，而是返回一个生成器对象。在迭代这个对象时，生成器函数将执行，直到遇到一个 yield 语句，此时函数会暂停，并将 yield 后面的值返回给调用者。函数的状态会被保留，因此在下次迭代时它将从上次停止的地方继续执行。

以下是一个简单的生成器函数例子：

def simple_generator():
    yield 1
    yield 2
    yield 3

gen = simple_generator()
for item in gen:
    print(item)

输出结果：

1
2
3

1. 生成器表达式（Generator Expression）

生成器表达式是一种更简洁的创建生成器的方法，类似于列表生成式。生成器表达式使用圆括号 () 将表达式包含起来，而不是像列表生成式使用方括号 []。

以下是一个简单的生成器表达式例子：

# 生成一个包含平方数的生成器
squares_gen = (x**2 for x in range(1, 6))

for square in squares_gen:
    print(square)

输出结果：

1
4
9
16
25

生成器是一种非常有用的工具，可以在处理大规模数据时帮助减少内存占用。

常用的函数

1.lambda（）

lambda 函数，也称为匿名函数或拉姆达表达式，是 Python 中一种简洁的创建小型、临时函数的方法。lambda 函数的主要目的是减少代码量，通常用于需要传入一个简单函数作为参数的情况，如 map() 、filter() 或 sorted() 等函数。

lambda 函数的语法如下：

lambda arguments: expression

其中：

• lambda 是关键字，表示定义一个匿名函数
• arguments 是传递给匿名函数的参数列表
• expression 是一个关于参数的表达式，它的计算结果是匿名函数的返回值

注意，lambda 函数仅能包含一个表达式，不能包含复杂的语句或多个表达式。此外，它不能使用 return 关键字，因为 lambda 函数的返回值是表达式的计算结果。

以下是一些 lambda 函数的例子：

例1：创建一个接受两个参数的 lambda 函数，返回它们之和：

add = lambda x, y: x + y
result = add(5, 3)
print(result)  # 输出 8

例2：使用 lambda 函数将列表中所有元素都乘以 2：

numbers = [1, 2, 3, 4, 5]
doubled_numbers = list(map(lambda x: x * 2, numbers))
print(doubled_numbers)  # 输出 [2, 4, 6, 8, 10]

例3：使用 lambda 函数筛选出列表中的偶数：

numbers = [1, 2, 3, 4, 5]
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers)  # 输出 [2, 4]

虽然 lambda 函数可以提高代码的简洁性，但它不应该用于处理复杂的逻辑。在这种情况下，定义一个普通的函数会更清晰和易于维护。

map() 和 filter() 是 Python 中的内置函数，它们用于对可迭代对象（如列表、元组等）进行处理。这两个函数都可以与匿名函数（lambda 函数）结合使用，以便更简洁地处理序列数据。

2.map()

map() 函数用于对可迭代对象的每个元素应用指定的函数。它接收两个参数：

• 一个函数（作用于每个元素）
• 一个可迭代对象（包含待处理的元素）

map() 函数返回一个迭代器，可以使用 list() 函数将其转换为列表。以下是一个简单的示例：

def square(x):
    return x ** 2

numbers = [1, 2, 3, 4, 5]
squares = list(map(square, numbers))

上面的示例会得到一个新列表 squares，其值为 [1, 4, 9, 16, 25]。这里的 square 函数可以用 lambda 函数替换，使代码更简洁：

numbers = [1, 2, 3, 4, 5]
squares = list(map(lambda x: x ** 2, numbers))

3. filter()

filter() 函数用于筛选出可迭代对象中满足给定条件的元素。它接收两个参数：

• 一个返回布尔值（True 或 False）的函数（用于判断元素是否满足条件）
• 一个可迭代对象（包含待筛选的元素）

filter() 函数返回一个迭代器，可以使用 list() 函数将其转换为列表。以下是一个简单的示例：

def is_even(x):
    return x % 2 == 0

numbers = [1, 2, 3, 4, 5]
even_numbers = list(filter(is_even, numbers))

上面的示例会得到一个新列表 even_numbers，其值为 [2, 4]。这里的 is_even 函数可以用 lambda 函数替换，使代码更简洁：

numbers = [1, 2, 3, 4, 5]
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))

总之，map() 和 filter() 函数在处理序列数据时非常有用。map() 函数用于对序列中的每个元素应用指定的函数，而 filter() 函数则用于筛选出满足给定条件的元素。