在Python中如何使用yield

一、生成器

如果在一个方法内,包含了 yield 关键字,那么这个函数就是一个「生成器」。

生成器其实就是一个特殊的迭代器,它可以像迭代器那样,迭代输出方法内的每个元素。

我们来看一个包含 yield 关键字的方法:

# coding: utf8

# 生成器
def gen(n):
    for i in range(n):
        yield i

g = gen(5)      # 创建一个生成器
print(g)        # <generator object gen at 0x10bb46f50>
print(type(g))  # <type 'generator'>

# 迭代生成器中的数据
for i in g:
    print(i)

# Output:
# 0 1 2 3 4

注意,在这个例子中,当我们执行 g = gen(5) 时,gen 中的代码其实并没有执行,此时我们只是创建了一个「生成器对象」,它的类型是 generator

然后,当我们执行 for i in g,每执行一次循环,就会执行到 yield 处,返回一次 yield 后面的值。

这个迭代过程是和迭代器最大的区别。

换句话说,如果我们想输出 5 个元素,在创建生成器时,这个 5 个元素其实还并没有产生,什么时候产生呢?只有在执行for循环遇到 yield 时,才会依次生成每个元素。

此外,生成器除了和迭代器一样实现迭代数据之外,还包含了其他方法:

  • generator.__next__():执行 for 时调用此方法,每次执行到 yield 就会停止,然后返回 yield 后面的值,如果没有数据可迭代,抛出 StopIterator 异常,for 循环结束
  • generator.send(value):外部传入一个值到生成器内部,改变 yield 前面的值
  • generator.throw(type[, value[, traceback]]):外部向生成器抛出一个异常
  • generator.close():关闭生成器

通过使用生成器的这些方法,我们可以完成很多有意思的功能。

二、next

先来看生成器的 __next__ 方法,我们看下面这个例子。

# coding: utf8

def gen(n):
    for i in range(n):
        print('yield before')
        yield i
        print('yield after')

g = gen(3)      # 创建一个生成器
print(g.__next__())  # 0
print('----')
print(g.__next__())  # 1
print('----')
print(g.__next__())  # 2
print('----')
print(g.__next__())  # StopIteration

# Output:
# yield before
# 0
# ----
# yield after
# yield before
# 1
# ----
# yield after
# yield before
# 2
# ----
# yield after
# Traceback (most recent call last):
#   File "gen.py", line 16, in <module>
#     print(g.__next__())  # StopIteration
# StopIteration

在这个例子中,我们定义了 gen 方法,这个方法包含了 yield 关键字。然后我们执行 g = gen(3) 创建一个生成器,但是这次没有执行 for 去迭代它,而是多次调用 g.__next__() 去输出生成器中的元素。

我们看到,当执行 g.__next__()时,代码就会执行到 yield 处,然后返回 yield 后面的值,如果继续调用 g.__next__(),注意,你会发现,这次执行的开始位置,是上次 yield 结束的地方,并且它还保留了上一次执行的上下文,继续向后迭代。

这就是使用 yield 的作用,在迭代生成器时,每一次执行都可以保留上一次的状态,而不是像普通方法那样,遇到 return 就返回结果,下一次执行只能再次重复上一次的流程。

生成器除了能保存状态之外,我们还可以通过其他方式,改变其内部的状态,这就是下面要讲的 sendthrow 方法。

三、send

上面的例子中,我们只展示了在 yield 后有值的情况,其实还可以使用 j = yield i 这种语法,我们看下面的代码:

# coding: utf8

def gen():
    i = 1
    while True:
        j = yield i
        i *= 2
        if j == -1:
            break

此时如果我们执行下面的代码:

for i in gen():
    print(i)
    time.sleep(1)

输出结果会是 1 2 4 8 16 32 64 ... 一直循环下去, 直到我们杀死这个进程才能停止。

这段代码一直循环的原因在于,它无法执行到 j == -1 这个分支里 break 出来,如果我们想让代码执行到这个地方,如何做呢?

这里就要用到生成器的 send 方法了,send 方法可以把外部的值传入生成器内部,从而改变生成器的状态。

g = gen()   # 创建一个生成器
print(g.__next__())  # 1
print(g.__next__())  # 2
print(g.__next__())  # 4
# send 把 -1 传入生成器内部 走到了 j = -1 这个分支
print(g.send(-1))   # StopIteration 迭代停止

当我们执行 g.send(-1) 时,相当于把 -1 传入到了生成器内部,然后赋值给了 yield 前面的 j,此时 j = -1,然后这个方法就会 break 出来,不会继续迭代下去。

四、throw

外部除了可以向生成器内部传入一个值外,还可以传入一个异常,也就是调用 throw 方法:

# coding: utf8

def gen():
    try:
        yield 1
    except ValueError:
        yield 'ValueError'
    finally:
        print('finally')

g = gen()   # 创建一个生成器
print(g.__next__()) # 1
# 向生成器内部传入异常 返回ValueError
print(g.throw(ValueError))

# Output:
# 1
# ValueError
# finally

这个例子创建好生成器后,使用 g.throw(ValueError) 的方式,向生成器内部传入了一个异常,走到了生成器异常处理的分支逻辑。

