15 Python 迭代器和生成器

什么是迭代 （iterable）

　　字符串、列表、元组、字典、集合都可以被for循环，说明他们都是可迭代的。

　　可以直接作用于for循环的对象统称为可迭代对象(Iterable)。

　　可以被next()函数调用并不断返回下一个值的对象称为迭代器(Iterator)。

　　所有的Iterable均可以通过内置函数iter()来转变为Iterator。

　　对迭代器来讲，有一个__next__()就够了。在你使用for 和 in 语句时，程序就会自动调用即将被处理的对象的迭代器对象，然后使用它的__next__()方法，直到监测到一个StopIteration异常。

　　可迭代协议

　　　　我们现在是从结果分析原因，能被for循环的就是“可迭代的”，但是如果正着想，for怎么知道谁是可迭代的呢？

　　　　假如我们自己写了一个数据类型，希望这个数据类型里的东西也可以使用for被一个一个的取出来，那我们就必须满足for的要求。这个要求就叫做“协议”。

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

 >>> L = [1,2,3]
 >>> [x**2 for x in L]
 [1, 4, 9]
 >>> next(L)
 Traceback (most recent call last):
   File "<stdin>", line 1, in <module>
 TypeError: 'list' object is not an iterator
 >>> I=iter(L)
 >>> next(I)
 1
 >>> next(I)
 2
 >>> next(I)
 3
 >>> next(I)
 Traceback (most recent call last):
   File "<stdin>", line 1, in <module>
 StopIteration

　　上面例子中，列表L可以被for进行循环但是不能被内置函数next()用来查找下一个值，所以L是Iterable。

　　L通过iter进行包装后设为I，I可以被next()用来查找下一个值，所以I是Iterator。

1. 内置函数iter()仅仅是调用了对象的__iter()方法，所以list对象内部一定存在方法iter__()
2. 内置函数next()仅仅是调用了对象的__next()方法，所以list对象内部一定不存在方法next__()，但是Itrator中一定存在这个方法。
3. for循环内部事实上就是先调用iter()把Iterable变成Iterator在进行循环迭代的

 >>> L = [4,5,6]
 >>> I = L.__iter__()
 >>> L.__next__()
 Traceback (most recent call last):
   File "<stdin>", line 1, in <module>
 AttributeError: 'list' object has no attribute '__next__'
 >>> I.__next__()
 4
 >>> from collections import Iterator, Iterable
 >>> isinstance(L, Iterable)
 True
 >>> isinstance(L, Iterator)
 False
 >>> isinstance(I, Iterable)
 True
 >>> isinstance(I, Iterator)
 True
 >>> [x**2 for x in I]
 [25, 36]

迭代器

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

具有访问生成器的能力，可以访问到生成器的值，类似于生成器的__next__方法，一个一个值一个值得去迭代，只能够按照顺序的去查找。

特点：

1. 访问者不需要关心迭代器内部的结构，仅需通过next()方法不断去取下一个内容
2. 不能随机访问集合中的某个值 ，只能从头到尾依次访问
3. 访问到一半时不能往回退
4. 便于循环比较大的数据集合，节省内存

 print('__next__' in dir(range(12)))  #查看'__next__'是不是在range()方法执行之后内部是否有__next__
 print('__iter__' in dir(range(12)))  #查看'__next__'是不是在range()方法执行之后内部是否有__next__

 from collections import Iterator
 print(isinstance(range(100000000),Iterator))  #验证range执行之后得到的结果不是一个迭代器

yield from

 def gen1():
     for c in 'AB':
         yield c
     for i in range(3):
         yield i

 print(list(gen1()))

 def gen2():
     yield from 'AB'
     yield from range(3)

 print(list(gen2()))

生成器

　　1.生成器函数：常规函数定义，但是，使用yield语句而不是return语句返回结果。yield语句一次返回一个结果，在每个结果中间，挂起函数的状态，以便下次重它离开的地方继续执行

　　2.生成器表达式：类似于列表推导，但是，生成器返回按需产生结果的一个对象，而不是一次构建一个结果列表

生成器Generator：

　　本质：迭代器(所以自带了__iter__方法和__next__方法，不需要我们去实现)

　　特点：惰性运算,开发者自定义

生成器函数

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

　　仅仅拥有生成某种东西的能力，如果不用__next__方法是获取不到值得。

