协程

 

二：迭代器

迭代：是一种动作，访问集合元素的一种方式。

迭代器：是一种对象，可以记住遍历位置的一种对象，迭代器只能往前，知道集合中的所有元素被访问完，才会结束。

那么什么东西才能被迭代呢？也就是可以for in 

可迭代对象：list tuple dict  str

for i in 100:
    print(i)

# 结果
TypeError: 'int' object is not iterable

 

那我们能不能自己构造一个对象，具有迭代的功能呢？

class Test(object):
    def __init__(self):
        self.box = []
    def add(self,value):
        self.box.append(value)
t = Test()
t.add(1)
t.add(2)
t.add(3)
for i in t:
    print(i)

# 结果
TypeError: 'Test' object is not iterable

 

结果：也不能进行迭代

那么到底什么东西是可以被迭代的呢？那么我们就要看看可迭代对象的本质是什么？

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

也就是说可迭代对象，必须具有迭代器。那么我们对上面的类，进行改造，增加__iter__函数，看是否是一个可以被迭代的对象。

from collections import Iterable # 导入迭代对象
class Test(object):
    def __init__(self):
        self.box = []
    def add(self,value):
        self.box.append(value)
    def __iter__(self):
        pass
t = Test()
t.add(1)
t.add(2)
t.add(3)
print(isinstance(t,Iterable)) # 判断是否是一个可以迭代对象
for i in t:
    print(i)

# 结果
True
TypeError: iter() returned non-iterator of type 'NoneType' 

 

加上__iter__函数后，Test的实例对象就变成了了一个可迭代对象，那么为什么循环的时候报错：iter()返回的非迭代器类型为“NoneType”，也就是说__iter__函数里面的返回值有问题。

那么我们来看iter()函数

demo = [1,2,3]
demo_iter = iter(demo)

print(demo_iter.__next__())
print(next(demo_iter))
print(next(demo_iter))
print(next(demo_iter))

# 结果
1
2
3
StopIteration

 

iter(可迭代对象)函数的参数是一个可迭代对象，然后可以调用next（iter（可迭代对象））或者 iter（）.__next__()方法来获取可迭代对象里面的元素，元素获取结束后，再继续获取报错。

iter（可迭代对象）返回的是可迭代对象的迭代器，使用next（迭代器）函数可以通过迭代器，取出元素。

iter()函数实际上就是调用了可迭代对象的__iter__方法。也就是说明，可迭代对象的__iter__方法返回值是一个迭代器。

那我们给__iter__函数的返回值为一个可迭代对象，是不是就能够进行循环了呢？

from collections import Iterable # 导入迭代器
class Test(object):
    def __init__(self):
        self.box = []
    def add(self,value):
        self.box.append(value)
    def __iter__(self):
        return self.box
t = Test()
t.add(1)
t.add(2)
t.add(3)

for i in t:
    print(i)

# 结果
TypeError: iter() returned non-iterator of type 'list'
更加印证了，__iter__返回值是一个迭代器，而不是迭代对象

 

__iter_返回值必须是一个迭代器

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

class Test(object):
    def __init__(self):
        self.box = []
    def add(self,value):
        self.box.append(value)
    def __iter__(self):
        # 返回迭代器对象,self的作用是让迭代器对象可以取到self.box
        myiterator = MyIterator(self)
        return myiterator

class MyIterator():
    def __init__(self,myiterable):
        self.myiterable = myiterable
        # 用来记录位置
        self.position = 0
    def __next__(self):
        """循环的时候，循环器就是调用的这个方法"""
        if self.position < len(self.myiterable.box):
            item = self.myiterable.box[self.position]
            self.position += 1
            return item
        # 保证循环结束后可以停止，要不会一直返回None
        raise StopIteration
    def __iter__(self):
        pass

t = Test()
t.add(1)
t.add(2)
t.add(3)
for i in t:
    print(i)

# 结果
1
2
3

那么for in 的本质是什么呢？

其实for的本质是 先通过iter（）获取迭代器，然后通过 调用调用next方法从迭代器中取返回值，item

上面的循环都是从迭代器从可迭代对象里面通过index取对应的元素，那么如果我们不是从可迭代对象里面取值，而是直接在迭代器里面的运算值，那么会是怎样呢？

下面的例子是迭代器版的费布拉切数列数列的n项

class FibIterator():

    def __init__(self,count):
        self.n1 = 0
        self.n2 = 1
        self.p = 0
        self.count = count
    def __iter__(self):
        pass
    def __next__(self):
        if self.p < self.count:
            item = self.n1
            self.n1,self.n2 = self.n2,self.n1 + self.n2
            self.p += 1
            return item
        raise StopIteration


f = FibIterator(10)
for i in range(10):
    print(next(f))

0
1
1
2
3
5
8
13
21
34

 

改进迭代器

