python----------迭代器和生成器

一、可迭代协议：可以被迭代要满足要求的就叫做可迭代协议。内部实现了__iter__方法

　iterable：可迭代的------对应的标志

　　什么叫迭代？：一个一个取值，就像for循环一样取值

字符串，列表，元组，集合，字典都是可迭代的

二、迭代器协议：内部实现了__iter__，__next__方法

　　迭代器大部分都是在python的内部去使用的，我们直接拿来用就行了

　　迭代器的优点：如果用了迭代器，节约内存，方便操作

dir([1,2].__iter__())是列表迭代器中实现的所有的方法，而dir([1,2])是列表中实现的所有方法，都是以列表的方式返回给我们，为了方便看清楚，我们把他们转换成集合，然后取差集，然而，我们看到列表迭代器中多出了三个方法，那么这三个方法都分别是干什么的呢？

  1 print(dir([1,2].__iter__()))#查看列表迭代器的所有方法
  2 print(dir([1,2]))#查看列表的所有方法
  3 print(set(dir([1,2].__iter__()))-set(dir([1,2])))

  1 iter_l=[1,2,3,4,5,6].__iter__()
  2 
  3 print(iter_l.__length_hint__())#获取迭代器中元素的长度
  4 # print(iter_l.__setstate__(4))#根据索引指定从哪里开始迭代
  5 
  6 print(iter_l.__next__())
  7 print(iter_l.__next__())
  8 print(iter_l.__next__())#一个一个的取值
  9 print(next(iter_l))
 10 #next(iter_l)这个方法和iter_l.__next__()方法一样，推荐用next(iter_l)这个

生成器表达 View Code

  1 l=[1,2,3,4,5]
  2 a=l.__iter__()
  3 
  4 # print(next(a))
  5 # print(next(a))
  6 # print(next(a))
  7 # print(next(a))
  8 # print(next(a))
  9 # print(next(a))   #上面的列表长度只有5个，而你多打印了，就会报错。处理的情况如下，就不会报错了
 10 
 11 while True:
 12     try:
 13         item=a.__next__()
 14         print(item)
 15     except StopIteration: # 异常处理
 16         break

View Code

三、可迭代和迭代器的相同点：都可以用for循环

四、可迭代和迭代器的不同点：就是迭代器内部多实现了一个__next__方法

五、判断迭代器和可迭代的方法：

　　第一种：判断内部是不是实现了__next__方法

  1 '__iter__' in dir(str)#如果__iter__在这个方法里面，就是可迭代的。

View Code

　　第二种：

　　　　Iterable 判断是不是可迭代对象

　　　　Iterator 判断是不是迭代器

　　　　用法：

  1 from collections import Iterable
  2 from collections import Iterator
  3 
  4 #比如给一个字符串
  5 s='abc'
  6 print(isinstance(s,Iterable))#isinstance判断类型的
  7 print(isinstance(s,Iterator))

View Code

判断range函数和map函数

  1 map1=map(abs,[1,-2,3,-4])
  2 print(isinstance(map1,Iterable))
  3 print(isinstance(map1,Iterator))#map方法自带迭代器
  4 
  5 s=range(100)#是一个可迭代的，但是不是迭代器
  6 print(isinstance(s,Iterable))
  7 print(isinstance(s,Iterator))

View Code

五、生成器函数：常规定义函数，但是，使用yield语句而不是return语句返回结果。yield语句一次返回一个结果。生成器的好处，就是一下子不会在内存中生成太多的数据

python中提供的生成器：1.生成器函数 2.生成器表达式

生成器的本质：就是一个迭代器

  1 def  func(): #这是一个简单的函数
  2         a=1
  3         return a
  4 print(func())
  5 
  6 
  7 def func():
  8     print('aaaaaaaaaaa')
  9     a = 1
 10     yield a  # 返回第一个值
 11     print('bbbbbb')
 12     yield 12  # 返回第二个值
 13 
 14 
 15 ret = func()  # 得拿到一个生成器
 16 # print(ret)#返回的是一个地址
 17 print(next(ret))#取第一个值
 18 print(next(ret))# 取第二个值
 19 print(next(ret))# 取第三个值，会报错，因为没有yield第三个值
 20 
 21

初始生成器 View Code

