python高级_day6

python可迭代对象、迭代器、生成器

   python中内置的序列，如list、tuple、str、bytes、dict、set、collections.deque等都是可迭代对象，但它们不是迭代器。迭代器可以被 next() 函数调用，并不断返回下一个值。Python从可迭代的对象中获取迭代器。迭代器和生成器都是为了惰性求值（lazy evaluation），避免浪费内存空间，实现高效处理大量数据。在Python 3中，生成器有广泛的用途，所有生成器都是迭代器，因为生成器完全实现了迭代器接口。迭代器用于从集合中取出元素，而生成器用于"凭空"生成元素 。PEP 342 给生成器增加了 send() 方法，实现了"基于生成器的协程"。PEP 380允许生成器中可以return返回值，并新增了 yield from 语法结构，打开了调用方和子生成器的双向通道

1 可迭代对象

   可迭代的对象（Iterable）是指使用iter()内置函数可以获取迭代器（Iterator）的对象。python解释器需要迭代对象x时，会自动调用iter(x)，内置的iter()函数有以下作用：

1. 检查对象x是否实现了__iter__()方法，如果实现了该方法就调用它，并尝试获取一个迭代器
2. 如果没有实现__iter__()方法，但是实现了__getitem__(index)方法，尝试按顺序（从索引0开始）获取元素，即参数index是从0开始的整数（int）。之所以会检查是否实现__getitem__(index)方法，为了向后兼容
3. 如果前面都尝试失败，python会抛出TypeError异常，通常会提示'X' object is not iterable（X类型的对象不可迭代），其中X是目标对象所属的类

具体来说，哪些是可迭代对象呢？

• 如果对象实现了能返回迭代器的__iter__()方法，那么对象就是可迭代的
• 如果对象实现了__getitem__(index)方法，而且index参数是从0开始的整数（索引），这种对象也可以迭代的。python中内置的序列类型，如list、tuple、str、bytes、dict、set、collections.deque等都可以迭代，原因是它们都实现了__getitem__()方法（注意： 其实标准的序列还都实现了__iter__()方法）

1.1 判断对象是否可迭代

   从python 3.4开始，检查对象x能否迭代，最准确的方法是：调用iter(x)函数，如果不可迭代，会抛出TypeError异常。这比使用isinstance(x, abc.Iterable)更准确，因为iter(x)函数会考虑到遗留的__getitem__(index)方法，而abc.Iterable类则不会考虑

1.2 __getitem__()

下面构造一个类，它实现了__getitem__()方法。可以给类的构造方法传入包含一些文本的字符串，然后可以逐个单词进行迭代

'''创建test.py模块'''
import re
import reprlib

RE_WORD = re.compile('\w+')

class Sentence:
    def __init__(self, text):
        self.text = text
        self.words = RE_WORD.findall(text)

    def __getitem__(self, index):
        return self.words[index]

    def __len__(self):  # 为了让对象可以迭代没必要实现这个方法，这里是为了完善序列协议，即可以用len(s)获取单词个数
        return len(self.words)

    def __repr__(self):
        return 'Sentence({})'.format(reprlib.repr(self.text))
    
    
# from test import Sentence  # 导入刚创建的类
s = Sentence('I love Python')  # 传入字符串，创建一个Sentence实例

print(s)  # 自动调用__repr__()函数
print(s[0]) # 自动调用__getitem__()函数，和下面效果一样

print(s.__getitem__(0))

for word in s:  # Sentence实例可以迭代
     print(word)


print(list(s))  # 因为可以迭代，所以Sentence对象可以用于构建列表和其它可迭代的类型

from collections import abc

print(isinstance(s, abc.Iterable))  # 不能正确判断Sentence类的对象s是可迭代的对象

print(iter(s))  # 没有抛出异常，返回迭代器，说明Sentence类的对象s是可迭代的

Sentence('I love Python')
I
I
I
love
Python
['I', 'love', 'Python']
False

