面向对象编程之生成器与迭代器

生成器

列表推导式

[i * i for i in range(8)]

>
[0, 1, 4, 9, 16, 25, 36, 49]

生成器表达式

(i * i for i in range(8))

>
<generator object <genexpr> at 0x0000025C8F9019A8>

查看生成器对应的所有元素，有两种方式：

1.多次调用内置函数next(),每次调用都返回生成器的下一个元素，直到抛出异常StopIteration时表示没有更多元素了。
2.使用for-in语句对生成器进行迭代，这样就不需要关心异常StopIteration了。

生成器中保存的并不是其对应的所有元素，而是如何推算出所有元素的算法。将生成器用于for-in语句时，元素是在循环的过程中不断被推送出来的。将生成器作为内置函数next()的实参时，返回的下一个元素也是在调用函数时被推送出来的。因此，生成器是惰性推算的，也就是说，只有当用到生成器中的某个元素时，才会临时进行推算，而并不会提前推算出来。

如果需要创建一个元素个数较大的容器，就可以考虑使用生成器，从而节约大量的存储空间。

生成器函数 yield

生成器函数中通过关键字yield返回推算出的元素。生成器函数与普通函数的区别在于：当调用 内置函数next()或使用for-in语句进行迭代时，执行完yield语句就会将生成器函数挂起，下次会从挂起的地方继续执行。

def fib(n):
    i = 0
    a,b = 1,1
    while i < n:
        print(a,end = ',')
        a,b = b,a+b
        i+=1
fib(6)

>
1,1,2,3,5,8,

def fib(n):
    i = 0
    a,b = 1,1
    while i < n:
        yield a
        a,b = b,a+b
        i+=1
fib(6)

>
<generator object fib at 0x0000021D6F86FB10>

gf = fib(6)
print(next(gf))
print(next(gf))
print(next(gf))
print(next(gf))
print(next(gf))
print(next(gf))
print(next(gf))

>
1
1
2
3
5
8
---------------------------------------------------------------------------
StopIteration                             Traceback (most recent call last)
<ipython-input-7-2e6b10837911> in <module>()
      6 print(next(gf))
      7 print(next(gf))
----> 8 print(next(gf))

StopIteration: 

gf = fib(6)
for item in gf:
    print(item)

>
1
1
2
3
5
8

遇到return生成器终止

只要有yield就是生成器

def test():
    n = 0
    while n < 10:
        yield n
        n+=2
        return '返回值作为异常的提示语'
a = test()
print(a)

>
<generator object test at 0x000001A825EE9390>

next(a)
>
0

next(a)
>
---------------------------------------------------------------------------
StopIteration                             Traceback (most recent call last)
<ipython-input-11-3f6e2eea332d> in <module>()
----> 1 next(a)

StopIteration: 返回值作为异常的提示语

迭代器

可以用于for-in语句的对象被称为可迭代（iterable）对象

例如：range,列表，元组，字符串，字典，集合，生成器都是可迭代对象

可以调用内置函数isinstance()判断一个对象是否是可迭代对象。标准库模块collections中的类Iterable用于表示可迭代对象

from collections import Iterable
print(isinstance([1,2,3],Iterable))
>
True

print(isinstance('abc',Iterable))
>
True

print(isinstance((i * i for i in range(1,7)),Iterable))
>
True

如果一个可迭代对象可以作为内置函数next()的实参从而支持惰性推算，那么该对象被称为迭代器（Iterator）对象。

对于range，列表，元组，字符串，字典和合集等可迭代对象，都不可以作为内置函数next（）的实参，而生成器可以。所以，生成器是迭代器的一种。

可以调用内置函数isinstance()判断一个对象是否是迭代器对象。标准库模块collections中的类Iterator用于表示迭代器对象。

L = [1,2,3]
next(L)
>
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-16-613237b05554> in <module>()
      1 L = [1,2,3]
----> 2 next(L)

TypeError: 'list' object is not an iterator

s = 'abc'
next(s)
>
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-17-000efaea8dad> in <module>()
      1 s = 'abc'
----> 2 next(s)

TypeError: 'str' object is not an iterator

from collections import Iterator
print(isinstance(L, Iterator))
print(isinstance(s, Iterator))
>
False
False

print(isinstance((i * i for i in range(1,7)),Iterator))
>
True

可以调用内置函数iter()把不支持惰性推算的可迭代对象转换为迭代器对象。

iter_L = iter(L)
iter_s = iter(s)
print(isinstance(iter_L, Iterator))
print(isinstance(iter_s, Iterator))
>
True
True

print(next(iter_L))
print(next(iter_L))
print(next(iter_L))
print(next(iter_L))
>
1
2
3
---------------------------------------------------------------------------
StopIteration                             Traceback (most recent call last)
<ipython-input-18-6087a98b9770> in <module>()
      2 print(next(iter_L))
      3 print(next(iter_L))
----> 4 print(next(iter_L))

StopIteration: 

print(next(iter_s))
print(next(iter_s))
print(next(iter_s))
print(next(iter_s))
>
a
b
c
---------------------------------------------------------------------------
StopIteration                             Traceback (most recent call last)
<ipython-input-19-4df9ec750908> in <module>()
      2 print(next(iter_s))
      3 print(next(iter_s))
----> 4 print(next(iter_s))

StopIteration: 

如果一个对象同时实现了特殊方法__iter__()和__next__(),那么该对象也被称为迭代器对象。如果将该对象用于for-in语句，for-in语句首先会调用特殊方法__iter__()返回一个可迭代对象，然后不断调用该可迭代对象的特殊方法__next__()返回下一次迭代的值，直到遇到StopIteration时退出循环。

class MyIterator(object):
    def __init__(self):
        self.data = 0
    def __iter__(self):
        return self
    def __next__(self):
        if self.data > 5:
            raise StopIteration()
        else:
            self.data += 1
            return self.data
for item in MyIterator():
    print(item)
>
1
2
3
4
5
6

class Fib(object):
    def __init__(self):
        self.a,self.b = 0,1
    def __iter__(self):
        return self
    def __next__(self):
        self.a,self.b = self.b,self.a + self.b
        if self.a > 50:
            raise StopIteration()
        return self.a
for item in Fib():
    print(item)
 >
1
1
2
3
5
8
13
21
34