python生成器有几种写法,python生成器函数例子

大家好，小编来为大家解答以下问题，python生成器有几种写法，python生成器函数例子，今天让我们一起来看看吧！

本文部分参考：Python迭代器，生成器–精华中的精华 https://www.cnblogs.com/deeper/p/7565571.html

一 迭代器和可迭代对象

迭代器是访问集合元素的一种方式。火车头采集器AI伪原创。迭代器只能往前不会后退。迭代器的一大优点是不要求事先准备好整个迭代过程中所有的元素，仅仅在迭代到某个元素时才计算该元素，而在这之前或之后，元素可以不存在或者被销毁。这个特点使得它特别适合用于遍历一些巨大的或是无限的集合，比如几个G的文件。

特点：

a）访问者不需要关心迭代器内部的结构，仅需通过next()方法或不断去取下一个内容

b）不能随机访问集合中的某个值 ，只能从头到尾依次访问

c）访问到一半时不能往回退

d）便于循环比较大的数据集合，节省内存

e）也不能复制一个迭代器。如果要再次（或者同时）迭代同一个对象，只能去创建另一个迭代器对象。

enumerate()的返回值就是一个迭代器，我们以enumerate为例：

a = enumerate(['a','b'])

for i in range(2):    #迭代两次enumerate对象
    for x, y in a:
        print(x,y)
    print(''.center(50,'-'))

结果：

0 a
1 b
-----------------------分割线------------------------
-----------------------分割线------------------------

可以看到再次迭代enumerate对象时，没有返回值。

我们可以用linux的文件处理命令vim和cat来理解一下：

a) 读取很大的文件时，vim需要很久，cat是毫秒级；因为vim是一次性把文件全部加载到内存中读取；而cat是加载一行显示一行

b) vim读写文件时可以前进，后退，可以跳转到任意一行；而cat只能向下翻页，不能倒退，不能直接跳转到文件的某一页（因为读取的时候这个“某一页“可能还没有加载到内存中）。

正式进入python迭代器之前，我们先要区分两个容易混淆的概念：可迭代对象(Iterable)和迭代器(Iterator)。

1.1可迭代对象

定义：迭代器是一个对象，不是一个函数。只要它定义了可以返回一个迭代器的__iter__方法，或者定义了可以支持下标索引的__getitem__方法，那么它就是一个可迭代对象。

注意： 集合数据类型，如list、tuple、dict、set、str都是可迭代对象Iterable，却不是迭代器Iterator。

如何判断一个对象是可迭代对象呢？可以通过collections模块的Iterable类型判断：

from collections import Iterable
print(isinstance([], Iterable))
print(isinstance({}, Iterable))
print(isinstance('abc', Iterable))
print(isinstance({'name':'join','age':23},Iterable))
print(isinstance(set([2,3]),Iterable))

结果为：

True
True
True
True
True

再看：

from collections import Iterator
print(isinstance([], Iterator))
print(isinstance({}, Iterator))
print(isinstance('abc', Iterator))
print(isinstance({'name':'join','age':23},Iterator))
print(isinstance(set([2,3]),Iterator))

结果为：

False
False
False
False
False

1.2迭代器

定义：任何实现了__iter__()和__next__()（python2中实现next()）方法的对象都是迭代器，__iter__返回迭代器自身，__next__返回容器中的下一个值。

这里我们来看一下迭代器和可迭代对象的使用方法。

问题：不适用for,while以及下表索引，怎么遍历一个list？

l1=[2,3,5]
iter_l1 = l1.__iter__() 
# 或者iter(iter_l1)
# iter(iter_l1)是python的内置函数，
# l1.__iter__()调用的是l1对象的__iter__()方法。
# 下面的next()函数和__iter__()函数类似。
print(next(iter_l1)) # 或print(iter_l1.__next__()
print(next(iter_l1))
print(next(iter_l1))
print(next(iter_l1))

结果为：