1.3 __iter__()

   如果实现了__iter__()方法，但该方法没有返回迭代器时，这时调用该方法python的解释器会抛出一个异常

class Foo:
    def __iter__(self):
        pass    

from collections import abc

f = Foo()

print(isinstance(f, abc.Iterable))  # 错误地判断Foo类的对象f是可迭代的对象

print(iter(f))  # 使用iter()方法会抛出异常，即对象f不可迭代，不能用for循环迭代它

True
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
in
9 print(isinstance(f, abc.Iterable)) # 错误地判断Foo类的对象f是可迭代的对象
10

---> 11 print(iter(f)) # 使用iter()方法会抛出异常，即对象f不可迭代，不能用for循环迭代它

TypeError: iter() returned non-iterator of type 'NoneType'

python迭代协议要求iter()必须返回特殊的迭代器对象。下一节会讲迭代器，迭代器对象必须实现__next__()方法，并使用StopIteration异常来通知迭代结束

class Foo:
    def __iter__(self):  # 其实是将迭代请求委托给了列表
        return iter([1, 2, 3])  # iter()函数从列表创建迭代器，等价于[1, 2, 3].__iter__()    

from collections import abc

f = Foo()

print(isinstance(f, abc.Iterable))

print(iter(f))

for i in f:
     print(i)

True

1
2
3

1.4 iter()函数的补充

iter()函数有两种用法：

• iter(iterable) -> iterator： 传入可迭代的对象，返回迭代器
• iter(callable, sentinel) -> iterator： 传入两个参数，第一个参数必须是可调用的对象，用于不断调用（没有参数），产出各个值；第二个值是哨符，这是个标记值，当可调用的对象返回这个值时，触发迭代器抛出 StopIteration 异常，而不产出哨符

# 使用iter()的第二种方法来掷骰子，知道掷出1点为止
from random import randint

def d6():
     return randint(1, 6)

d6_iter = iter(d6, 1)  # 第一个参数是d6函数，第二个参数是哨符

print(d6_iter)  # 这里的 iter 函数返回一个 callable_iterator 对象

for roll in d6_iter:  # for 循环可能运行特别长的时间，不过肯定不会打印 1，因为 1 是哨符
    print(roll)

4
2
4
5
6
5
4
4
4
4
2
5

# 逐行读取文件
with open('mydata.txt') as fp:
    for line in iter(fp.readline, '\n'):  # fp.readline每次返回一行
        print(line)

lj

abc

111

xixixi

hhahahah

2 迭代器

   迭代是数据处理的基石。当扫描内存中放不下的数据集时，我们要找到一种惰性获取数据项的方式，即按需一次获取一个数据项。这就是迭代器模式（Iterator pattern）
   迭代器是这样的对象：实现了无参数的__next__()方法，返回序列中的下一个元素，如果没有元素了，就抛出StopIteration异常。即，迭代器可以被next()函数调用，并不断返回下一个值。
在 python 语言内部，迭代器用于支持：

• for 循环
• 构建和扩展集合类型
• 逐行遍历文本文件
• 列表推导、字典推导和集合推导
• 元组拆包
• 调用函数时，使用 * 拆包实参

2.1 判断对象是否为迭代器

   检查对象x是否为迭代器最好的方式是调用 isinstance(x, abc.Iterator);注意区分可迭代对象和迭代器的区别，判断可迭代对象使用的是iter()函数

from collections import abc

print(isinstance([1,3,5], abc.Iterator))
print(isinstance((2,4,6), abc.Iterator))
print(isinstance({'name': 'wangy', 'age': 18}, abc.Iterator))
print(isinstance({1, 2, 3}, abc.Iterator))
print(isinstance('abc', abc.Iterator))
print(isinstance(100, abc.Iterator))

print(isinstance((x*2 for x in range(5)), abc.Iterator))  # 生成器表达式，后续会介绍

