迭代器、生成器

迭代器

　　迭代是访问集合元素的一种方式。迭代器是一个可以记住遍历的位置的对象。迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。

1.可迭代对象

我们已经知道可以对list、tuple、str等类型的数据使用for...in...的循环语法从其中依次拿到数据进行使用，我们把这样的过程称为遍历，也叫迭代。

但是，是否所有的数据类型都可以放到for...in...的语句中，然后让for...in...每次从中取出一条数据供我们使用，即供我们迭代吗？

>>> for i in 100:
...     print(i)
...
Traceback (most recent call last):
  File "E:/python/测试.py",
 line 1, in <module> 
TypeError: 'int' object is not iterable 
# int整型不是iterable，即int整型不是可以迭代的

# 我们自定义一个容器MyList用来存放数据，可以通过add方法向其中添加数据
class MyList(object):
    def __init__(self):
        self.container = list()

    def add(self, num):
        self.container.append(num)

mylist = MyList()
mylist.add(1)
mylist.add(2)
mylist.add(3)
for num in mylist:
    print(num)

Traceback (most recent call last):
  File "E:/python/测试.py", line 13, in <module>
    for num in mylist:
TypeError: 'MyList' object is not iterable

我们自定义了一个容器类型MyList，在将一个存放了多个数据的MyList对象放到for...in...的语句中，发现for...in...并不能从中依次取出一条数据返回给我们，也就说我们随便封装了一个可以存放多条数据的类型却并不能被迭代使用。

我们把可以通过for...in...这类语句迭代读取一条数据供我们使用的对象称之为可迭代对象（Iterable）

2.如何判断一个对象是否可以迭代

可以使用 isinstance() 判断一个对象是否是 Iterable 对象：

from collections import Iterable

print(isinstance([], Iterable))  # True
print(isinstance({}, Iterable))  # True
print(isinstance('abcde', Iterable))  # True
print(isinstance(mylist, Iterable))  # False
print(isinstance(111, Iterable))  # False

3. 可迭代对象的本质

我们分析对可迭代对象进行迭代使用的过程，发现每迭代一次（即在for...in...中每循环一次）都会返回对象中的下一条数据，一直向后读取数据直到迭代了所有数据后结束。那么，在这个过程中就应该有一个“人”去记录每次访问到了第几条数据，以便每次迭代都可以返回下一条数据。我们把这个能帮助我们进行数据迭代的“人”称为迭代器(Iterator)。

可迭代对象的本质就是可以向我们提供一个这样的中间“人”即迭代器帮助我们对其进行迭代遍历使用。

可迭代对象通过__iter__方法向我们提供一个迭代器，我们在迭代一个可迭代对象的时候，实际上就是先获取该对象提供的一个迭代器，然后通过这个迭代器来依次获取对象中的每一个数据.

那么也就是说，一个具备了__iter__方法的对象，就是一个可迭代对象。

class MyList(object):
    def __init__(self):
        self.container = list()

    def add(self, num):
        self.container.append(num)

    def __iter__(self):
        pass

mylist = MyList()

from collections import Iterable

print(isinstance(mylist, Iterable))  # True

这次发现添加了__iter__方法的mylist对象已经是一个可迭代对象了

4.iter()函数与next()函数

list、tuple等都是可迭代对象，我们可以通过iter()函数获取这些可迭代对象的迭代器。然后我们可以对获取到的迭代器不断使用next()函数来获取下一条数据，直到最后抛出StopIteration错误表示无法继续返回下一个值了。iter()函数实际上就是调用了可迭代对象的__iter__方法。

new_list = [1,2,3,4,5]
new_list_iter = iter(new_list)
print(next(new_list_iter))
print(next(new_list_iter))
print(next(new_list_iter))
print(next(new_list_iter))
print(next(new_list_iter))
print(next(new_list_iter))
# 输出结果：
Traceback (most recent call last):
  File "E:/python/测试.py", line 31, in <module>
    print(next(new_list_iter))
StopIteration
1
2
3
4
5

5. 如何判断一个对象是否是迭代器

可以使用 isinstance() 判断一个对象是否是 Iterator 对象：

from collections import Iterator

print(isinstance([], Iterator))
print(isinstance({}, Iterator))
print(isinstance('abcde', Iterator))
# 输出结果都为False

6. 迭代器Iterator