　　创建一个生成器函数

 >>> def scq():
     print("")
        # 当函数代码块中遇到yield关键字的时候，这个函数就是一个生成器函数
     yield 1
     print("")
     yield 2
     print("")
     yield 3

 # 把生成器赋值给一个对象

 >>> r = scq()

 # 查看r的苏剧类型并且输出r的值

 >>> print(type(r),r)
 <class 'generator'> <generator object scq at 0x000001F117D8DF10> 

 # 当执行生成器的__next__的时候，代码会按照顺序去执行，当执行到yield时会返回并
 # 提出，yield后面的值就是返回值，然后记录代码执行的位置，并退出

 >>> ret = r.__next__()
 11

 # 第二次执行的时候会根据上次代码执行的位置继续往下执行

 >>> ret = r.__next__()
 22
 >>> ret = r.__next__()
 33

 # 如果__next__获取不到值的时候就会报StopIteration错误

 >>> ret = r.__next__()
 Traceback (most recent call last):
   File "<stdin>", line 1, in <module>
 StopIteration

　　利用生成器创建一个range

 # 创建一个生成器函数，函数名是range，n是传入的参数，也是输出的数的最大值
 def range(n):
     # 默认从0开始
     start = 0
     # 进入while循环，如果最小值小于最大值就进入循环
     while start < n:
         # 第一次返回start，下面代码不执行
         yield start
         # 第二次进来的时候start = start + 1，然后进入下一次循环
         start += 1

 # 停止的参数为5
 obj = range(5)
 # 第一个数赋值给n1
 n1 = obj.__next__()
 # 第二个数赋值给n2
 n2 = obj.__next__()
 # 第三个数赋值给n3
 n3 = obj.__next__()
 # 第四个数赋值给n4
 n4 = obj.__next__()
 # 第五个数赋值给n5
 n5 = obj.__next__()

 # 输出这五个数的值
 print(n1,n2,n3,n4,n5)

 # 执行结果

 C:\Python35\python.exe F:/Python_code/sublime/Week5/Day03/s1.py
 0 1 2 3 4

 Process finished with exit code 0

　 生成器监听文件输入的例题

 import time

 def tail(filename):
     f = open(filename)
     f.seek(0, 2) #从文件末尾算起
     while True:
         line = f.readline()  # 读取文件中新的文本行
         if not line:
             time.sleep(0.1)
             continue
         yield line

 tail_g = tail('tmp')
 for line in tail_g:
     print(line)

　计算移动平均值（1）

 def averager():
     total = 0.0
     count = 0
     average = None
     while True:
         term = yield average
         total += term
         count += 1
         average = total/count

 g_avg = averager()
 next(g_avg)
 print(g_avg.send(10))
 print(g_avg.send(30))
 print(g_avg.send(5))

　计算移动平均值（2）预激协程的装饰器

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

 @init
 def averager():
     total = 0.0
     count = 0
     average = None
     while True:
         term = yield average
         total += term
         count += 1
         average = total/count

 g_avg = averager()
 # next(g_avg)   在装饰器中执行了next方法
 print(g_avg.send(10))
 print(g_avg.send(30))
 print(g_avg.send(5))

列表推导式和生成器表达式

 #老男孩由于峰哥的强势加盟很快走上了上市之路,alex思来想去决定下几个鸡蛋来报答峰哥

 egg_list=['鸡蛋%s' %i for i in range(10)] #列表解析

 #峰哥瞅着alex下的一筐鸡蛋,捂住了鼻子,说了句:哥,你还是给我只母鸡吧,我自己回家下

 laomuji=('鸡蛋%s' %i for i in range(10))#生成器表达式
 print(laomuji)
 print(next(laomuji)) #next本质就是调用__next__
 print(laomuji.__next__())
 print(next(laomuji))

各种推导式详解

　　推导式的套路

　　　　之前我们已经学习了最简单的列表推导式和生成器表达式。但是除此之外，其实还有字典推导式、集合推导式等等。

　　　　下面是一个以列表推导式为例的推导式详细格式，同样适用于其他推导式。

 variable = [out_exp_res for out_exp in input_list if out_exp == 2]
   out_exp_res:　　列表生成元素表达式，可以是有返回值的函数。
   for out_exp in input_list：　　迭代input_list将out_exp传入out_exp_res表达式中。
   if out_exp == 2：　　根据条件过滤哪些值可以。

列表推导式

　　例一：30以内所有能被3整除的数

 multiples = [i for i in range(30) if i % 3 is 0]
 print(multiples)
 # Output: [0, 3, 6, 9, 12, 15, 18, 21, 24, 27]

　　例二：30以内所有能被3整除的数的平方

 def squared(x):
     return x*x
 multiples = [squared(i) for i in range(30) if i % 3 is 0]
 print(multiples)

　　例三:找到嵌套列表中名字含有两个‘e’的所有名字

 names = [['Tom', 'Billy', 'Jefferson', 'Andrew', 'Wesley', 'Steven', 'Joe'],
          ['Alice', 'Jill', 'Ana', 'Wendy', 'Jennifer', 'Sherry', 'Eva']]

 print([name for lst in names for name in lst if name.count('e') >= 2])  # 注意遍历顺序，这是实现的关键