2
3
5
---------------------------------------------------------------------------
StopIteration                             Traceback (most recent call last)
 in 
      4 print(next(iter_l1))
      5 print(next(iter_l1))
----> 6 print(next(iter_l1))

结论：思路就是，先得到当前对象（当前对象是可迭代对象）的迭代器，然后每次执行next(iter_l1)就可以得到当前对象的一个值。

修改一下：

l1=[2,3,5]
iter_l1 = l1.__iter__() 
for i in iter_l1:
    print(i,end=',')

结果为：

2,3,5,

再次执行for语句如下：

for i in iter_l1:
    print(i,end=',')

此次返回结果为空，可以看到迭代器只能遍历一次对象，不能重复遍历。由于for语句可以自动处理StopIteration异常，所以这里没有报出StopIteration，而是没有任何结果。

看一个例子。我们想得到Fibonacci数列，思路是定义一个可迭代对象类Fib；然后在定义一个迭代器类FibIterator，使用方式是：
① 实例化一个可迭代对象： fib = Fib()
② 得到fib的一个迭代器： fib_iter = iter(fib)
③ 然后每次调用next(fib_iter)可得到fibonacci数列中的一个数。

class FibIterator():
    '''
    定义迭代器类
    '''
    def __init__(self,num,a,b,current):
        self.num = num
        self.a = a
        self.b = b
        self.current = current
    def __iter__(self):
        return self
    def __next__(self):
        if(self.num-1>=0):
            self.num = self.num-1
            self.current = self.a
            self.a = self.b
            self.b = self.b+self.current   #以上两步赋值操作可省略中间变量直接写为self.a,self.b = self.b,self.a+self,b 
            return self.current
        else: raise StopIteration
         
class Fib:
    '''
    定义可迭代对象所属类
    '''
    def __init__(self,num): #num表示该数列的长度
        self.a = 1
        self.b = 2
        self.current=self.a
        self.num = num
    def __iter__(self):
        return FibIterator(self.num,self.a,self.b,self.current)
        
fib = Fib(20)
fib_iter = iter(fib)
for i in range(20):
    print(next(fib_iter),end=',')

结果为：

1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597,2584,4181,6765,10946,

这里定义的Fibonacci类的__init__函数有一个参数num，表示一共得到几个fibonacci数。

由于可迭代对象是实现了__iter__()方法的，迭代器对象是实现了__iter__()和__next__()方法的，能否只定义一个迭代器类呢？

试一下。

class Fib:
    def __init__(self,num):
        self.num = num
        self.a = 1
        self.b = 2
        self.current = self.a
    def __iter__(self):
        return self
    def __next__(self):
        if(self.num-1>=0):
            self.num = self.num-1
            self.current = self.a
            self.a = self.b
            self.b = self.b+self.current   #以上两步赋值操作可省略中间变量直接写为self.a,self.b = self.b,self.a+self,b 
            return self.current
        else: raise StopIteration
        
fib = Fib(10)
for i in fib:
    print(i,end=',')

结果为：

1,2,3,5,8,13,21,34,55,89,

当我们再次执行for语句时，

for i in fib:
    print(i,end=',')

同上面的分析一样，结果为空。如果想再次得到fibonacci数列的前10个数，就必须重新实例化Fib对象。

结论：为什么不只保留Iterator的接口而还需要设计Iterable呢？

因为迭代器迭代一次以后就空了，那么如果list，dict也是一个迭代器，迭代一次就不能再继续被迭代了，这显然是反人类的；所以通过__iter__每次返回一个独立的迭代器，就可以保证不同的迭代过程不会互相影响。

另外，迭代器是惰性的，只有在需要返回下一个数据时它才会计算。所以，Iterator甚至可以表示一个无限大的数据流，例如全体自然数。而使用list是永远不可能存储全体自然数的。

下面的例子得到全体自然数（下面我们用生成器可以得到更简单的写法）。

class Natural:
    def __init__(self):
        pass
    def __iter__(self):
        return NaturalIterator()