通过上面的分析，我们已经知道，迭代器是用来帮助我们记录每次迭代访问到的位置，当我们对迭代器使用next()函数的时候，迭代器会向我们返回它所记录位置的下一个位置的数据。实际上，在使用next()函数的时候，调用的就是迭代器对象的__next__方法（Python3中是对象的__next__方法，Python2中是对象的next()方法）。所以，我们要想构造一个迭代器，就要实现它的__next__方法。但这还不够，python要求迭代器本身也是可迭代的，所以我们还要为迭代器实现__iter__方法，而__iter__方法要返回一个迭代器，迭代器自身正是一个迭代器，所以迭代器的__iter__方法返回自身即可。

一个实现了__iter__方法和__next__方法的对象，就是迭代器。

class MyList(object):
    '''定义一个可迭代对象'''
    def __init__(self):
        self.containers = list()

    def add(self, num):
        self.containers.append(num)

    def __iter__(self):
        myiterator = MyIterator(self)
        return myiterator

class MyIterator(object):
    '''定义一个供上面可迭代对象使用的迭代器'''
    def __init__(self, mylist):
        self.mylist = mylist
        # current用来记录当前访问的位置
        self.current = 0

    def __next__(self):
        if self.current < len(self.mylist.containers):
            container = self.mylist.containers[self.current]
            self.current += 1
            return container
        else:
            raise StopIteration

    def __iter__(self):
        return self


mylist = MyList()
mylist.add(1)
mylist.add(2)
mylist.add(3)
mylist.add(4)
mylist.add(5)
for num in mylist:
    print(num)

# 输出结果：1、2、3、4、5

7. 迭代器的应用场景

我们发现迭代器最核心的功能就是可以通过next()函数的调用来返回下一个数据值。如果每次返回的数据值不是在一个已有的数据集合中读取的，而是通过程序按照一定的规律计算生成的，那么也就意味着可以不用再依赖一个已有的数据集合，也就是说不用再将所有要迭代的数据都一次性缓存下来供后续依次读取，这样可以节省大量的存储（内存）空间。

举个例子，比如，数学中有个著名的斐波拉契数列（Fibonacci），数列中第一个数为0，第二个数为1，其后的每一个数都可由前两个数相加得到：

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, ...

现在我们想要通过for...in...循环来遍历迭代斐波那契数列中的前n个数。那么这个斐波那契数列我们就可以用迭代器来实现，每次迭代都通过数学计算来生成下一个数

class Fibonacci(object):
    def __init__(self,n):
        self.n = n  # 生成数列的前n个数
        self.current = 0  # 保存当前生成到数列中的第几个数
        self.num1 = 0  # 保存前前一个数，初始值为数列中的第一个数0
        self.num2 = 1  # 保存前一个数，初始值为数列中的第二个数1

    def __next__(self):
        '''被next() 函数调用来获取下一个数'''
        if self.current < self.n:
            num = self.num1
            self.num1, self.num2 = self.num2, self.num1 + self.num2
            self.current += 1
            return num
        else:
            raise StopIteration

    def __iter__(self):
        '''迭代器的__iter__返回自身即可'''
        return self


fib = Fibonacci(8)
for num in fib:
    print(num)

8.并不是只有for循环能接收可迭代对象

除了for循环能接收可迭代对象，list、tuple等也能接收。

li = list(Fibonacci(8))
print(li)
tp = tuple(Fibonacci(8))
print(tp)
# 输出结果：
[0, 1, 1, 2, 3, 5, 8, 13]
(0, 1, 1, 2, 3, 5, 8, 13)

***

• 　　凡是可作用于for循环的对象都是Iterable类型

• 　　凡是可作用于next()函数的对象都是Iterator类型，他们表示一个惰性计算的序列；

• 　　集合数据类型如list、dict、str等是Iterable但不是Iterator,不过可以通过iter()函数获得一个Iterator对象。

生成器

1.生成器

利用迭代器，我们可以在每次迭代获取数据（通过next()方法）时按照特定的规律进行生成。但是我们在实现一个迭代器时，关于当前迭代到的状态需要我们自己记录，进而才能根据当前状态生成下一个数据。为了达到记录当前状态，并配合next()函数进行迭代使用，我们可以采用更简便的语法，即生成器(generator)。生成器是一类特殊的迭代器。

2.创建生成器方法1

要创建一个生成器，有很多种方法。第一种方法很简单，只要把一个列表生成式的 [ ] 改成 ( )