False
False
False
False
False
False
True

   python中内置的序列类型，如list、tuple、str、bytes、dict、set、collections.deque等都是可迭代的对象，但不是迭代器； 生成器一定是迭代器

2.2 __next__()和__iter__()

标准的迭代器接口：

• __next__()： 返回下一个可用的元素，如果没有元素了，抛出StopIteration异常。调用next(x)相当于调用x.__next__()
• __iter__()： 返回迭代器本身（self），以便在应该使用可迭代的对象的地方能够使用迭代器，比如在for循环、list(iterable)函数、sum(iterable, start=0, /)函数等应该使用可迭代的对象地方可以使用迭代器。说明： 如章节1所述，只要实现了能返回迭代器的__iter__()方法的对象就是可迭代的对象，所以，迭代器都是可迭代的对象！

import re
import reprlib

RE_WORD = re.compile('\w+')

# Sentence是可迭代对象
class Sentence:
    def __init__(self, text):
        self.text = text
        self.words = RE_WORD.findall(text)

    def __repr__(self):
        return 'Sentence(%s)' % reprlib.repr(self.text)

    def __iter__(self):
        return SentenceIterator(self.words)  # 迭代协议要求__iter__返回一个迭代器


# SentenceIterator是迭代器
class SentenceIterator:
    def __init__(self, words):
        self.words = words
        self.index = 0

    def __next__(self):
        try:
            word = self.words[self.index]  # 获取 self.index 索引位（从0开始）上的单词。
        except IndexError:
            raise StopIteration()  # 如果 self.index 索引位上没有单词，那么抛出 StopIteration 异常
        self.index += 1
        return word

    def __iter__(self):
        return self  # 返回迭代器本身

2.3 next()函数获取迭代器中下一个元素

   除了可以使用for循环处理迭代器中的元素以外，还可以使用next()函数，它实际上是调用iterator.__next__()，每调用一次该函数，就返回迭代器的下一个元素。如果已经是最后一个元素了，再继续调用next()就会抛出StopIteration异常。一般来说，StopIteration异常是用来通知我们迭代结束的

• next()函数抛出异常

with open('mydata.txt') as fd:
    try:
        while True:
            line = next(fd)
            print(line, end='')
    except StopIteration:
        pass

lj
abc
111
xixixi
hhahahah

wuwuwuw

• next()函数指定默认值

with open('mydata.txt') as fd:
    while True:
        line = next(fd, None)
        if line is None://用==也可以判断
            break
        print(line, end='')

laijie
abc
111
xixixi
hhahahah
wuwuwuw

2.4 可迭代的对象与迭代器的对比

   首先，我们要明确可迭代的对象和迭代器之间的关系：python从可迭代的对象中获取迭代器。
   比如，用for循环迭代一个字符串'ABC'，字符串是可迭代的对象。for循环的背后会先调用iter(s)将字符串转换成迭代器，只不过我们看不到

s = 'ABC'

for char in s:
    print(char)

A
B
C

如果没有for循环，就不得不使用while循环来模拟

it = iter(s)  # 使用可迭代的对象s构建迭代器it

while True:
    try:
        print(next(it))  # 不断在迭代器上调用next函数，获取下一个字符
    except StopIteration:  # 如果没有字符了，迭代器会抛出StopIteration异常
        del it
        break

A
B
C

StopIteration异常表明迭代器到头了，python语言内部会处理for循环和其它迭代上下文（如列表推导、元组拆包等）中的StopIteration异常

class Sentence:
    def __init__(self, text):
        self.text = text
        self.words = RE_WORD.findall(text)

    def __repr__(self):
        return 'Sentence(%s)' % reprlib.repr(self.text)

    def __iter__(self):
        return SentenceIterator(self.words)  # 迭代协议要求__iter__返回一个迭代器
    