字典推导式

　　例一：将一个字典的key和value对调

 mcase = {'a': 10, 'b': 34}
 mcase_frequency = {mcase[k]: k for k in mcase}
 print(mcase_frequency)

　　例二：合并大小写对应的value值，将k统一成小写

 mcase = {'a': 10, 'b': 34, 'A': 7, 'Z': 3}
 mcase_frequency = {k.lower(): mcase.get(k.lower(), 0) + mcase.get(k.upper(), 0) for k in mcase.keys()}
 print(mcase_frequency)

集合推导式

　　例：计算列表中每个值的平方，自带去重功能

 squared = {x**2 for x in [1, -1, 2]}
 print(squared)
 # Output: set([1, 4])

练习题：

　　例1:  过滤掉长度小于3的字符串列表，并将剩下的转换成大写字母

　　例2:  求(x,y)其中x是0-5之间的偶数，y是0-5之间的奇数组成的元祖列表

　　例3:  求M中3,6,9组成的列表M = [[1,2,3],[4,5,6],[7,8,9]]

 1.[name.upper() for name in names if len(name)>3]
 2.[(x,y) for x in range(5) if x%2==0 for y in range(5) if y %2==1]
 3. [row[2] for row in M]

总结：

　　1.把列表解析的[]换成()得到的就是生成器表达式

　　2.列表解析与生成器表达式都是一种便利的编程方式，只不过生成器表达式更节省内存

　　3.Python不但使用迭代器协议，让for循环变得更加通用。大部分内置函数，也是使用迭代器协议访问对象的。例如， sum函数是Python的内置函数，该函数使用迭代器协议访问对象，而生成器实现了迭代器协议，所以，我们可以直接这样计算一系列值的和：

 sum(x ** 2 for x in range(4))

 # 而不用多此一举的先构造一个列表：

 sum([x ** 2 for x in range(4)]) 

可迭代对象：

　　拥有__iter__方法

　　特点：惰性运算

　　例如:range(),str,list,tuple,dict,set

迭代器Iterator：

　　拥有__iter__方法和__next__方法

　　例如:iter(range()),iter(str),iter(list),iter(tuple),iter(dict),iter(set),reversed(list_o),map(func,list_o),filter(func,list_o),file_o

生成器Generator：

　　本质：迭代器，所以拥有__iter__方法和__next__方法

　　特点：惰性运算,开发者自定义

使用生成器的优点：

1.延迟计算，一次返回一个结果。也就是说，它不会一次生成所有的结果，这对于大数据量处理，将会非常有用。

2.提高代码可读性

 #列表解析
 sum([i for i in range(100000000)])#内存占用大,机器容易卡死

 #生成器表达式
 sum(i for i in range(100000000))#几乎不占内存

生成器相关的面试题

　　生成器在编程中发生了很多的作用，善用生成器可以帮助我们解决很多复杂的问题

　　除此之外，生成器也是面试题中的重点，在完成一些功能之外，人们也想出了很多魔性的面试题。
　　面试题（1）

 def demo():
     for i in range(4):
         yield i

 g=demo()

 g1=(i for i in g)
 g2=(i for i in g1)

 print(list(g1))
 print(list(g2))

　　面试题（2）

 def add(n,i):
     return n+i

 def test():
     for i in range(4):
         yield i

 g=test()
 for n in [1,10]:
     g=(add(n,i) for i in g)

 print(list(g))

　　tail&grep

 def demo():
     for i in range(4):
         yield i

 g=demo()

 g1=(i for i in g)
 g2=(i for i in g1)

 print(list(g1))
 print(list(g2))

 复制代码
 复制代码

 def add(n,i):
     return n+i

 def test():
     for i in range(4):
         yield i

 g=test()
 for n in [1,10]:
     g=(add(n,i) for i in g)

 print(list(g))

 复制代码
 复制代码

 import os

 def init(func):
     def wrapper(*args,**kwargs):
         g=func(*args,**kwargs)
         next(g)
         return g
     return wrapper

 @init
 def list_files(target):
     while 1:
         dir_to_search=yield
         for top_dir,dir,files in os.walk(dir_to_search):
             for file in files:
                 target.send(os.path.join(top_dir,file))
 @init
 def opener(target):
     while 1:
         file=yield
         fn=open(file)
         target.send((file,fn))
 @init
 def cat(target):
     while 1:
         file,fn=yield
         for line in fn:
             target.send((file,line))

 @init
 def grep(pattern,target):
     while 1:
         file,line=yield
         if pattern in line:
             target.send(file)
 @init
 def printer():
     while 1:
         file=yield
         if file:
             print(file)

 g=list_files(opener(cat(grep('python',printer()))))

 g.send('/test1')

 协程应用：grep -rl /dir