>>> L = [x * x for x in range(8)]
>>> L
[0, 1, 4, 9, 16, 25, 36, 49]
>>> g = (x * x for x in range(10))
>>> g
<generator object <genexpr> at 0x000002DCA3415BA0>

创建 L 和 G 的区别仅在于最外层的 [ ] 和 ( ) ， L 是一个列表，而 G 是一个生成器。我们可以直接打印出列表L的每一个元素，而对于生成器G，我们可以按照迭代器的使用方法来使用，即可以通过next()函数、for循环、list()等方法使用。

>>> next(g)
0
>>> next(g)
1
>>> next(g)
4
>>> next(g)
9
>>> next(g)
16
>>> next(g)
25
>>> next(g)
36
>>> next(g)
49
>>> next(g)
64
>>> next(g)
81
>>> next(g)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration
>>> g = (x * x for x in range(5))
>>> for i in g:
...     print(i)
...
0
1
4
9
16
>>>

3. 创建生成器方法2

generator非常强大。如果推算的算法比较复杂，用类似列表生成式的 for 循环无法实现的时候，还可以用函数来实现。

# 斐波拉契数列：
>>> def fib(n):
...     current, a, b = 0, 0, 1
...     while current < n:
...             a, b = b, a+b
...             current += 1
...             yield a
...     return 'done'
...
>>> f = fib(5)
>>> next(f)
1
>>> next(f)
1
>>> next(f)
2
>>> next(f)
3
>>> next(f)
5
>>> next(f)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration: done

在使用生成器实现的方式中，我们将原本在迭代器__next__方法中实现的基本逻辑放到一个函数中来实现，但是将每次迭代返回数值的return换成了yield，此时新定义的函数便不再是函数，而是一个生成器了。简单来说：只要在def中有yield关键字的 就称为 生成器

此时按照调用函数的方式( 案例中为f = fib(5) )使用生成器就不再是执行函数体了，而是会返回一个生成器对象（ 案例中为f ），然后就可以按照使用迭代器的方式来使用生成器了。

>>> for i in fib(5):
...     print(i)
...
1
1
2
3
5

但是用for循环调用generator时，发现拿不到generator的return语句的返回值。如果想要拿到返回值，必须捕获StopIteration错误，返回值包含在StopIteration的value中：

>>> g = fib(5)
>>> while True:
...     try:
...             x = next(g)
...             print('value:{}'.format(x))
...     except StopIteration as e:
...             print('生成器返回值:{}'.format(e.value))
...             break
...
value:1
value:1
value:2
value:3
value:5
生成器返回值:done

***

• 使用了yield关键字的函数不再是函数，而是生成器。（使用了yield的函数就是生成器）

• yield关键字有两点作用：

  • 保存当前运行状态（断点），然后暂停执行，即将生成器（函数）挂起
  • 将yield关键字后面表达式的值作为返回值返回，此时可以理解为起到了return的作用

• 可以使用next()函数让生成器从断点处继续执行，即唤醒生成器（函数）

• Python3中的生成器可以使用return返回最终运行的返回值，而Python2中的生成器不允许使用return返回一个返回值（即可以使用return从生成器中退出，但return后不能有任何表达式）。

4. 使用send唤醒

我们除了可以使用next()函数来唤醒生成器继续执行外，还可以使用send()函数来唤醒执行。使用send()函数的一个好处是可以在唤醒的同时向断点处传入一个附加数据。

# 使用send
>>> def test():
...     i = 0
...     while i < 5:
...             temp = yield i
...             print(temp)
...             i += 1
...
>>> t = test()
>>> next(t)
0
>>> t.send('heiheihei')
heiheihei
1
>>> next(t)
None
2
>>> t.send('hahahah')
hahahah
3
>>> next(t)
None
4
>>> next(t)
None
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration
>>>

# 使用next
>>> t = test()
>>> next(t)
0
>>> next(t)
None
1
>>> next(t)
None
2
>>> next(t)
None
3
>>> next(t)
None
4
>>> next(t)
None
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration
>>>

# 使用__next__()方法（不常使用）
>>> t = test()
>>> t.__next__()
0
>>> t.__next__()
None
1
>>> t.__next__()
None
2
>>> t.__next__()
None
3
>>> t.__next__()
None
4
>>> t.__next__()
None
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration