Python生成器怎么用？yield详解与实例

哈喽！今天心血来潮给大家带来了《Python生成器怎么用？yield关键字全解析》，想必大家应该对文章都不陌生吧，那么阅读本文就都不会很困难，以下内容主要涉及到，若是你正在学习文章，千万别错过这篇文章~希望能帮助到你！

生成器是Python中一种特殊的函数，使用yield关键字实现，与普通函数不同，它按需生成值，节省内存。1. 生成器在执行过程中可暂停并返回值，下次调用时继续执行；2. 适用于处理大数据或无限序列，具有内存效率高、性能优化等优势；3. yield from用于委托给其他生成器，简化代码并支持协程通信；4. 异常可通过try-except捕获，完成状态由StopIteration表示，close()方法可强制关闭生成器并执行清理。

Python中的生成器是一种特殊的函数，它可以在执行过程中暂停并返回一个值，然后在需要时从暂停的地方继续执行。这得益于yield关键字，它让函数不再是执行一次就结束，而是变成了一个可以按需生成序列的“生产者”，极大地节省了内存开销，尤其是在处理大量数据或无限序列时。

要使用Python生成器，最直接的方式就是在函数定义中包含yield关键字。一旦一个函数包含了yield，它就不再是一个普通的函数，而是变成了一个生成器函数。当你调用这个生成器函数时，它并不会立即执行函数体内的代码，而是返回一个生成器对象（本质上是一个迭代器）。要真正开始执行并获取值，你需要对这个生成器对象调用next()方法，或者更常见地，将其放入for循环中。yield关键字的作用就是将数据“产出”给调用者，并暂停当前函数的执行状态，包括所有的局部变量和执行点。当下次请求值时，函数会从上次yield之后的地方继续执行，直到遇到下一个yield或者函数结束。

# 示例：一个简单的计数器生成器
def count_up_to(n):
    i = 1
    while i <= n:
        print(f"正在生成值: {i}")
        yield i
        i += 1

# 使用生成器
my_counter = count_up_to(3)

print("第一次获取值:")
print(next(my_counter))

print("第二次获取值:")
print(next(my_counter))

print("使用for循环继续获取:")
for num in my_counter:
    print(num)

# 尝试获取更多值，会抛出StopIteration
# print(next(my_counter))

生成器与普通函数有何不同？为何选择生成器？

生成器函数与普通函数在行为模式上有着根本的区别，这决定了它们各自适用的场景。普通函数在被调用时，会从头到尾执行一遍，计算出所有结果，然后返回一个最终的值或一个数据结构（比如列表）。这意味着，如果你的函数需要处理大量数据并返回一个集合，它会一次性在内存中构建出整个集合。

而生成器函数则不同，它返回的是一个迭代器。当你遍历这个迭代器时，生成器函数才会在每次请求时按需计算并yield出一个值。这种“惰性计算”模式是其核心优势。想象一下，如果你需要处理一个包含数十亿条记录的文件，或者生成一个无限序列（比如斐波那契数列），普通函数会直接让你的内存爆炸。生成器则可以优雅地处理这些情况，因为它在任何时刻都只在内存中保留当前需要处理的数据和生成器的状态，而不是整个数据集。

选择生成器，通常是出于以下几个考量：

1. 内存效率：这是最主要的原因。当你面对的数据量巨大，无法一次性载入内存时，生成器是理想选择。它避免了创建大型中间数据结构，显著降低了内存占用。
2. 性能优化：对于某些计算密集型任务，如果你不需要立即得到所有结果，而是可以逐个处理，生成器能够让你更快地开始处理第一个结果，而不是等待所有结果都计算完毕。这在数据流处理、管道化操作中尤其有用。
3. 无限序列：只有生成器才能处理无限序列，因为它们不会尝试一次性生成所有元素。
4. 代码简洁性与可读性：对于复杂的迭代逻辑，使用生成器可以使代码更清晰、更易于理解。它将迭代逻辑封装在一个函数内部，外部调用者只需要关注如何消费数据，而不需要关心数据是如何一步步生成的。

例如，读取一个大文件并逐行处理，使用生成器会比一次性readlines()然后遍历更加高效和安全。

# 读取大文件示例
def read_large_file(file_path):
    with open(file_path, 'r', encoding='utf-8') as f:
        for line in f:
            yield line.strip() # 逐行返回，不一次性加载所有行

# 使用
# for data_line in read_large_file('my_huge_data.log'):
#     process(data_line)

yield from 的使用场景与优势是什么？

yield from是Python 3.3引入的一个语法糖，它的主要作用是“委托”给另一个生成器或可迭代对象。简单来说，它允许一个生成器直接将一部分迭代任务交给另一个生成器来完成，而无需显式地循环并逐个yield子生成器产生的值。这在构建复杂的、由多个子任务组成的生成器链时，能让代码变得异常简洁和高效。