假如我想让工厂给学生做校服，生产2000000件衣服，我和工厂一说，工厂应该是先答应下来，然后再去生产，我可以一件一件的要，也可以根据学生一批一批的找工厂拿。
而不能是一说要生产2000000件衣服，工厂就先去做生产2000000件衣服，等回来做好了，学生都毕业了。。。

  1 def make_cloth():
  2     for i in range(1,20000):
  3         yield '第%s件衣服'%(i)
  4 ret = make_cloth()
  5 print(next(ret))
  6 print(next(ret))
  7 print(next(ret))
  8 for i in range(100):
  9     print(next(ret))
 10 
 11

做衣服生成器 View Code

  1 必须先用next再用send
  2 def average():
  3     total=0 #总数
  4     day=0 #天数
  5     average=0 #平均数
  6     while True:
  7         day_num = yield average   #average=0
  8         total += day_num
  9         day += 1
 10         average = total/day
 11 avg=average() #直接返回生成器
 12 next(avg)#激活生成器，avg.send(),什么都不传的时候send和next的效果一样
 13 print(avg.send(10))
 14 print(avg.send(20))#send   1.传值 2.next
 15 print(avg.send(30))
 16 
 17

计算移动平均值 View Code

  1 让装饰器去激活
  2 def wrapper(func):
  3     def inner(*args,**kwargs):
  4        ret = func(*args,**kwargs)
  5        next(ret)
  6        return ret
  7     return inner
  8 
  9 @wrapper
 10 def average():
 11     total=0 #总数
 12     day=0 #天数
 13     average=0 #平均数
 14     while True:
 15         day_num = yield average   #average=0
 16         total += day_num
 17         day += 1
 18         average = total/day
 19 
 20 
 21 ret=average() #直接返回生成器
 22 print(ret.send(10))
 23 print(ret.send(20))#send   1.传一个值过去 2.让当前yield继续执行
 24 print(ret.send(30))
 25 
 26

带装饰器的计算移动平均值 View Code

  1 import time
  2 
  3 
  4 def tail(filename):
  5     f = open(filename)
  6     f.seek(0, 2) #从文件末尾算起
  7     while True:
  8         line = f.readline()  # 读取文件中新的文本行
  9         if not line:
 10             time.sleep(0.1)
 11             continue
 12         yield line
 13 
 14 tail_g = tail('tmp')
 15 for line in tail_g:
 16     print(line)
 17 
 18

生成器监听文件例子 View Code

六、yield from

  1 def func():
  2     # for i in 'AB':
  3     #     yield i
  4     yield from 'AB'     yield from 'AB'就相当于上面的for循环，吧循环简化了
  5     yield from [1,2,3]
  6 
  7 g=func()
  8 print(list(g))
  9 # print(next(g))
 10 # print(next(g))
 11 
 12

yield from View Code

七、列表推导式：

  1 举例一
  2 y=2
  3 #for i in range(100):
  4  #   print(i*y)
  5 
  6 
  7 #列表推导式是for循环的简写
  8 l=[i*y for i in range(100)]
  9 
 10 举例二
 11 l=[{'name':'v1','age':'22'},{'name':'v2'}]
 12 # for dic in l:
 13 #     print(dic['name'])
 14 name_list=[dic['name'] for dic in l]
 15 print(name_list)
 16 
 17

列表推导式 View Code

  1 # ======一层循环======
  2 l = [i*i for i in range(1,10)]
  3 print(l)
  4 # 上面的列表推倒式就相当于下面的
  5 l  = []
  6 for i in range(1,10):
  7     l.append(i*i)
  8 print(l)
  9 l = []
 10 
 11 
 12 # ======多层循环========
 13 # 1.列表推倒式
 14 l = [i*j for i in range(1,10) for j in range(1,10)]
 15 print(l)
 16 # 2.循环
 17 l = []
 18 for i in range(1,10):
 19     for j in range(1,10):
 20         s = i*j
 21         l.append(s)
 22 print(l)

View Code

八、生成器表达式：类似于列表推倒式，就是把列表推导式的【】改为了（）

  1 l=[{'name':'v1','age':'22'},{'name':'v2'}]
  2 
  3 name_list=(dic['name'] for dic in l)#吧列表生成器的[]改成()
  4 print(name_list)#取出的是一个生成器，而不是要取得值，所以得加上next
  5 print(next(name_list))
  6 print(next(name_list))
  7 # print(next(name_list))
  8 
  9

生成器表达 View Code

归类: Python相关

原文地址：https://www.cnblogs.com/lz1996/p/11571632.html