class SentenceIterator:
    def __init__(self, words):
        self.words = words
        self.index = 0

    def __next__(self):
        try:
            word = self.words[self.index]  # 获取 self.index 索引位（从0开始）上的单词。
        except IndexError:
            raise StopIteration()  # 如果 self.index 索引位上没有单词，那么抛出 StopIteration 异常
        self.index += 1
        return word

    def __iter__(self):
        return self  # 返回迭代器本身
    
# from test import Sentence

s = Sentence('Pig and Pepper')
it = iter(s)  # 获取迭代器
print(it)

print(next(it))  # 使用next()方法获取下一个单词
print(it.__next__())  # __next__()方法也能达到效果，但我们应该避免直接调用特殊方法
print(next(it))
try:
    print(next(it))  # 没有单词了，因此迭代器抛出StopIteration异常
except:
    print("所有单词都迭代完了")

print(list(it))  # 到头后，迭代器就没用了
print(list(iter(s)))  # 如果想再次迭代，要重新构建迭代器

<__main__.SentenceIterator object at 0x0000000004E3A8D0>
Pig
and
Pepper
所有单词都迭代完了
[]
['Pig', 'and', 'Pepper']

总结：

• 迭代器要实现__next__()方法，返回迭代器中的下一个元素
• 迭代器还要实现__iter__()方法，返回迭代器本身，因此，迭代器可以迭代。迭代器都是可迭代的对象
• 可迭代的对象一定不能是自身的迭代器。也就是说，可迭代的对象必须实现__iter__()方法，但不能实现__next__()方法

3 生成器

   在python中，可以使用生成器让我们在迭代的过程中不断计算后续的值，而不必将它们全部存储在内存中：

'''斐波那契数列由0和1开始，之后的斐波那契系数就是由之前的两数相加而得出，它是一个无穷数列'''
def fib():  # 生成器函数
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

g = fib()  # 调用生成器函数，返回一个实现了迭代器接口的生成器对象，生成器一定是迭代器
counter = 1
for i in g:  # 可以迭代生成器
    print(i)  # 每需要一个值时，才会去计算生成
    counter += 1
    if counter > 10:  # 只生成斐波那契数列前10个数值
        break

0
1
1
2
3
5
8
13
21
34

3.1 生成器函数

   只要 Python 函数的定义体中有 yield 关键字，该函数就是生成器函数。调用生成器函数时，会返回一个生成器（generator）对象。也就是说，生成器函数是生成器工厂
普通的函数与生成器函数在语法上唯一的区别是，在后者的定义体中有 yield 关键字

def gen_AB():  # 定义生成器函数的方式与普通的函数无异，只不过要使用 yield 关键字
    print('start')
    yield 'A'
    print('continue')
    yield 'B'
    print('end')

print(gen_AB)  # 生成器函数


g = gen_AB()  # 调用生成器函数，返回一个生成器对象，注意：此时并不会执行生成器函数定义体中的代码，所以看不到打印start
print(g)


print(next(g))  # 生成器都是迭代器，执行next(g)时生成器函数会向前，前进到函数定义体中的下一个 yield 语句，生成 yield 关键字后面的表达式的值，在函数定义体的当前位置暂停，并返回生成的值
print(next(g))
print(next(g))

start
A
continue
B
end

---

StopIteration Traceback (most recent call last)
in
15 print(next(g)) # 生成器都是迭代器，执行next(g)时生成器函数会向前，前进到函数定义体中的下一个 yield 语句，生成 yield 关键字后面的表达式的值，在函数定义体的当前位置暂停，并返回生成的值
16 print(next(g))
---> 17 print(next(g))

StopIteration:

• 调用生成器函数后会创建一个新的生成器对象，但是此时还不会执行函数体。
• 第一次执行next(g)时，会激活生成器，生成器函数会向前 前进到 函数定义体中的 下一个 yield 语句，生成 yield关键字后面的表达式的值，在函数定义体的当前位置暂停，并返回生成的值。具体为：
  • 执行print('start')输出start
  • 执行yield 'A'，此处yield关键字后面的表达式为'A'，即表达式的值为A。所以整条语句会生成值A，在函数定义体的当前位置暂停，并返回值A，我们在控制台上看到输出A
