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

你可能感兴趣的