python3 生成器与生成器表达式

2023-05-01 20:29 由云淡#风清发表于 #后端开发

在 Python3 中，生成器表达式是一种语言结构，它可以快速地创建一个可迭代对象。生成器表达式类似于列表推导式，但使用圆括号而不是方括号，并且返回的是一个生成器对象而不是一个列表。

在 Python3 中，生成器表达式有两种类型：生成器函数和生成器表达式。

生成器函数：

生成器函数是一种特殊的函数，在函数中使用 yield 语句来生成一个值，然后暂停函数执行并保留当前状态，等待下一次调用时继续执行。生成器函数的优点是可以处理大量数据，因为它们只需要在内存中保存一个值，而不是全部保存在内存中。

例如，以下是一个生成器函数，它可以生成斐波那契数列中的前 n 个数字：

def fibonacci(n):
    a, b = 0, 1
    for i in range(n):
        yield a
        a, b = b, a + b
xx=fibonacci（9）
print(xx)

生成器表达式：

生成器表达式是使用圆括号包围的表达式，其中包含一个 for 循环和一个可选的 if 条件。生成器表达式可以用来生成一个序列，这个序列可以通过迭代访问，但不必事先将所有元素保存在内存中。

例如，以下生成器表达式可以生成一个包含从 1 到 10 的偶数的生成器对象：

gen = (i for i in range(1, 11) if i % 2 == 0)

注意事项：

生成器表达式可以节省内存空间，但是如果需要多次使用生成器对象中的值，则需要将其转换为列表或其他数据结构。
如果生成器表达式中的代码太长或复杂，则建议使用生成器函数来代替，以提高代码的可读性和可维护性。
如果生成器表达式中的代码有副作用（例如修改了全局变量），则可能会导致意外行为，应该避免这种情况。
生成器表达式可以嵌套，但是应该注意不要嵌套过深导致代码难以理解。例如：
```
gen = ((i, j) for i in range(1, 4) for j in range(4, 7))
```
这个生成器表达式可以生成一个包含所有 (1,4) 到 (3,6) 的元组的生成器对象。
生成器表达式中的 for 循环可以有多个，每个循环可以使用一个 if 条件。例如：
```
gen = (i * j for i in range(1, 4) if i % 2 == 0 for j in range(4, 7) if j % 2 != 0)
```
这个生成器表达式可以生成一个包含所有偶数 i 与奇数 j 的乘积的生成器对象。

生成器表达式中的变量作用域只在生成器表达式内部，不会泄露到外部。例如：

x = 10
gen = (x for x in range(1, 5))
print(list(gen))    # 输出 [1, 2, 3, 4]
print(x)    # 输出 10，说明 x 只在生成器表达式内部存在，不会影响外部变量 x 的值。

生成器表达式可以和其他 Python 的内置函数或模块一起使用，例如 map、filter、itertools 等。例如：

import itertools

# 使用 map 函数和生成器表达式生成一个列表，其中每个元素都是平方数。
lst = list(map(lambda x: x ** 2, (i for i in range(1, 5))))
print(lst)    # 输出 [1, 4, 9, 16]

# 使用 itertools 模块中的 zip_longest 函数和生成器表达式生成一个包含所有输入迭代器的元组的列表。
lst = list(itertools.zip_longest((i for i in range(1, 5)), ('a', 'b', 'c')))
print(lst)    # 输出 [(1, 'a'), (2, 'b'), (3, 'c'), (4, None)]

在使用生成器表达式时，应该尽可能地使用惰性求值，即只生成需要的元素，并且在使用完之后立即释放相应的资源。这样可以避免不必要的内存占用和性能问题。
处理大型数据集，例如从文件或数据库中读取数据，并将其用作生成器表达式的输入。这样可以避免一次性加载所有数据，并且节省内存空间。
```
with open('data.txt') as f:
    gen = (line.strip() for line in f if 'error' in line)
    for item in gen:
        print(item)
```
通过生成器表达式实现惰性求值，例如只有当需要时才计算函数的值。这样可以避免不必要的计算和内存占用。
```
def expensive_function(n):
    print(f"Calculating {n}...")
    return n ** 2

gen = (expensive_function(i) for i in range(5))
print(list(gen))    # 输出 Calculating 0... Calculating 1... Calculating 2... Calculating 3... Calculating 4... [0, 1, 4, 9, 16]
```
这个例子中，我们定义了一个函数 expensive_function，并使用一个生成器表达式来生成一个包含前五个数字的平方的列表。在评估生成器表达式时，expensive_function 只有在需要计算平方时才被调用，这样可以避免不必要的计算和内存占用。

在多个迭代器之间生成元素，例如合并两个排序列表并返回一个新的排序列表。

def merge_sorted(lst1, lst2):
    i, j = 0, 0
    while i < len(lst1) and j < len(lst2):
        if lst1[i] <= lst2[j]:
            yield lst1[i]
            i += 1
        else:
            yield lst2[j]
            j += 1
    yield from lst1[i:]
    yield from lst2[j:]

