python函数式编程之生成器

在前面的学习过程中，我们知道，迭代器有两个好处：

一是不依赖索引的统一的迭代方法
二是惰性计算，节省内存

但是迭代器也有自己的显著的缺点，那就是

不如按照索引取值方便
一次性，只能向后取值，不能向前取值

所以我们还需要学习另外一种对象，那已经生成器

1.什么是生成器

如果一个函数体内部包含yield关键字，该函数就是生成器函数，执行该函数就得到一个生成器对象

2.得到生成器

先来看下面的代码

def foo():
    print("first...")
    yield
    print("second...")
    yield
    print("third...")

g=foo()
print(g)

根据上面生成器的定义：函数体内部包含yield关键字，则该函数就是生成器函数，则上面的函数执行结果就是一个生成器对象

执行上面的代码，查看程序执行结果

<generator object foo at 0x0000000001DF2BF8>

可以看出：上面的函数执行的结果g就是一个生成器对象，上面的函数foo就是一个生成器函数

3.生成器的内置方法

修改上面的代码,调用dir方法查看生成器中包含的方法

def foo():
    print("first...")
    yield
    print("second...")
    yield
    print("third...")

g=foo()
print(dir(g))

打印生成器内部的方法，可以看到打印的结果

['__class__', '__del__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__lt__', '__name__', '__ne__', '__new__', '__next__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'close', 'gi_code', 'gi_frame', 'gi_running', 'gi_yieldfrom', 'send', 'throw']

在这些结果中，可以看到有__iter__方法和__next__方法，由此可以判断出生成器的本质就是迭代器

，生成器是迭代器的一种

4.判断生成器是否是迭代器

修改上面的代码

def foo():
    print("first...")
    yield
    print("second...")
    yield
    print("third...")

g=foo()

from collections import Iterable

print(isinstance(g,Iterable))

查看打印结果

True

上面的两个例子都可以证明：生成器的本质是迭代器，生成器就是迭代器的一种

5.生成器的 __iter__方法和__next__方法

既然生成器的本质是迭代器，那么调用生成器的 __iter__方法和__next__方法，得到的结果会是什么呢

修改上面的代码

def foo():
    print("first...")
    yield
    print("second...")
    yield
    print("third...")

g=foo()

print(g)
print(g.__iter__())
g.__next__()

程序执行结果

<generator object foo at 0x0000000001DF2BF8>
<generator object foo at 0x0000000001DF2BF8>
first...

从上面的程序的执行结果可以看出：直接打印生成器g和调用生成器g.__iter__方法，得到的结果都是生成器对象g 在内存中的地址

调用g.__next__方法，实际上就是从生成器g中取出一个值，执行一次g.__next__方法，触发一次生成器的取值操作，这个过程在上面的代码中表现为foo函数的向下执行过程

从上面的程序的执行结果中可以看到，只执行了foo函数的第一个print函数，并没有执行第二个和第三个print函数。

通常对函数来说，函数开始执行以后直到return语句，函数才会停止执行

在这里执行一次g.__next__方法，foo函数中执行了一行代码，遇到yield就停止了，在这里yield好像起到了return的作用。

实际上，yield关键字的功能之一就是起到返回的作用

上面的程序执行遇到yield，本次g.__next__方法执行完毕。

在函数的执行过程中，如果函数的return语句有返回值，则函数的执行完成就得到return语句的返回值，
如果return没有定义返回值或者函数中没有定义return语句，则函数的执行结果默认为None

修改上面的代码，打印__next__方法的执行结果

def foo():
    print("first...")
    yield
    print("second...")
    yield
    print("third...")

g=foo()

print(g.__next__())

程序执行结果

first...
None

可以看到，调用__next__方法时，yield后没接任何参数时，yield默认的返回值也是None

6.yield后面接返回值

那如果在yield关键字后接一个返回值，程序执行结果会是怎么样的呢

修改上面的代码，在yield关键字后接一个返回值,看程序的执行结果

def foo():
    print("first...")
    yield 1
    print("second...")
    yield 2
    print("third...")

g=foo()
print(g.__next__())

程序执行结果

first...
1

从上面的程序的执行结果可以看出，yield会把其后面接的数返回，作为__next__方法的执行结果

7.yield与return的不同点

在函数中，不管一个函数中定义了多少个return语句，函数在执行到第一个return语句的时候就会中止，其后面的语句将不会被继续执行

而对于yield来说，每调用一次__next__方法，程序会从开始向下执行，直到遇到yield语句，程序暂停，等到第二次调用 __next__方法，程序会从上次暂停的地方继续向下执行，直到遇到下一个yield或者程序执行完成

在上面的例子里，是使用yield把函数foo变成一个生成器，执行foo函数时，并不会立即执行foo函数，而是先得到生成器g,当调用一次`g.__next__`方法时，函数foo开始向下执行，遇到yield时，程序暂停，当下一次调用`g.__next__`方法时，函数foo继续从上一次暂停的地方开始向下执行，直到遇到yield暂停

8.生成器的StopIteration

修改程序，多次调用__next__方法，查看程序的执行结果

def foo():
    print("first...")
    yield
    print("second...")
    yield
    print("third...")

g=foo()

print(g)
print(g.__iter__())
g.__next__()
print('*'*30)
g.__next__()
print('#'*30)
g.__next__()

程序执行结果

<generator object foo at 0x0000000001DF2BF8>
<generator object foo at 0x0000000001DF2BF8>
first...
******************************
second...
##############################
third...
Traceback (most recent call last):
  File "E:/py_code/test.py", line 28, in <module>
    g.__next__()
StopIteration

从上面程序的执行结果可以看出，每调用一次生成器的__next__方法，会得到一个返回值，就相当于从迭代器中取一个值。

如果程序在执行过程中，没有得到返回值，这就说明迭代器的最后一个值已经被遍历完成了，所以此时再调用__next__方法，程序就会抛出异常

9.生成器的for循环遍历

在前面的学习中已经知道，生成器本质上就是一个迭代器。既然是迭代器，那么当然可以使用for循环来遍历生成器

修改上面的例子，使用for循环来遍历生成器

def foo():
    print("first...")
    yield 1
    print("second...")
    yield 2
    print("third...")

g=foo()

for i in g:
    print(i)
    print("*"*30)

查看程序的执行结果

first...
1
******************************
second...
2
******************************
third...

在上面的例子里,每执行一次for循环，就相当于是执行一次g.__next__方法，yield会返回其后所接的数字，所以for循环前两次的执行结果都是print函数和yield后接的数字

for循环执行到第三次的时候，执行完print函数，程序会抛出StopIteration异常，但是StopIteration的异常会被for循环捕捉到，所以for循环执行第三次只执行了print语句

10.总结：

yield关键字的功能:

与return的功能类似，都可以返回值，但不一样的地方在于一个函数中可以多次调用yield来返回值
为函数封装好了`__iter__方法`和`__next__方法`，把函数的执行结果变成了迭代器
`遵循迭代器的取值方式(obj.__next__())`,触发的函数的执行，函数暂停与再继续都由yield保存

11.示例：使用yield模拟linux中的命令：tail -f | grep 'error' | grep '404'

代码如下：

import time

def tail(file_path, encoding='utf-8'):
    with open(file_path, encoding=encoding) as f:
        f.seek(0, 2)
        while True:
            line = f.readline()
            if line:
                yield line
            else:
                time.sleep(0.5)

def grep(lines, pattern):
    for line in lines:
        if pattern in line:
            yield line

g1 = tail('a.txt')
g2 = grep(g1, 'error')
g3 = grep(g2, '404')

for i in g3:
    print(i)