class Test():

    def __init__(self):
        self.box = list()
        self.n = 0
    def __iter__(self):
        # 这里必须返回self,循环的时候先从iter中取self,也就是迭代器,不传self,会报错，iterator:None-Type
        return self
    def __next__(self):
        if self.n < len(self.box):
            item = self.box[self.n]
            self.n += 1
            return item
        raise StopIteration
    def add(self,value):
        self.box.append(value)

t = Test()
t.add(1)
t.add(2)
t.add(3)
# print(next(t))
# print(next(t))
# print(next(t))
# print(next(t))
for i in t:
    # i 其实就是每次next(t)的返回值，也就是item
    print(i)

# 结果
1
2
3

 

总结：迭代器一定是可迭代对象，因为具有iter（）和next（）方法，可迭代对象不一定是迭代器，因为只具有iter（）方法。

生成器：迭代器可以通过next（）方法取到返回值，但是这不能满足现实需求，因为每一次迭代的状态需要我们自己记录，也就是 +=1 操作，或者斐波那契中的 item=self.n1 这都要我们自己记录，

很不方便，尤其是在菲波那切数列例子中：

item = self.n1 # 记录当前的状态
self.n1,self.n2 = self.n2,self.n1 + self.n2
self.p += 1  # 下一次迭代的条件

 

这里我们就引入一个特殊的迭代器，就是生成器，来看看生成器是怎么简化迭代器的代码的

def fib(count):
    n1 = 0
    n2 = 1
    p = 0
    while p < count:
        item = n1
        n1,n2 = n2,n1+n2
        p += 1
        yield item
    raise StopIteration

f = fib(5) # f 生成器对象
for i in f:
    print(i)

# 结果
0
1
1
2
3
RuntimeError: generator raised StopIteration

 

一个函数：只要有了yield就变成了生成器，可以循环 for i in f，可以next（f），不用再创建 __iter__（）和__next__（）函数了。

对上面的生成器进行分析

def fib(count):
    n1 = 0
    n2 = 1
    p = 0
    while p < count:
        item = n1
        n1,n2 = n2,n1+n2
        p += 1
        print("函数暂停了，yield给外界的值是:%d" % item)
        yield item  
　　　　　　　　　　　　
    raise StopIteration


f = fib(5)
print(next(f))
print(next(f))

# 结果
函数暂停了，yield给外界的值是:0
0
函数暂停了，yield给外界的值是:1
1

 

总结：生成器执行的起点是yield处，yield会让生成器暂停，当调用next（生成器对象），生成器继续启动，遇到yield继续暂停。

yield---暂停功能。

next()---激活生成器，让生成器继续运行。

下面有一个重要的激活方式 send，send和next不同，send可以传入一个值，这个值可以通过seng激活生成器获得。

感觉send启动生成器很鸡肋，那么我们到底要这么send有什么具体的用处呢？

有一个例子，是动态求平均值

 

探讨迭代器里面yield的作用

import time

def func1():

    for i in range(11):
        # yield 作用是为了进行任务切换，切换的出发点是阻塞
        # 5. 进入迭代器，遇到yield，迭代器暂停 10 继续遇到yield，迭代器暂停
        yield
        # 9. 继续启动了迭代器，执行yield后面的内容，打印
        print('这是我第%s次打印啦' % i)
        time.sleep(1)


def func2():
    # 3.进入函数内部
    g = func1()
    # 4. 启动了 func1迭代器
    next(g)
    # 6. 因为迭代器暂停，进入循环
    for k in range(10):
        # 7. 打印 11 因为迭代器暂停，继续执行打印
        print('哈哈，我第%s次打印了' % k)
        time.sleep(1)
        # 8. 继续启动迭代器
        next(g)

#不写yield，下面两个任务是执行完func1里面所有的程序才会执行func2里面的程序，有了yield，我们实现了两个任务的切换+保存状态
# 1. 遇到func1(),但是因为里面有yield，func1就不是一个函数了，而是一个迭代器，需要用next(func1)来启动，所以这一步就不执行
func1()
# 2. func2()是一个正常的函数，调用函数
func2()



哈哈，我第0次打印了
这是我第0次打印啦
哈哈，我第1次打印了
这是我第1次打印啦
哈哈，我第2次打印了
这是我第2次打印啦
哈哈，我第3次打印了
这是我第3次打印啦
哈哈，我第4次打印了
这是我第4次打印啦
哈哈，我第5次打印了
这是我第5次打印啦
哈哈，我第6次打印了
这是我第6次打印啦
哈哈，我第7次打印了
这是我第7次打印啦
哈哈，我第8次打印了
这是我第8次打印啦
哈哈，我第9次打印了
这是我第9次打印啦

知识点一：函数里面有yield就不是一个函数了，而是一个迭代器，启动方式可以用next(函数名) 进行启动，启动后，进入迭代器内部，当执行遇到yield的地方，停止了，此时yield会保留执行的上下文，保存状态，然后重要的是，切换功能，切换到调用next（函数名）的地方，继续执行后面的代码。此时迭代器，处于暂停状态，一直到遇到next（函数名），才会继续启动迭代器，然后执行迭代器，yield后面的代码

 

 

 

 

 

 

 

 

 

# TODO