lst1 = [1, 3, 5, 7]
lst2 = [2, 4, 6, 8]
gen = merge_sorted(lst1, lst2)
print(list(gen))    # 输出 [1, 2, 3, 4, 5, 6, 7, 8]

这个例子中，我们定义了一个 merge_sorted 函数来合并两个排序列表，并返回一个新的排序列表。在函数中，我们使用一个生成器函数来生成所有排好序的元素，并在函数返回之前返回它们。这个方法可以在处理大型数据集时节省内存空间，并且可以避免不必要的排序或其他操作。

用于过滤和转换数据，例如将一个列表中的所有元素转换为字符串并删除其中的空格。
```
lst = [' hello ', ' world', '', 'python', '']
gen = (s.strip() for s in lst if s)
print(list(gen))    # 输出 ['hello', 'world', 'python']
```
这个例子中，我们使用一个生成器表达式来对列表中的所有元素进行过滤和转换。具体来说，我们首先使用 if 子句来过滤出所有不为空的字符串，然后使用 strip 方法来删除每个字符串的前导和尾随空格。最后，我们将经过处理的字符串返回为一个生成器对象，并将其转换为一个列表。
生成器表达式可以与其他 Python 内置函数（如 map 和 filter）和模块（如 itertools）结合使用，以实现更高效和优雅的代码。
在使用生成器表达式时，应该尽可能地使用惰性求值，即只生成需要的元素，并在使用完之后立即释放相应的资源。这样可以避免不必要的内存占用和性能问题。
如果生成器表达式中的代码有副作用（例如修改了全局变量），则可能会导致意外行为，应该避免这种情况。
在编写长的生成器表达式时，建议将其分解成多个简单的表达式或生成器函数，以提高代码的可读性和可维护性。
在使用生成器表达式时，应该学会使用列表推导式和普通的 for 循环来进行比较，以选择最适合特定任务的工具。
最后，需要注意的是，生成器表达式虽然非常强大和方便，但也并非万能的。在某些情况下，还是需要使用其他语言结构或算法来解决问题。
在使用生成器表达式时，应该避免使用过多的嵌套循环和条件语句，以免代码变得难以阅读和维护。在这种情况下，建议考虑使用其他数据结构或算法。
使用生成器表达式时，应该尽可能地保持代码简单和易读。这包括命名变量、注释代码和格式化输出，以便其他人可以理解你的代码。
在使用生成器表达式时，需要注意一些性能问题。例如，在处理大型数据集时，可能需要考虑使用并行计算或其他优化算法来提高效率。让我们来看一个例子，说明生成器表达式和列表推导式之间的差异：

让我们来看一个例子，说明生成器表达式和列表推导式之间的差异：

# 列表推导式
lst = [i ** 2 for i in range(1, 11)]
print(lst)

# 生成器表达式
gen = (i ** 2 for i in range(1, 11))
print(list(gen))

个例子中，我们首先使用列表推导式创建一个包含前 10 个数字的平方的列表。然后，我们使用一个生成器表达式来创建一个包含相同元素的生成器对象，并将其转换为一个列表。

一般来说，列表推导式比起生成器表达式更加适合小型数据集，因为它们可以在内存中完全构建出一个列表，并且可以在需要时随时进行索引和修改。另一方面，生成器表达式更适合大型数据集，因为它们只返回必要的元素，而且可以逐个处理每个元素，从而节省内存空间。

Python标准库还提供了许多内置函数和模块，可以帮助我们更加方便地处理和操作生成器。

其中一个比较常见的内置函数是next()函数。它用于从生成器中获取下一个值，并将生成器的执行状态从上一次挂起的位置继续向下执行。

以下是一个使用next()函数打印斐波那契数列的示例：

def fibonacci():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

# 输出前10项斐波那契数列
fib = fibonacci()
for i in range(10):
    print(next(fib))

在这个示例中，使用一个无限循环的生成器函数来计算斐波那契数列。然后，通过调用next()函数逐一输出数列的前10项。每次调用next()函数时，生成器函数会从上一次yield语句挂起的位置继续执行，直到下一个yield语句为止。

除了next()函数之外，Python标准库还提供了一些其他有用的生成器相关函数和模块，例如：

itertools: 一个集合了许多有用的迭代器函数的模块，如排列、组合、笛卡尔积等。
enumerate(): 返回一个由索引和元素组成的迭代器对象，常用于遍历序列时获取元素的索引。
filter(): 返回一个由满足某个条件的元素组成的迭代器对象，常用于过滤序列中的元素。
map(): 对序列中的每个元素应用一个函数，并返回一个由处理结果组成的迭代器对象。
zip(): 将多个序列打包为一个元组构成的迭代器对象，常用于将多个列表或元组同时遍历。

这些函数和模块可以帮助我们更加方便地使用生成器，并让我们的代码变得更加简洁和高效。