• 第二次执行next(g)时，生成器函数定义体中的代码由 yield 'A' 前进到 yield 'B'，所以会先输出continue，并生成值B，又在函数定义体的当前位置暂停，返回值B
• 第三次执行next(g)时，由于函数体中没有另一个 yield 语句，所以前进到生成器函数的末尾，会先输出end。到达生成器函数定义体的末尾时，生成器对象抛出StopIteration异常

• 注意用词： 普通函数返回值，调用生成器函数返回生成器，生成器产出或生成值
• 调用生成器函数后，会构建一个实现了迭代器接口的生成器对象，即，生成器一定是迭代器！

def gen_AB():  # 定义生成器函数的方式与普通的函数无异，只不过要使用 yield 关键字
    print('start')
    yield 'A'
    print('continue')
    yield 'B'
    print('end')

for c in gen_AB():
    print('-->', c)

start
--> A
continue
--> B
end

所以，可以使用生成器函数改写前面章节中的Sentence类，此时不再需要SentenceIterator类：

import re
import reprlib

RE_WORD = re.compile('\w+')

class Sentence:
    def __init__(self, text):
        self.text = text
        self.words = RE_WORD.findall(text)

    def __repr__(self):
        return 'Sentence(%s)' % reprlib.repr(self.text)

    def __iter__(self):
        # 最简单是委托迭代给列表，这里仅演示生成器函数的用法
        # return iter(self.words)  # 等价于self.words.__iter__()
        for word in self.words:
            yield word  # 产出当前的word

   迭代器和生成器都是为了惰性求值（lazy evaluation），避免浪费内存空间。而上面的Sentence类却不具备惰性，因为RE_WORD.findall(text)会创建所有匹配项的列表，然后将其绑定到 self.words 属性上。如果我们传入一个非常大的文本，那么该列表使用的内存量可能与文本本身一样多，而假设我们只需要迭代前几个单词，那么将浪费大量的内存。
   re.finditer 函数是 re.findall 函数的惰性版本，返回的不是列表，而是一个迭代器，按需生成 re.MatchObject实例。如果有很多匹配， re.finditer 函数能节省大量内存。我们要使用这个函数让 Sentence 类变得懒惰，即只在需要时才生成下一个单词：

import re
import reprlib

RE_WORD = re.compile('\w+')

class Sentence:
    def __init__(self, text):
        self.text = text

    def __repr__(self):
        return 'Sentence(%s)' % reprlib.repr(self.text)

    def __iter__(self):
        # finditer()函数构建一个迭代器，包含 self.text 中匹配 RE_WORD 的单词，产出 MatchObject 实例
        for match in RE_WORD.finditer(self.text):
            yield match.group()  # match.group() 方法从 MatchObject 实例中提取匹配正则表达式的具体文本

3.2 生成器表达式

   简单的生成器函数（有yield关键字），可以替换成生成器表达式（没有yield关键字，将列表推导中的[]替换为()即可），让代码变得更简短
   生成器表达式可以理解为列表推导的惰性版本：不会迫切地构建列表，而是返回一个生成器，按需惰性生成元素。也就是说，如果列表推导是制造列表的工厂，那么生成器表达式就是制造生成器的工厂：

def gen_AB():
    print('start')
    yield 'A'
    print('continue')
    yield 'B'
    print('end')

res1 = [x*3 for x in gen_AB()]  # 列表推导迫切地迭代 gen_AB() 函数生成的生成器对象产出的元素： 'A' 和 'B'。注意，下面的输出是 start、 continue 和 end
print(res1)

for i in res1:  # 这个 for 循环迭代列表推导生成的 res1 列表
    print('-->', i)

    