class NaturalIterator:
    def __init__(self):
        self.beg=0
        self.current=self.beg
    def __iter__(self):
        return self
    def __next__(self):
        self.current += 1
        return self.current   

# 显示前20个自然数
n1=Natural()
n1_iter = iter(n1)
for i in range(20):
    print(next(n1_iter),end=',')

结果为：

1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,

作业：使用迭代器和可迭代对象实现得到全体fibonacci数。

二 生成器

2.1 生成器的定义和使用

定义：生成器其实是一种特殊的迭代器，它不需要再像上面的类一样写__iter__()和__next__()方法了，只需要一个yiled关键字。

生成器一定是迭代器（反之不成立）。

Python有两种不同的方式提供生成器：

1. 生成器函数：常规函数定义，但是，使用yield语句而不是return语句返回结果。 yield语句一次返回一个结果，在每个结果中间，挂起函数的状态，以便下次重它离开的地方继续执行
2. 生成器表达式：类似于列表推导，但是，生成器返回按需产生结果的一个对象， 而不是一次构建一个结果列表

我们先用一个例子说明一下：

def generate_even():
    i=0
    while True:
        if i%2==0:
            yield i
        i += 1

g=generate_even()
dir(g) # 可以看到里面有__iter__()方法和__next__()方法，所以生成器也是迭代器。

for i in range(10):
    print(g.__next__(),end=',')

结果为：

0,2,4,6,8,10,12,14,16,18,

现在解释一下上面的代码：

我们知道，一个函数只能返回一次，即return以后，这次函数调用就结束了；

但是生成器函数可以暂停执行，并且通过yield返回一个中间值，当生成器对象的__next__()方法再次被调用的时候，生成器函数可以从上一次暂停的地方继续执行，直到下一次遇到yield语句（此时会返回yield后面的值，如果有的话）或者触发一个StopIteration。

了解协同程序：
a) 生成器的另外一个方面是协同程序的概念。协同程序是可以运行的独立函数调用，可以暂停或者挂起，并从程序离开的地方继续或者重新开始。

b) 可以在调用者和被调用的之间协同程序通信。

c) 在程序暂停时可以传参：举例来说，当协同程序暂停时，我们仍可以从其中获得一个中间的返回值，当调用回到程序中时，能够传入额外或者改变了的参数，但是仍然能够从我们上次离开的地方继续，并且所有状态完整。

生成器表达式类似于列表推导式，只是把[]换成()，这样就创建了一个生成器。

gen = (x for x in range(10))

下面我们用生成器来实现前面的fibonacci数列和全体自然数。

# 生成前n个fibonacci数
def fib(n):
    a, b = 0, 1
    count=0
    while True:
        if(count>n):
            break
        count += 1
        yield b
        a, b = b, a+b

f = fib(20)
for item in f:
    print(item,end=',')

结果为：

1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597,2584,4181,6765,10946,

def Natural():
    n=0
    while True:
        yield n
        n += 1
g_n1=Natural()
for i in range(20):
    print(next(g_n1),end=',')

结果为：

0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,

2.2 send方法

生成器函数最大的特点是可以接受外部传入的一个变量，并根据变量内容计算结果后返回。这是生成器函数最难理解的地方，也是最重要的地方，协程的实现就全靠它了。

看一个小猫吃鱼的例子：

def cat():
    print('我是一只hello kitty')
    while True:
        food = yield
        if food == '鱼肉':
            yield '好开心'
        else:
            yield '不开心，人家要吃鱼肉啦'

中间有个赋值语句food = yield，可以通过send方法来传参数给food，试一下：

情况1）

miao = cat()    #只是用于返回一个生成器对象，cat函数不会执行
print(''.center(50,'-'))
print(miao.send('鱼肉'))

结果：

Traceback (most recent call last):
--------------------------------------------------
  File "C:/Users//Desktop/Python/cnblogs/subModule.py", line 67, in 
    print(miao.send('鱼肉'))