五、close

生成器的 close 方法也比较简单,就是手动关闭这个生成器,关闭后的生成器无法再进行操作。

>>> g = gen()
>>> g.close() # 关闭生成器
>>> g.__next__() # 无法迭代数据
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

close 方法我们在开发中使用得比较少,了解一下就好。

六、使用场景

了解了 yield 和生成器的使用方式,那么 yield生成器一般用在哪些业务场景中呢?

下面我介绍几个例子,分别是大集合的生成、简化代码结构、协程与并发,你可以参考这些使用场景来使用 yield

大集合的生成

如果你想生成一个非常大的集合,如果使用 list 创建一个集合,这会导致在内存中申请一个很大的存储空间,例如想下面这样:

# coding: utf8

def big_list():
    result = []
    for i in range(10000000000):
        result.append(i)
    return result

# 一次性在内存中生成大集合 内存占用非常大
for i in big_list():
    print(i)

这种场景,我们使用生成器就能很好地解决这个问题。

因为生成器只有在执行到 yield 时才会迭代数据,这时只会申请需要返回元素的内存空间,代码可以这样写:

# coding: utf8

def big_list():
    for i in range(10000000000):
        yield i

# 只有在迭代时 才依次生成元素 减少内存占用
for i in big_list():
    print(i)

简化代码结构

我们在开发时还经常遇到这样一种场景,如果一个方法要返回一个 list,但这个 list 是多个逻辑块组合后才能产生的,这就会导致我们的代码结构变得很复杂:

# coding: utf8

def gen_list():
    # 多个逻辑块 组成生成一个列表
    result = []
    for i in range(10):
        result.append(i)
    for j in range(5):
        result.append(j * j)
    for k in [100, 200, 300]:
        result.append(k)
    return result

for item in gen_list():
    print(item)

这种情况下,我们只能在每个逻辑块内使用 appendlist 中追加元素,代码写起来比较啰嗦。

此时如果使用 yield 来生成这个 list,代码就简洁很多:

# coding: utf8

def gen_list():
    # 多个逻辑块 使用yield 生成一个列表
    for i in range(10):
        yield i
    for j in range(5):
        yield j * j
    for k in [100, 200, 300]:
        yield k

for item in gen_list():
    print(i)

使用 yield 后,就不再需要定义 list 类型的变量,只需在每个逻辑块直接 yield 返回元素即可,可以达到和前面例子一样的功能。

我们看到,使用 yield 的代码更加简洁,结构也更清晰,另外的好处是只有在迭代元素时才申请内存空间,降低了内存资源的消耗。

七、协程与并发

还有一种场景是 yield 使用非常多的,那就是「协程与并发」。

如果我们想提高程序的执行效率,通常会使用多进程、多线程的方式编写程序代码,最常用的编程模型就是「生产者-消费者」模型,即一个进程 / 线程生产数据,其他进程 / 线程消费数据。

在开发多进程、多线程程序时,为了防止共享资源被篡改,我们通常还需要加锁进行保护,这样就增加了编程的复杂度。

在 Python 中,除了使用进程和线程之外,我们还可以使用「协程」来提高代码的运行效率。

什么是协程?

简单来说,由多个程序块组合协作执行的程序,称之为「协程」。

而在 Python 中使用「协程」,就需要用到 yield 关键字来配合。

可能这么说还是太好理解,我们用 yield 实现一个协程生产者、消费者的例子:

# coding: utf8

def consumer():
    i = None
    while True:
        # 拿到 producer 发来的数据
        j = yield i
        print('consume %s' % j)

def producer(c):
    c.__next__()
    for i in range(5):
        print('produce %s' % i)
        # 发数据给 consumer
        c.send(i)
    c.close()

c = consumer()
producer(c)

# Output:
# produce 0
# consume 0
# produce 1
# consume 1
# produce 2
# consume 2
# produce 3
# consume 3
...

这个程序的执行流程如下:

1.c = consumer() 创建一个生成器对象

2.producer(c) 开始执行,c.__next()__会启动生成器 consumer 直到代码运行到 j = yield i 处,此时 consumer 第一次执行完毕,返回

3.producer 函数继续向下执行,直到 c.send(i)处,这里利用生成器的 send 方法,向 consumer 发送数据

4.consumer 函数被唤醒,从 j = yield i 处继续开始执行,并且接收到 producer 传来的数据赋值给 j,然后打印输出,直到再次执行到 yield 处,返回

5.producer 继续循环执行上面的过程,依次发送数据给 cosnumer,直到循环结束

6.最终 c.close() 关闭 consumer 生成器,程序退出

在这个例子中我们发现,程序在 producerconsumer 这 2 个函数之间来回切换执行,相互协作,完成了生产任务、消费任务的业务场景,最重要的是,整个程序是在单进程单线程下完成的。

