迭代器和生成器
迭代器(iterator)
迭代器协议：必须拥有__iter__方法和__next__方法。
字符串，列表，元组，字典，集合都可以被for 循环，说明他们都是可迭代的。
from collections import Iterable
l=[1,2,3,4,5]
t=(3,4,5,6,6)
d={'a':1,'b':2}
s={1,2,3,4,5}
print(isinstance(l,Iterable))
print(isinstance(t,Iterable))
print(isinstance(d,Iterable))
print(isinstance(s,Iterable))
# True
# True
# True
# True
结合使用for循环时的现象，可以从字面上理解，迭代就是可以将某个数据集内的数据'一个挨着一个的取出来'。
可迭代协议：内部含有__iter__方法的数据类型就是可迭代的
验证可迭代协议：
print(dir([1,2]))
print(dir((2,3)))
print(dir({'a':1,'b':2}))
print(dir({1,2,3,4}))
# ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
# ['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']
# ['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
# ['__and__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__iand__', '__init__', '__init_subclass__', '__ior__', '__isub__', '__iter__', '__ixor__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__rand__', '__reduce__', '__reduce_ex__', '__repr__', '__ror__', '__rsub__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__xor__', 'add', 'clear', 'copy', 'difference', 'difference_update', 'discard', 'intersection', 'intersection_update', 'isdisjoint', 'issubset', 'issuperset', 'pop', 'remove', 'symmetric_difference', 'symmetric_difference_update', 'union', 'update']
由上可以看出，可以被for循环的都是可迭代的，要想可迭代，内部必须要有一个__iter__方法。
执行以下__iter__方法：
print([1,2].__iter__()) # <list_iterator object at 0x000001A68B0210B8>
得到了一个list_iterator，此时我们又得到了一个新的名词——iterator。
同样的，可以对字典、集合、元祖进行__iter__操作
print((1,2,3).__iter__())
print({'a':1,'b':2}.__iter__())
print({1,2,3}.__iter__())
# <tuple_iterator object at 0x0000021688F61080>
# <dict_keyiterator object at 0x0000021688E8A4A8>
# <set_iterator object at 0x0000021688F60630>
同样的得到了tuple_iterator、dict_keyiterator、set_iterator，这就说明了它们都是可迭代的。
可以通过集合求差集来看可迭代对象与迭代器质检的差别。
print(set(dir([1,2].__iter__()))-set(dir([1,2])))
# {'__next__', '__length_hint__', '__setstate__'}
#可以看出可迭代对象比迭代器多了一个__next__功能
对可迭代对象进行操作：
iter_1=[1,2,3,4,5].__iter__()
print(iter_1.__length_hint__())
# 从索引为2的元素开始迭代
print('*',iter_1.__setstate__(2))
#一个一个的取值
print('**',iter_1.__next__())
print('***',iter_1.__next__())
# 5
# * None
# ** 3
# *** 4
可以看到其中的__next__方法可以实现一个一个的取值。在for循环的内部就是调用了__next__方法才能取到一个一个的值。
写一个使用迭代器的__next__方法来遍历的程序，不需要for循环：
l=[1,2,3,4] l_iter=l.__iter__() item=l_iter.__next__() print(item) item=l_iter.__next__() print(item) item=l_iter.__next__() print(item) item=l_iter.__next__() print(item) item=l_iter.__next__() print(item) # 1 # 2 # 3 # 4 # File "G:/群下载/2.闭包的概念.py", line 206, in <module> # item=l_iter.__next__() # StopIteration
上述方法确实将l中的每个元素都遍历且取出来了，但是当l中的元素个数不清楚 的时候我们会写很多行重复的代码，且当超出范围的时候还会像上面一样报错。
这个时候，我们需要使用异常处理机制来将这个异常来处理掉。用while循环来模拟for循环的原理：———for循环时依赖迭代器，且也可以仿照写一个。
for 循环就是想让我们更简单的使用迭代器
用迭代器取值就不需要关心索引或者key的问题了。
l=[1,2,3,4]
l_iter=l.__iter__()
while True:
try:
item=l_iter.__next__()
print(item)
except StopIteration:
break
# 1
# 2
# 3
# 4
range()方法：
# 查看__iter__方法中range()使用dir()方法之后是否还存在
print('__iter__'in dir(range(12)))
#查看__next__方法中range()使用dir()方法之后是否还存在
print('__next__' in dir(range(12)))
from collections import Iterable
print(isinstance(range(100),Iterable)) # 验证range执行之后得到的结果是不是一个迭代器
# True
# False
# True
可迭代的必须要含有__iter__方法 # 可迭代协议
迭代器比可迭代的多一个__next__方法
迭代器：包含__next__，__iter__方法的就是迭代器。 # 迭代器协议
包含__next__方法的可迭代对象就是迭代器
迭代器是可迭代的一部分
获得迭代器：可迭代的调用__iter__()
使用迭代器：__next__()
如何判断一个变量是不是迭代器或者可迭代的
方法一：
print('__iter__' in dir([1,2,3,4]))
print('__next__' in dir([1,2,3,4]))
# True
# False
# 由此可以看出[1,2,3,4]有__iter__用法，没有__next__用法，说明该列表是一个可迭代对象，
#但不是一个迭代器。
方法二：
from collections import Iterable
print(isinstance(([1,2,3,4]),Iterable))
# True
str_iter='abc'.__iter__()
print(isinstance(str_iter,Iterable))
# True
print(isinstance('abc',Iterable))
# True
只是记录当前这个元素和下一个元素
range_iter=range(10).__iter__() print(range_iter.__next__()) print(range_iter.__next__()) # 0 # 1
总结迭代器的特点：1、惰性运算；
2、从前到后依次的取值，但是过程是不可逆的，不可重复的；
3、节省内存
生成器：
用生成器做监听文件的程序
def tail():
f = open('文件', 'r', encoding='utf-8') # 打开文件
f.seek(0, 2) # 将光标移到文件内容的最后
while True:
line = f.readline() # 读出文件中光标之后的内容
if line: # 如果有则输出新加的内容
yield line
g = tail()
for i in g:
print(i.strip())
send用法：
1、从哪一个yield开始接着执行，就把一个值传给了那个yield
2、send不能用在第一个触发生成器
3、生成器函数中有多少个yield就必须有多少个next+send
def func():
print('*'*10)
a = yield 5
print(a)
b = yield 10
g = func()
num = g.__next__()
print(num)
num2 = g.send('alix')
print(num2)
# **********
# 5
# alix
# 10
利用send计算滚动平均值：
def avarge():
total=0.0
count=0
avarge=None
while True:
trem=yield avarge
count+=1
total+=trem
avarge=total/count
g=avarge()
avg_num=g.__next__()
avg_num=g.send(10)
print(avg_num)
avg_num=g.send(30)
print(avg_num)
avg_num=g.send(60)
print(avg_num)
# 10.0
# 20.0
# 33.333333333333336
将上面的滚动平均值改成装饰器的形式：
def init(func): # 生成器的预激装饰器
def inner(*args,**kwargs):
g=func(*args,**kwargs) # func=avarge
g.__next__()
return g
return inner
@init
def avarge():
total=0.0
count=0
avarge=None
while True:
trem = yield avarge
count += 1
total += trem
avarge = total/count
g = avarge()
avg_num=g.send(10)
print(avg_num)
avg_num=g.send(30)
print(avg_num)
avg_num=g.send(60)
print(avg_num)
# 10.0
# 20.0
# 33.333333333333336
# 将a='AB',b='CD'输出，输出成'A','B','C','D'
def func():
a = 'AB'
b = 'CD'
yield from a
yield from b
g=func()
g_s=g.__next__()
print(g_s)
g_s=g.__next__()
print(g_s)
g_s=g.__next__()
print(g_s)
g_s=g.__next__()
print(g_s)
# A
# B
# C
# D
或将上面的代码简化
# 将a='AB',b='CD'输出，输出成'A','B','C','D'
def func():
a = 'AB'
b = 'CD'
yield from a
yield from b
g=func()
for i in g:
print(i)
# A
# B
# C
# D
触发执行的方式：
next和send是执行几次拿几个数据，在取值的过程中不知道到底有多少个，可能会超出范围，当超出范围的时候会报错。
其中send(None)==__next__(),send中next的基础上传一个值到生成器函数内部；send操作不能用在生成器使用的第一次。
for循环每次取一个值，取完为止，不会报错
def cloth():
for i in range(100):
yield '衣服%s'%i
g = cloth()
for c in g:
print(c)
if c.endswith('20'): # 打印到衣服20
break
print(g.__next__()) # 再次触发生成器，输出衣服21到衣服99
print('*'*20)
for c in g:
print(c)
列表推导式：
求出l=[1,2,3,4,5,6,7]中每个元素的平方并存入新的列表中
#方法一：
l=[1,2,3,4,5,6,7]
li=[]
for i in l:
li.append(i*i)
l=li
print(l)
# [1, 4, 9, 16, 25, 36, 49]
#方法二：
l=[1,2,3,4,5,6,7]
x=[i*i for i in l]
print(x)
# [1, 4, 9, 16, 25, 36, 49]
生成器表达式：
l=[1,2,3,4,5,6,7]
g=(i*i for i in l)
for i in g:
print(i)
# 1
# 4
# 9
# 16
# 25
# 36
# 49
使用生成器的优点：
1、延迟计算，一次返回一个结果。也就是说，它不会一次生成所有的结果，这在处理较多数据的时候可以节省内存空间。
2、提高代码可读性
字典的推导式：
找出names中含有2个e的名字：
names=[{'Tom','Billy','Jefferson','Andrew','Wesley','Steven','Joe'},
{'Alice','Jill','Ana','Wendy','Jennifer','Sherry','Eva'}]
names=[{'Tom','Billy','Jefferson','Andrew','Wesley','Steven','Joe'},
{'Alice','Jill','Ana','Wendy','Jennifer','Sherry','Eva'}]
ret=[name for name_list in names for name in name_list if name.count('e')>=2] # 相当于两个for循环的嵌套，之后再加上一个if判断
print(ret)
# ['Steven', 'Jefferson', 'Wesley', 'Jennifer']