res2 = (x*3 for x in gen_AB())  # 把生成器表达式返回的值赋值给 res2。只需调用 gen_AB() 函数，虽然调用时会返回一个生成器，但是这里并不使用
print(res2)  # res2 是一个生成器对象

for i in res2:  # 只有 for 循环迭代 res2 时， gen_AB 函数的定义体才会真正执行。 for 循环每次迭代时会隐式调用 next(res2)，前进到 gen_AB 函数中的下一个 yield 语句。注意， gen_AB 函数的输出与 for 循环中 print 函数的输出夹杂在一起
    print('-->', i)

start
continue
end
['AAA', 'BBB']
--> AAA
--> BBB
at 0x0000000004DE1570>
start
--> AAA
continue
--> BBB
end

可以看出，生成器表达式会产出生成器，因此可以使用生成器表达式进一步减少Sentence类的代码：

import re
import reprlib

RE_WORD = re.compile('\w+')

class Sentence:
    def __init__(self, text):
        self.text = text

    def __repr__(self):
        return 'Sentence(%s)' % reprlib.repr(self.text)

    def __iter__(self):  # 不再是生成器函数了（没有 yield），而是使用生成器表达式构建生成器
        return (match.group() for match in RE_WORD.finditer(self.text))

• 何时使用生成器表达式？
  • 生成器表达式是创建生成器的简洁语法，这样无需先定义函数再调用。不过，生成器函数灵活得多，可以使用多个语句实现复杂的逻辑，也可以作为协程使用（后续博文介绍）
  • 遇到简单的情况时，可以使用生成器表达式，因为这样扫一眼就知道代码的作用。如果生成器表达式要分成多行写，我倾向于定义生成器函数，以便提高可读性。此外，生成器函数有名称，因此可以重用

如果将生成器表达式传入只有一个参数的函数时，可以省略生成器表达式外面的()：

print(list((x*2 for x in range(5))))

print(list(x*2 for x in range(5)))  # 可以省略生成器表达式外面的()

[0, 2, 4, 6, 8]
[0, 2, 4, 6, 8]

3.3 嵌套生成器

可以将多个生成器像管道(pipeline)一样链接起来使用，更高效的处理数据：

def integers():  # 1. 产出整数的生成器
    for i in range(1, 9):
        yield i
         

chain1 = integers()

print(list(chain1))


def squared(seq):  # 2. 基于整数的生成器，产出平方数的生成器
    for i in seq:
        yield i * i         

chain2 = squared(integers())

print(list(chain2))

def negated(seq):  # 3. 基于平方数的生成器，产出负的平方数的生成器
    for i in seq:
        yield -i         

chain3 = negated(squared(integers()))  # 链式生成器，更高效

print(list(chain3))

[1, 2, 3, 4, 5, 6, 7, 8]
[1, 4, 9, 16, 25, 36, 49, 64]
[-1, -4, -9, -16, -25, -36, -49, -64]

由于上面各生成器函数的功能都非常简单，所以可以使用生成器表达式进一步优化链式生成器：

integers = range(1, 9)
squared = (i * i for i in integers)
negated = (-i for i in squared)

print(negated)

print(list(negated))

at 0x0000000004DE1660>
[-1, -4, -9, -16, -25, -36, -49, -64]

3.4 增强生成器

   python 2.5 通过了 PEP 342 -- Coroutines via Enhanced Generators ，这个提案为生成器对象添加了额外的方法和功能，其中最值得关注的是.send()方法
   与.__next__()方法一样，.send()方法使生成器前进到下一个yield语句。不过，.send()方法还允许调用方把数据发送给生成器，即不管传给.send()方法什么参数，那个参数都会成为生成器函数定义体中对应的yield表达式的值。也就是说，.send()方法允许在调用方和生成器之间双向交换数据，而.__next__()方法只允许调用方从生成器中获取数据