考虑一个场景，你需要从多个来源获取数据，或者一个数据处理流程可以分解为几个独立的子步骤，每个步骤都可以是一个生成器。如果没有yield from，你可能需要这样写：

def sub_generator_a():
    yield "Data from A1"
    yield "Data from A2"

def sub_generator_b():
    yield "Data from B1"
    yield "Data from B2"

def main_generator_old_way():
    for item in sub_generator_a():
        yield item
    for item in sub_generator_b():
        yield item

# for data in main_generator_old_way():
#     print(data)

有了yield from，代码会变得更加优雅：

def sub_generator_a():
    yield "Data from A1"
    yield "Data from A2"

def sub_generator_b():
    yield "Data from B1"
    yield "Data from B2"

def main_generator_new_way():
    yield from sub_generator_a()
    yield from sub_generator_b()
    # 甚至可以yield from一个列表或元组
    yield from ["More", "Data"]

# for data in main_generator_new_way():
#     print(data)

yield from的优势远不止代码简洁。它还负责处理子生成器与外部调用者之间的所有通信，包括send()、throw()和close()方法。这意味着，如果你通过generator.send(value)向主生成器发送数据，yield from会自动将这个数据传递给被委托的子生成器；如果子生成器抛出异常，异常也会被正确地传递回主生成器，反之亦然。这使得构建复杂的协程（在asyncio出现之前，yield from常用于此）和管道化数据处理变得更加自然和健壮。它就像一个透明的管道，让数据和控制流在主生成器和子生成器之间无缝穿梭。

如何处理生成器中的异常和完成状态？

生成器在执行过程中，同样会遇到异常，并且最终会有一个完成的状态。理解如何处理这些情况对于编写健壮的生成器代码至关重要。

异常处理：

生成器内部的代码可以使用标准的try...except...finally块来捕获和处理异常，就像普通函数一样。如果生成器内部发生了未捕获的异常，这个异常会传播到调用生成器的代码中。

def risky_generator():
    yield 1
    # 模拟一个错误
    raise ValueError("Something went wrong inside the generator!")
    yield 2

# 尝试捕获生成器内部抛出的异常
try:
    gen = risky_generator()
    print(next(gen))
    print(next(gen)) # 这里会抛出异常
except ValueError as e:
    print(f"捕获到生成器内部的错误: {e}")

更高级的用法是，你可以从外部向生成器“注入”一个异常，强制它在当前的yield点抛出异常。这通过生成器对象的throw(type, value, traceback)方法实现。这在某些控制流场景中非常有用，比如当你发现外部条件不再允许生成器继续执行时。

def controlled_generator():
    print("生成器开始")
    try:
        value = yield 1
        print(f"收到外部发送的值: {value}")
        value = yield 2
        print(f"再次收到外部发送的值: {value}")
    except GeneratorExit:
        print("生成器被强制关闭 (GeneratorExit)")
    except Exception as e:
        print(f"生成器内部捕获到异常: {e}")
    finally:
        print("生成器清理完成")
    print("生成器结束")

gen = controlled_generator()
print(next(gen)) # 打印 "生成器开始", 返回 1

try:
    # 从外部抛入一个TypeError
    gen.throw(TypeError, "这是一个外部注入的类型错误")
except StopIteration: # 注意：如果生成器内部捕获并处理了，外部可能不会收到
    print("生成器已停止")
except TypeError as e:
    print(f"外部捕获到异常: {e}") # 如果生成器内部没有捕获，外部会捕获到

完成状态：

当生成器函数体内的代码执行完毕，没有更多的yield语句时，生成器就进入了完成状态。此时，如果继续尝试从生成器中获取值（例如调用next()），Python会自动抛出一个StopIteration异常。for循环能够优雅地处理这个异常，它会在接收到StopIteration时自动停止迭代，因此我们通常不需要显式地捕获它。

def finite_generator():
    yield 'A'
    yield 'B'
    print("生成器已无更多值")

gen = finite_generator()
print(next(gen))
print(next(gen))

try:
    print(next(gen)) # 尝试获取第三个值，会抛出StopIteration
except StopIteration:
    print("生成器已完成迭代，没有更多值了。")

此外，你还可以显式地关闭一个生成器，通过调用generator.close()方法。这会在生成器当前暂停的yield点注入一个GeneratorExit异常。如果生成器内部有finally块，它会在此时被执行，这对于清理资源（比如关闭文件句柄或网络连接）非常有用。

def resource_generator():
    print("资源正在打开...")
    try:
        yield "数据1"
        yield "数据2"
    finally:
        print("资源正在关闭...") # 确保在生成器关闭时执行

gen = resource_generator()
print(next(gen))
gen.close() # 显式关闭生成器，会触发finally块
# 再次尝试next(gen)会直接抛出StopIteration

以上就是《Python生成器怎么用？yield详解与实例》的详细内容，更多关于的资料请关注golang学习网公众号！