到此这篇关于在Python中如何使用yield的文章就介绍到这了,更多相关yield的用法内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • Python中Yield的基本用法

    带有yield的函数在Python中被称之为generator(生成器),也就是说,当你调用这个函数的时候,函数内部的代码并不立即执行 ,这个函数只是返回一个生成器(Generator Iterator). def generator(): for i in range(10) : yield i*i gen = generator() print(gen) <generator object generator at 0x7ffaad115aa0> 1. 使用next方法迭代生成器 gene

  • python中yield的用法详解——最简单,最清晰的解释

    首先我要吐槽一下,看程序的过程中遇见了yield这个关键字,然后百度的时候,发现没有一个能简单的让我懂的,讲起来真TM的都是头头是道,什么参数,什么传递的,还口口声声说自己的教程是最简单的,最浅显易懂的,我就想问没有有考虑过读者的感受. 接下来是正题: 首先,如果你还没有对yield有个初步分认识,那么你先把yield看做"return",这个是直观的,它首先是个return,普通的return是什么意思,就是在程序中返回某个值,返回之后程序就不再往下运行了.看做return之后再把它

  • Python中生成器和yield语句的用法详解

    在开始课程之前,我要求学生们填写一份调查表,这个调查表反映了它们对Python中一些概念的理解情况.一些话题("if/else控制流" 或者 "定义和使用函数")对于大多数学生是没有问题的.但是有一些话题,大多数学生只有很少,或者完全没有任何接触,尤其是"生成器和yield关键字".我猜这对大多数新手Python程序员也是如此. 有事实表明,在我花了大功夫后,有些人仍然不能理解生成器和yield关键字.我想让这个问题有所改善.在这篇文章中,我将解

  • Python yield的用法实例分析

    本文实例讲述了Python yield的用法.分享给大家供大家参考,具体如下: yield的英文单词意思是生产,刚接触Python的时候感到非常困惑,一直没弄明白yield的用法. 只是粗略的知道yield可以用来为一个函数返回值塞数据,比如下面的例子: def addlist(alist): for i in alist: yield i + 1 取出alist的每一项,然后把i + 1塞进去.然后通过调用取出每一项: alist = [1, 2, 3, 4] for x in addlist

  • python yield和Generator函数用法详解

    这篇文章主要介绍了python yield和Generator函数用法详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 首先我们从一个小程序导入,各定一个list,找出其中的素数,我们会这样写 import math def is_Prims(number): if number == 2: return True //除2以外的所有偶数都不是素数 elif number % 2 == 0: return False //如果一个数能被除1和

  • 举例详解Python中yield生成器的用法

    yield是生成的意思,但是在python中则是作为生成器理解,生成器的用处主要可以迭代,这样简化了很多运算模型(还不是很了解是如何简化的). yield是一个表达式,是有返回值的. 当一个函数中含有yield时,它不再是一个普通的函数,而是一个生成器.当该函数被调用时不会自动执行,而是暂停,见第一个例子: 例1: >>> def mygenerator(): ... print 'start...' ... yield 5 ... >>> mygenerator()

  • python3.6生成器yield用法实例分析

    本文实例讲述了python3.6生成器yield用法.分享给大家供大家参考,具体如下: 今天看源码的时候看到了一个比较有意思的函数:yield 功能与return类似,都是返回定义的函数的一个结果,不同的是return返回后这次调用函数就结束了,除了返回值,其余临时变量都会被清除.而yield会停止在当前步,并保留其余变量的值,等下次调用该函数时,从yield的下一步继续往下运行. yield的好处是如果函数需要很大的内存,比方说需要计算并返回一个很大的数列,如果用return,我们只能用一个l

  • Python协程 yield与协程greenlet简单用法示例

    本文实例讲述了Python协程 yield与协程greenlet简单用法.分享给大家供大家参考,具体如下: 协程 协程,又称微线程,纤程.英文名Coroutine. 协程是啥 协程是python个中另外一种实现多任务的方式,只不过比线程更小占用更小执行单元(理解为需要的资源). 为啥说它是一个执行单元,因为它自带CPU上下文.这样只要在合适的时机, 我们可以把一个协程 切换到另一个协程. 只要这个过程中保存或恢复 CPU上下文那么程序还是可以运行的. 通俗的理解:在一个线程中的某个函数,可以在任

  • python中yield的用法详解

    首先我要吐槽一下,看程序的过程中遇见了yield这个关键字,然后百度的时候,发现没有一个能简单的让我懂的,讲起来真TM的都是头头是道,什么参数,什么传递的,还口口声声说自己的教程是最简单的,最浅显易懂的,我就想问没有有考虑过读者的感受. 接下来是正题: 首先,如果你还没有对yield有个初步分认识,那么你先把yield看做"return",这个是直观的,它首先是个return,普通的return是什么意思,就是在程序中返回某个值,返回之后程序就不再往下运行了.看做return之后再把它

  • Python中xrange与yield的用法实例分析

    本文实例分析了Python中xrange与yield的用法.分享给大家供大家参考,具体如下: range和xrange Python提供了生成和返回整数序列的内置函数range及xrange,虽然这两个函数在功能上是差不多的,但其实现原理还是有差别的.range(n, m)返回的是一个从n到(m-1)的连续的整数列表,而xrange(n, m)返回的却是一个特殊的目的对象,即xrange对象本身. >>> range(1, 5) [1, 2, 3, 4] >>> xra

随机推荐