• 查看生成器对象的状态:可以使用 inspect.getgeneratorstate(...) 函数查看生成器对象的当前状态：
• GEN_CREATED： 等待开始执行
• GEN_RUNNING： 正在被解释器执行。只有在多线程应用中才能看到这个状态
• GEN_SUSPENDED： 在yield表达式处暂停
• GEN_CLOSED： 执行结束

def echo(value=None):
    print("Execution starts when 'next()' is called for the first time.")
    try:
        while True:
            try:
                value = (yield value)  # 调用send(x)方法后，等号左边的value将被赋值为x
            except Exception as e:
                value = e
    finally:
        print("Don't forget to clean up when 'close()' is called.")
        
g=echo(1)  # 返回生成器对象，此时value=1

import inspect

print(inspect.getgeneratorstate(g))

print(next(g))  # 第一次要调用next()方法，让生成器前进到第一个yield处，后续才能在调用send()方法时，在该yield表达式位置接收客户发送的数据

print(inspect.getgeneratorstate(g))

print(next(g))  # 第二次调用next()方法，相当于调用send(None)，所以value = (yield value)中等号左边的value将被赋值为None。下一次While循环，又前进到(yield value)处，产出value的值，因为此时value=None，所以打印None

print(inspect.getgeneratorstate(g))

print(g.send(2))  # 直接调用send(2)方法，所以value = (yield value)中等号左边的value将被赋值为2。下一次While循环，又前进到(yield value)处，产出value的值，因为此时value=2，所以打印2

print(g.throw(TypeError, "spam"))  # 调用throw()方法，将异常对象发送给生成器，所以except语句会捕获异常，即value=TypeError('spam')。下一次While循环，又前进到(yield value)处，产出value的值，因为此时value=TypeError('spam')，所以打印TypeError('spam')

g.close()  # 调用close()方法，关闭生成器

print(inspect.getgeneratorstate(g))

GEN_CREATED
Execution starts when 'next()' is called for the first time.
1
GEN_SUSPENDED
None
GEN_SUSPENDED
2
spam
Don't forget to clean up when 'close()' is called.
GEN_CLOSED

这是一项重要的 "改进"，甚至改变了生成器的本性：像这样使用的话，生成器就变身为基于生成器的协程。

注意： 给已结束的生成器发送任何值，都将抛出StopIteration异常，且返回值（保存在异常对象的value属性上）是None

3.5 yield from

• yield from 是在python3.3才出现的语法。所以这个特性在Python2中是没有的。
• yield from 后面需要加的是可迭代对象，它可以是普通的可迭代对象，也可以是迭代器，甚至是生成器。

3.5.1 简单应用：拼接可迭代对象

使用yield和使用yield from对比：

• 使用yield

# 字符串
astr='ABC'
# 列表
alist=[1,2,3]
# 字典
adict={"name":"wangbm","age":18}
# 生成器
agen=(i for i in range(4,8))

def gen(*args):
    for item in args:
        for i in item:
            yield i

new_list=gen(astr, alist, adict,agen)
print(list(new_list))

['A', 'B', 'C', 1, 2, 3, 'name', 'age', 4, 5, 6, 7]

• 使用yield from

# 字符串
astr='ABC'
# 列表
alist=[1,2,3]
# 字典
adict={"name":"wangbm","age":18}
# 生成器
agen=(i for i in range(4,8))

def gen(*args):
    for item in args:
        yield from item

new_list=gen(astr, alist, adict, agen)
print(list(new_list))

['A', 'B', 'C', 1, 2, 3, 'name', 'age', 4, 5, 6, 7]

由上面两种方式对比，可以看出，yield from后面加上可迭代对象，他可以把可迭代对象里的每个元素一个一个的yield出来，对比yield来说代码更加简洁，结构更加清晰。

3.5.2 复杂应用：生成器的嵌套

   当 yield from 后面加上一个生成器后，就实现了生成的嵌套。
   当然实现生成器的嵌套，并不是一定必须要使用yield from，而是使用yield from可以让我们避免自己处理各种料想不到的异常，而让我们专注于业务代码的实现。

