Python中的yield-易微帮

文章目录

1. Python中的yield

yield 是 Python 中用于创建生成器的关键字之一。它可以在函数内部暂停执行并返回一个值，但是保留了函数的状态，使得函数可以在后续调用时恢复执行，从上次暂停的地方继续执行。这种特性使得生成器可以逐步产生值，而不需要一次性将所有值存储在内存中，从而节省了内存空间。

1.1 一个简单的示例

我们可以通过一个简单的示例来说明 yield 的使用：

def count_up_to(limit):
    count = 1
    while count <= limit:
        yield count
        count += 1

# 创建一个生成器对象
counter = count_up_to(5)

# 逐步获取生成器产生的值并打印
print(next(counter))  # 输出：1
print(next(counter))  # 输出：2
print(next(counter))  # 输出：3
print(next(counter))  # 输出：4
print(next(counter))  # 输出：5

1.2 示例的每一步含义

def count_up_to(limit):：这是一个生成器函数的定义，它命名为 count_up_to，接受一个参数 limit，用于指定计数的上限。
count = 1：这是计数器的初始化，从 1 开始计数。
while count <= limit:：这是一个循环，它会在计数小于等于上限时持续执行。
yield count：这是 yield 语句，它会产生当前计数值并暂停函数的执行。在每次迭代中，生成器会生成一个值并将控制权返回给调用方。
count += 1：这是计数器的增加步骤，每次迭代时，计数器增加 1。
counter = count_up_to(5)：这里创建了一个生成器对象，调用 count_up_to() 函数并将其赋值给变量 counter。
print(next(counter))：在生成器对象上调用 next() 函数，这会使生成器函数从上次暂停的地方继续执行，生成并返回下一个计数值。

通过 yield，我们可以实现一个能够逐步产生数值的生成器函数。这个函数在每次迭代时都会生成一个值并暂停执行，直到下一次迭代开始。这种逐步生成值的方式非常高效，特别是在处理大量数据或无限序列时。

2. yield 和return的区别

yield 和 return 在 Python 中有着不同的作用，尽管它们都可以用于函数中的值的返回，但它们之间有着关键的区别。

2.1 一个简单的示例

让我们通过一个示例来说明它们的区别：

def generator_with_yield():
    yield 1
    yield 2
    yield 3

def function_with_return():
    return [1, 2, 3]

# 使用生成器函数
gen = generator_with_yield()
print(next(gen))  # 输出：1
print(next(gen))  # 输出：2
print(next(gen))  # 输出：3

# 使用普通函数
result = function_with_return()
print(result)  # 输出：[1, 2, 3]

2.2 示例中每一步的含义

def generator_with_yield():：这是一个生成器函数的定义。它使用 yield 语句产生值。在每次调用 next() 时，函数会执行到下一个 yield 语句，生成一个值并暂停执行，直到下一次调用。
def function_with_return():：这是一个普通函数的定义。它使用 return 语句来返回一个列表。
gen = generator_with_yield()：这里创建了一个生成器对象，调用 generator_with_yield() 函数并将其赋值给变量 gen。
print(next(gen))：在生成器对象上调用 next() 函数，这会使生成器函数从头开始执行，生成第一个值并返回。每次调用 next()，生成器函数都会继续执行，直到遇到下一个 yield 语句为止。
result = function_with_return()：在普通函数上调用，它会执行函数内部的代码，生成并返回一个列表。
print(result)：打印普通函数的返回值，这是一个包含 [1, 2, 3] 的列表。

关键区别：

yield 可以在生成器函数中多次返回值，并且函数的状态会被保留，可以在后续调用中恢复执行。这使得生成器函数可以实现惰性计算和逐步生成值的功能。
return 一旦执行，会立即结束函数的执行，并将一个值返回给调用方。函数的状态不会被保留，无法恢复执行。

总的来说，yield 用于创建生成器函数，支持暂停和恢复执行，而 return 用于普通函数，用于一次性返回值并终止函数执行。

3. yield中的send()方法

在 Python 的 yield 中，send() 是一种方法，它允许在生成器函数内部发送数据，并使生成器继续执行。这种方法可以用于在生成器的每次迭代中向其提供值，以及控制生成器的行为。

3.1 一个简单的示例

下面是一个简单的示例，演示了如何在生成器函数中使用 send() 方法：

def accumulator():
    total = 0
    while True:
        value = yield total
        if value is not None:
            total += value

# 创建一个生成器对象
acc_gen = accumulator()

# 启动生成器
next(acc_gen)

# 使用 send() 方法向生成器发送值并获取结果
print(acc_gen.send(1))  # 输出：1
print(acc_gen.send(2))  # 输出：3
print(acc_gen.send(3))  # 输出：6

3.2 示例中每一步的含义

def accumulator():：这是一个生成器函数的定义，命名为 accumulator。它没有参数。
total = 0：这是累加器的初始化，开始时总和为 0。
while True:：这是一个无限循环，表示生成器函数会一直执行，直到外部调用方主动关闭生成器。
value = yield total：这是 yield 语句，它会生成当前的总和值，并暂停函数的执行。在每次迭代中，生成器会生成一个值并将控制权返回给调用方。同时，它也是一个接收来自外部的值的地方，通过 send() 方法向生成器发送值。
if value is not None:：这是一个条件语句，检查发送的值是否为 None，如果不是 None，则表示有新的值要累加到总和中。
total += value：这是将新值累加到总和中的步骤。
acc_gen = accumulator()：这里创建了一个生成器对象，调用 accumulator() 函数并将其赋值给变量 acc_gen。
next(acc_gen)：这是启动生成器的步骤，通过 next() 函数开始执行生成器函数，使其执行到第一个 yield 语句处暂停。
print(acc_gen.send(1))：在生成器对象上调用 send() 方法，发送值 1 给生成器，并获取生成器生成的总和值。

通过 send() 方法，我们可以在生成器的每次迭代中向其提供值，并控制生成器的行为。这种方法使得生成器函数更加灵活，可以与外部环境进行双向通信。

4. yield中的throw()方法

在 Python 的 yield 中，throw() 是一种方法，它允许在生成器函数内部抛出一个指定的异常，并使生成器处理该异常。这种方法可以用于在生成器函数中处理错误或特定情况，并根据需要采取相应的行动。

4.1 一个简单的示例

下面是一个简单的示例，演示了如何在生成器函数中使用 throw() 方法：

def catcher():
    try:
        while True:
            try:
                value = yield
                print("Received:", value)
            except ValueError as ve:
                print("ValueError occurred:", ve)
    except GeneratorExit:
        print("Generator closed.")

# 创建一个生成器对象
gen = catcher()
next(gen)  # 启动生成器

# 在生成器中抛出异常
gen.throw(ValueError("Invalid value"))

# 继续在生成器中发送值
gen.send(10)

# 关闭生成器
gen.close()

4.2 示例中每一步的含义

def catcher():：这是一个生成器函数的定义，命名为 catcher。它没有参数。
try:：这是一个 try 块，表示生成器函数会尝试执行其中的代码。
while True:：这是一个无限循环，表示生成器函数会一直执行，直到外部调用方主动关闭生成器。
try:：这是内部的 try 块，用于捕获可能在 yield 语句周围发生的异常。
value = yield：这是 yield 语句，它会暂停函数的执行，并等待外部发送的值。在每次迭代中，生成器会生成一个值并将控制权返回给调用方。
except ValueError as ve:：这是一个 except 块，用于捕获特定类型的异常（在这里是 ValueError）。
print("Received:", value)：这是打印接收到的值的步骤。
except GeneratorExit:：这是一个特殊的 except 块，用于捕获生成器关闭时的异常。
gen = catcher()：这里创建了一个生成器对象，调用 catcher() 函数并将其赋值给变量 gen。
next(gen)：这是启动生成器的步骤，通过 next() 函数开始执行生成器函数，使其执行到第一个 yield 语句处暂停。
gen.throw(ValueError("Invalid value"))：在生成器对象上调用 throw() 方法，抛出一个 ValueError 异常。
gen.send(10)：继续在生成器中发送值，这里发送了一个整数值 10。
gen.close()：关闭生成器，这将导致生成器函数抛出 GeneratorExit 异常，生成器函数中的相应代码将被执行。

通过 throw() 方法，我们可以在生成器函数中抛出异常，并根据需要进行处理。这种方法使得生成器函数更加灵活，可以在生成器内部处理错误或特定情况。

Python中的yield