TypeError: can't send non-None value to a just-started generator

看到了两个信息：

a）miao = cat() ，只是用于返回一个生成器对象，cat函数不会执行

b）can’t send non-None value to a just-started generator；不能给一个刚创建的生成器对象直接send值

改一下，情况2）

miao = cat()
miao.__next__()
print(miao.send('鱼肉'))

那么到底send()做了什么呢？send()的帮助文档写的很清楚，’’‘Resumes the generator and “sends” a value that becomes the result of the current yield-expression.’’’；可以看到send依次做了两件事：

a）回到生成器挂起的位置，继续执行

b）并将send(arg)中的参数赋值给对应的变量，如果没有变量接收值，那么就只是回到生成器挂起的位置

但是，我认为send还做了第三件事：

c）兼顾__next__()作用，挂起程序并返回值，所以我们在print(miao.send(‘鱼肉’))时，才会看到’好开心’；其实__next__()等价于send(None)

所以当我们尝试这样做的时候：

def cat():
    print('我是一只hello kitty')
    while True:
        food = yield
        if food == '鱼肉':
            yield '好开心'
        else:
            yield '不开心，人家要吃鱼肉啦'

miao = cat()
print(miao.__next__())
print(miao.send('鱼肉'))
print(miao.send('骨头'))
print(miao.send('鸡肉'))

就会得到这个结果：

我是一只hello kitty
None
好开心
None
不开心，人家要吃鱼肉啦

我们按步骤分析一下：

a）执行到print(miao.next())，执行cat()函数，print了”我是一只hello kitty”，然后在food = yield挂起，并返回了None，打印None

b）接着执行print(miao.send(‘鱼肉’))，回到food = yield，并将’鱼肉’赋值给food，生成器函数恢复执行；直到运行到yield ‘好开心’，程序挂起，返回’好开心’，并print’好开心’

c）接着执行print(miao.send(‘骨头’))，回到yield ‘好开心’，这时没有变量接收参数’骨头’，生成器函数恢复执行；直到food = yield，程序挂起，返回None，并print None

d）接着执行print(miao.send(‘鸡肉’))，回到food = yield，并将’鸡肉’赋值给food，生成器函数恢复执行；直到运行到yield’不开心，人家要吃鱼肉啦’，程序挂起，返回’不开心，人家要吃鱼肉啦’，并print ‘不开心，人家要吃鱼肉啦’

大功告成，那我们优化一下代码：

def cat():
    msg = '我是一只hello kitty'
    while True:
        food = yield msg
        if food == '鱼肉':
            msg = '好开心'
        else:
            msg = '不开心，人家要吃鱼啦'

miao = cat()
print(miao.__next__())
print(miao.send('鱼肉'))
print(miao.send('鸡肉'))

我们再看一个更实用的例子，一个计数器。

def counter(start_at = 0):
    count = start_at
    while True:
        val = yield count
        if val is not None:
            count = val
        else:
            count += 1

count = counter(5)
print(count.__next__())
print(count.send(0))

结果为5,0而不是5,6的原因：

①执行print(count.next()),程序运行到val = yield count(第一个yield语句）后挂起，然后返回yield后面的值，所以结果为5。

②执行print(count.send(0))，程序恢复到挂起点val = yield count,将send的参数0赋值给接受变量val,然后继续执行下面的语句，由于val=0，所以if val is not None条件为真，count = val,接着又来到yield语句（val = yield count）,此时程序挂起，返回yield后面的值count=0。

综上：当执行next()方法时，程序会恢复到挂起点，依次执行yield语句下面的语句，最后再返回yield后面的值；而不是先返回yield后面的值，再执行yield后面的语句。

最后给出一张图说明Iterable,Iterator,Generator的关系：

补充几个小例子：

a）使用生成器创建一个range

def range(n):
    count = 0
    while count < n:
        yield count
        count += 1