讲解之前，首先要知道几个概念：

1. 调用方：调用委派生成器的客户端（调用方）代码
2. 委托生成器：包含yield from表达式的生成器函数
3. 子生成器：yield from后面加的生成器函数

你可能不知道他们都是什么意思，没关系，来看下这个例子。

#这个例子，是实现实时计算平均值的。 比如，第一次传入10，那返回平均数自然是10. 第二次传入20，那返回平均数是(10+20)/2=15 第三次传入30，那返回平均数(10+20+30)/3=20
# 子生成器
def average_gen():
    total = 0
    count = 0
    average = 0
    while True:
        new_num = yield average
        count += 1
        total += new_num
        average = total/count

# 委托生成器
def proxy_gen():
    while True:
        yield from average_gen()

# 调用方
def main():
    calc_average = proxy_gen()
    next(calc_average)            # 预激下生成器
    print(calc_average.send(10))  # 打印：10.0
    print(calc_average.send(20))  # 打印：15.0
    print(calc_average.send(30))  # 打印：20.0

if __name__ == '__main__':
    main()

0
10.0
15.0
20.0

• 委托生成器的作用是：在调用方与子生成器之间建立一个双向通道。
  所谓的双向通道是什么意思呢？ 调用方可以通过send()直接发送消息给子生成器，而子生成器yield的值，也是直接返回给调用方。

• 你可能会经常看到有些代码，还可以在yield from前面看到可以赋值。这是什么用法？
  你可能会以为，子生成器yield回来的值，被委托生成器给拦截了。你可以亲自写个demo运行试验一下，并不是你想的那样。 因为我们之前说了，委托生成器，只起一个桥梁作用，它建立的是一个双向通道，它并没有权利也没有办法，对子生成器yield回来的内容做拦截。
  为了解释这个用法，还是用上述的例子，并对其进行了一些改造。

# 子生成器
def average_gen():
    total = 0
    count = 0
    average = 0
    while True:
        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():
    calc_average = proxy_gen()
    print(next(calc_average))            # 预激协程
    print(calc_average.send(10))  # 打印：10.0
    print(calc_average.send(20))  # 打印：15.0
    print(calc_average.send(30))  # 打印：20.0
    calc_average.send(None)      # 结束协程
    # 如果此处再调用calc_average.send(10)，由于上一协程已经结束，将重开一协程

if __name__ == '__main__':
    main()

0
10.0
15.0
20.0
计算完毕！！
总共传入 3 个数值， 总和：60，平均数：20.0

• 为什么要使用yield from
  既然委托生成器，起到的只是一个双向通道的作用，还需要委托生成器做什么？调用方直接调用子生成器不就好啦？

下面我们来一起探讨一下，到底yield from 有什么过人之处，让我们非要用它不可。

• 因为它可以帮我们处理异常
  如果我们去掉委托生成器，而直接调用子生成器。那我们就需要把代码改成像下面这样，我们需要自己捕获异常并处理。而不像使yield from那样省心。

# 子生成器
def average_gen():
    total = 0
    count = 0
    average = 0
    while True:
        new_num = yield average
        if new_num is None:
            break
        count += 1
        total += new_num
        average = total/count
    return total,count,average

# 调用方
def main():
    calc_average = average_gen()
    print(next(calc_average))            # 预激协程
    print(calc_average.send(10))  # 打印：10.0
    print(calc_average.send(20))  # 打印：15.0
    print(calc_average.send(30))  # 打印：20.0

    # ----------------注意-----------------
    try:
        calc_average.send(None)
    except StopIteration as e:
        total, count, average = e.value
        print("计算完毕！！\n总共传入 {} 个数值， 总和：{}，平均数：{}".format(count, total, average))
    # ----------------注意-----------------

if __name__ == '__main__':
    main()

0
10.0
15.0
20.0

计算完毕！！
总共传入 3 个数值， 总和：60，平均数：20.0