python(迭代器，生成器)

1.迭代

　　将某个数据集中的数据‘一个一个挨着取出来’,就是迭代。

'''
dir([1,2].__iter__())是列表迭代器中实现的所有方法，dir([1,2])是列表中实现的所有方法,都是以列表的形式返回给我们的，为了看的更清楚，我们分别把他们转换成集合，
然后取差集。
'''
#print(dir([1,2].__iter__()))
#print(dir([1,2]))
print(set(dir([1,2].__iter__()))-set(dir([1,2])))

 运行结果：{'__length_hint__', '__setstate__', '__next__'}

　其中 __length_hint__表示的是迭代元素的个数。

　__next()__表示取出元素

　__setstate__设置迭代起始的位置

iter_l = [1,2,3,4,5,6].__iter__()
# 获取迭代器中元素的长度
print(iter_l.__length_hint__())
# 根据索引值指定从哪里开始迭代
print('*',iter_l.__setstate__(4))
#一个一个的取值
print('**',iter_l.__next__())
print('***',iter_l.__next__())
# 如果再次__next__()会直接报错
print('****',iter_l.__next__())
# 报错 停止迭代 StopIteration

使用try except处理这个异常

# 使用异常处理机制处理这个机制
list_1 = [1,2,3,4,5,6]
iterator = list_1.__iter__()
while 1:
    try:
        item = iterator.__next__()
        print(item)
    except StopIteration:
        break

迭代器遵循迭代器协议:必须拥有__iter__方法和__next__方法

对range（）进行如下测试：

print('__iter__' in dir(range(12))) # True
print('__next__' in dir(range(12))) # False
from collections import Iterator
from collections import Iterable
print(isinstance(range(2),Iterator)) # False 不是一个迭代器 迭代器必须同时满足__iter__ __next__
print(isinstance(range(2),Iterable)) # True 是一个迭代对象 __iter__ 

可迭代协议　

　可以被迭代的满足的要求就叫做可迭代协议。可迭代协议的定义非常的简单。就是在内部实现了__iter__方法。

　分析__iter__方法做了什么事情呢？

print([1,2,3].__iter__()) # <list_iterator object at 0x10ae1a2e8>
print(range(2).__iter__()) # <range_iterator object at 0x10aeef6f0>

随后就可以快乐的使用for in i xxx 就可以迭代取出内部的数据咯

i = range(2).__iter__() # <range_iterator object at 0x10aeef6f0>
for j in i:
    print(j) # 0 i

2.生成器

　　2.1 生成器函数

　　一个包含yield关键字的函数就是一个生成器函数。yield可以为我们从函数中返回值，但是yield又不同于return，return的执行意味着程序的结束，调用生成器函数不会得到返回的具体的值，而是得到一个可迭代的对象。每一次获取这个可迭代对象的值，就能推动函数的执行，获取新的返回值。直到函数执行结束。

def generator():
    print(1)
    yield 'a'
    print(2)
    yield 'b'
g = generator()
# print(g) # <generator object generator at 0x110419f10>
# print(g.__next__())
"""
1
a
"""
# print(g.__next__())
"""
1
a
2
b
"""
# print(g.__next__()) # 没有了报错。.StopIteration
# 当前 使用for 迭代取出
for i in g:
    print(i)
"""
1
a
2
b
"""

生成器有什么好处呢？就是不会一下子在内存中生成太多数据。

假设要生产200w箱娃哈哈. 按需生产。请求一箱。生产一箱。

# 200w箱娃哈哈 需要一箱。生产一箱
import time
def create_wahaha():
    for i in range(1,2000000):
        yield'生产了%s箱娃哈哈'%i

generator = create_wahaha()
# 开始要第一箱娃哈哈
for i in range(100):
    if i == 10:
        break
    print(generator.__next__())
    time.sleep(1)


print(generator.__next__()) # 生产了11箱娃哈哈 并不会从第一箱开始.除非再次调用create_wahaha()


generator2 = create_wahaha()
print(generator2.__next__()) # 生产了1箱娃哈哈

 2.2、send

def generator():
    print(123)
    content = yield 1
    print('=====',content)
    print(456)
    yield 2
g = generator()
ret = g.__next__()
print("*****",ret) 
ret = g.send('hello')
print('*******',ret)
"""
123
***** 1
===== hello
456
******* 2
"""
# 使用send获取下一个值的效果和next基本一致
# 只是在获取下一个值的时候，给上一个yield的位置传递一个数据
# --------
# 第一次使用生成器的时候，必须使用next获取下一个值
# 最后一个yield不能接收外部的值

小试牛刀，借助yield计算移动的平均速度

def average():
    total = 0
    count = 0
    avg = None
    while True:
      term = yield avg
      total += term
      count +=1
      avg = total / count
a = average()
# next(a)
a.__next__()
print(a.send(10))
print(a.send(20))
print(a.send(30))

进一步借助装饰器去掉每一次调用必须执行next()

def init(func): #在调用被装饰生成器函数的时候首先用next激活生成器
    def inner(*agrs,**kwargs):
        g = func(*agrs,**kwargs)
        next(g)
        return g
    return inner

@init
def average():
    total = 0.0
    count = 0
    average = None
    while True:
        term = yield average
        total += term
        count += 1
        average = total / count
g_avg = average()
# next(g_avg) 在装饰器中已经执行了该方法
print(g_avg.send(10))
print(g_avg.send(20))