知识点:从迭代器一直撸到yield from

时间:2021-05-02 23:31:13

最近在跟一个系列,

难度和篇幅比较合适我这样的懒人。

敲下代码,作下注释,看看输出,就蛮好。

https://www.cnblogs.com/wongbingming/p/9095243.html

import collections
from collections.abc import Iterable, Iterator, Generator
from inspect import getgeneratorstate

"""
借助collections.abc这个模块,
使用isinstance()来类别一个对象是否是可迭代的(Iterable),
是否是迭代器(Iterator),
是否是生成器(Generator)。
"""

astr = "XiaoMing"
print("String: {}".format(astr))
print(isinstance(astr, Iterable))
print(isinstance(astr, Iterator))
print(isinstance(astr, Generator))

# String: XiaoMing
# True
# False
# False

"""
从结果来看,这些可迭代对象都不是迭代器,也不是生成器。
它们有一个共同点,就是它们都可以使用for来循环。
"""
alist = [21, 45, 65, 78]
print("List: {}".format(alist))
print(isinstance(alist, Iterable))
print(isinstance(alist, Iterator))
print(isinstance(alist, Generator))
# List: [21, 45, 65, 78]
# True
# False
# False

adict = {'name': "xiaoming", 'age': 18}
print("Dict: {}".format(adict))
print(isinstance(adict, Iterable))
print(isinstance(adict, Iterator))
print(isinstance(adict, Generator))
# Dict: {'name': 'xiaoming', 'age': 18}
# True
# False
# False

"""
可迭代对象,是其内部实现了,__iter__ 这个魔术方法。
可以通过,dir()方法来查看是否有__iter__来判断一个变量是否是可迭代的。
"""
adeque = collections.deque('abcdefg')
print("deque: {}".format(adeque))
print(isinstance(adeque, Iterable))
print(isinstance(adeque, Iterator))
print(isinstance(adeque, Generator))
# deque: deque(['a', 'b', 'c', 'd', 'e', 'f', 'g'])
# True
# False
# False

"""
对比可迭代对象,迭代器其实就只是多了一个函数而已。
就是__next__(),我们可以不再使用for循环来间断获取元素值。
而可以直接使用next()方法来实现。
可以通过,dir()方法来查看是否有__next__来判断一个变量是否是迭代器的
"""
aIterator = iter(astr)
print("aIterator: {}".format(aIterator))
print(isinstance(aIterator, Iterable))
print(isinstance(aIterator, Iterator))
print(isinstance(aIterator, Generator))
# aIterator: <str_iterator object at 0x00000000023F5358>
# True
# True
# False

"""
而生成器,则是在迭代器的基础上(可以用for循环,可以使用next()),再实现了yield。

yield 是什么东西呢,它相当于我们函数里的return。
在每次next(),或者for遍历的时候,
都会yield这里将新的值返回回去,并在这里阻塞,等待下一次的调用。
正是由于这个机制,才使用生成器在Python编程中大放异彩。
实现节省内存,实现异步编程。
可迭代对象和迭代器,是将所有的值都生成存放在内存中,
而生成器则是需要元素才临时生成,节省时间,节省空间。
"""
aGenerator = (x*x for x in range(10))
print("aGenerator: {}".format(aGenerator))
print(isinstance(aGenerator, Iterable))
print(isinstance(aGenerator, Iterator))
print(isinstance(aGenerator, Generator))
# aGenerator: <generator object <genexpr> at 0x0000000002727FC0>
# True
# True
# True

"""
由于生成器并不是一次生成所有元素,而是一次一次的执行返回,
那么如何刺激生成器执行(或者说激活)呢?
激活主要有两个方法

使用next()
使用generator.send(None)

通过交替执行,说明这两种方法是等价的。
"""
gen = aGenerator
print(gen.send(None))
print(next(gen))
print(gen.send(None))
print(next(gen))
print(gen.send(None))
print(next(gen))
# 0
# 1
# 4
# 9
# 16
# 25
"""
生成器在其生命周期中,会有如下四个状态

GEN_CREATED # 等待开始执行
GEN_RUNNING # 解释器正在执行(只有在多线程应用中才能看到这个状态)
GEN_SUSPENDED # 在yield表达式处暂停
GEN_CLOSED # 执行结束

在生成器工作过程中,
若生成器不满足生成元素的条件,
就会/应该 抛出异常(StopIteration)。
我们在自己定义一个生成器的时候,
我们也应该在不满足生成元素条件的时候,抛出异常。
"""


def mygen(n):
    now = 0
    while now < n:
        yield now
        now += 1
    # 抛出异常
    raise StopIteration


gen2 = mygen(2)
print(getgeneratorstate(gen2))
print(next(gen2))
print(getgeneratorstate(gen2))
print(next(gen2))
gen2.close()
print(getgeneratorstate(gen2))
# GEN_CREATED
# 0
# GEN_SUSPENDED
# 1
# GEN_CLOSED

"""
协程和线程,有相似点,多个协程之间和线程一样,只会交叉串行执行;
也有不同点,线程之间要频繁进行切换,加锁,解锁,
从复杂度和效率来看,和协程相比,这确是一个痛点。
协程通过使用 yield 暂停生成器,
可以将程序的执行流程交给其他的子程序,
从而实现不同子程序的之间的交替执行。
"""


def jumping_range(N):
    index = 0
    while index < N:
        # yield index 是将index return给外部调用程序。
        # jump = yield 可以接收外部程序通过send()发送的信息,并赋值给jump
        jump = yield index
        if jump is None:
            jump = 1
        index += jump
    # 抛出异常
    raise StopIteration


itr = jumping_range(5)
print(next(itr))
print(itr.send(2))
print(itr.send(-1))
print(itr.send(None))
print(next(itr))
print(itr.send(-2))
print(next(itr))
# 0
# 2
# 1
# 2
# 3
# 1
# 2

"""
yield from后面加上可迭代对象,
他可以把可迭代对象里的每个元素一个一个的yield出来,
对比yield来说代码更加简洁,结构更加清晰。
"""


def gen3(*args, **kwargs):
    for item in args:
        yield from item


new_list = gen3(astr, alist, adict, aGenerator)
print(list(new_list))
# ['X', 'i', 'a', 'o', 'M', 'i', 'n', 'g', 21, 45, 65, 78, 'name', 'age', 36, 49, 64, 81]

# 子生成器
def average_gen():
    total = 0
    count = 0
    average = 0
    while True:
        # 子生成器yield的值,直接返回给调用方。
        new_num = yield average
        if new_num is None:
            break
        count += 1
        total += new_num
        average = total/count
    # 每一次return,都意味着当前协程结束。
    return total, count, average


# 委托生成器
# 作用是:在调用方与子生成器之间建立一个双向通道。
def proxy_gen():
    while True:
        # 只有子生成器要结束(return)了,
        # yield from左边的变量才会被赋值,后面的代码才会执行。
        total, count, average = yield from average_gen()
        print("计算完毕!!\n总共传入 {} 个数值, 总和:{},平均数:{}"
              .format(count, total, average))


# 调用方
def main_gen():
    calc_average = proxy_gen()
    next(calc_average)
    # 调用方可以通过send()直接发送消息给子生成器
    print(calc_average.send(10))
    print(calc_average.send(20))
    print(calc_average.send(30))
    calc_average.send(None) # 结束协程
    # 如果此处再调用calc_average.send(10),由于上一协程已经结束,将重开一协程

main_gen()
# 10.0
# 15.0
# 20.0
# 计算完毕!!
# 总共传入 3 个数值, 总和:60,平均数:20.0