阅读目录
- 楔子
- python中的for循环
- 可迭代协议
- 迭代器协议
- 为什么要有for循环
- 初识生成器
- 生成器函数
- 列表推导式和生成器表达式
- 本章小结
- 生成器相关的面试题
楔子
假如我现在有一个列表l=['a','b','c','d','e'],我想取列表中的内容,有几种方式?
首先,我可以通过索引取值l[0],其次我们是不是还可以用for循环来取值呀?
你有没有仔细思考过,用索引取值和for循环取值是有着微妙区别的。
如果用索引取值,你可以取到任意位置的值,前提是你要知道这个值在什么位置。
如果用for循环来取值,我们把每一个值都取到,不需要关心每一个值的位置,因为只能顺序的取值,并不能跳过任何一个直接去取其他位置的值。
但你有没有想过,我们为什么可以使用for循环来取值?
for循环内部是怎么工作的呢?
python中的for循环
要了解for循环是怎么回事儿,咱们还是要从代码的角度出发。
首先,我们对一个列表进行for循环。
for i in [1,2,3,4]: print(i)
上面这段代码肯定是没有问题的,但是我们换一种情况,来循环一个数字1234试试。
for i in 1234 print(i) 结果: Traceback (most recent call last): File "test.py", line 4, in <module> for i in 1234: TypeError: 'int' object is not iterable
看,报错了!报了什么错呢?“TypeError: 'int' object is not iterable”,说int类型不是可迭代的。
什么叫迭代
现在,我们已经获得了一个新线索,有一个叫做“可迭代的”概念。
首先,我们从报错来分析,好像之所以1234不可以for循环,是因为它不可迭代。那么如果“可迭代”,就应该可以被for循环了。
这个我们知道呀,字符串、列表、元组、字典、集合都可以被for循环,说明他们都是可迭代的。
我们怎么来证明这一点呢?
from collections import Iterable l = [1,2,3,4] t = (1,2,3,4) d = {1:2,3:4} s = {1,2,3,4} print(isinstance(l,Iterable)) print(isinstance(t,Iterable)) print(isinstance(d,Iterable)) print(isinstance(s,Iterable))
结合我们使用for循环取值的现象,再从字面上理解一下,其实迭代就是我们刚刚说的,可以将某个数据集内的数据“一个挨着一个的取出来”,就叫做迭代。
可迭代协议
我们现在是从结果分析原因,能被for循环的就是“可迭代的”,但是如果正着想,for怎么知道谁是可迭代的呢?
假如我们自己写了一个数据类型,希望这个数据类型里的东西也可以使用for被一个一个的取出来,那我们就必须满足for的要求。这个要求就叫做“协议”。
可以被迭代的对象要满足的要求就叫做可迭代协议。
可迭代协议的定义非常简单,就是内部实现了__iter__方法。
接下来我们就来验证一下:
a = dir(list)
b = dir(tuple)
c = dir(dict)
d = dir(set)
e = dir(int)
print('__iter__' in a) #True
print('__iter__' in b) #True
print('__iter__' in c) #True
print('__iter__' in d) #True
print('__iter__' in e) #False
总结一下我们现在所知道的:可以被for循环的都是可迭代的,要想可迭代,内部必须有一个__iter__方法。
接着分析,__iter__方法做了什么事情呢?
print([1,2].__iter__()) #<list_iterator object at 0x00000000027C9080>
执行了list([1,2])的__iter__方法,我们好像得到了一个list_iterator,现在我们又得到了一个新名词——iterator(迭代器)。
迭代器协议
既什么叫“可迭代”之后,又一个历史新难题,什么叫“迭代器”?
虽然我们不知道什么叫迭代器,但是我们现在已经有一个迭代器了,这个迭代器是一个列表的迭代器。
我们来看看这个列表的迭代器比起列表来说实现了哪些新方法,这样就能揭开迭代器的神秘面纱了吧?
''' 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__', '__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__
在for循环中,就是在内部调用了__next__方法才能取到一个一个的值。
那接下来我们就用迭代器的next方法来写一个不依赖for的遍历。
iter1 = iter([1,2,3,4,5]) while True: try: print(next(iter1)) except StopIteration: break
迭代器遵循迭代器协议:必须拥有__iter__方法和__next__方法。
如此一来,关于迭代器和生成器的方法我们就介绍了两个,最后我们来看看range()是个啥。首先,它肯定是一个可迭代的对象,但是它是否是一个迭代器?我们来测试一下
print('__next__' in dir(range(12))) #False print('__iter__' in dir(range(12))) #True from collections import Iterator print(isinstance(range(100000000),Iterator)) #False
结果是:range对象中有__iter__方法,所以它是可迭代的;但是没有__next__方法,所以不是一个迭代器。
为什么要有for循环
基于上面讲的列表这一大堆遍历方式,聪明的你立马看除了端倪,于是你不知死活大声喊道,你这不逗我玩呢么,有了下标的访问方式,我可以这样遍历一个列表啊
l=[1,2,3] index=0 while index < len(l): print(l[index]) index+=1 #要毛线for循环,要毛线可迭代,要毛线迭代器
没错,序列类型字符串,列表,元组都有下标,你用上述的方式访问,perfect!
但是你考虑过非序列类型像字典,集合,文件对象的感受。
所以for循环就是基于迭代器协议提供了一个统一的可以遍历所有可迭代对象的方法,即在遍历之前,先调用对象的__iter__方法将其转换成一个迭代器,然后使用迭代器协议去实现循环访问,这样所有的对象就都可以通过for循环来遍历了,而且你看到的效果也确实如此,这就是无所不能的for循环。
初识生成器
我们知道的迭代器有两种:一种是调用方法直接返回的,一种是可迭代对象通过执行iter方法得到的,迭代器有的好处是可以节省内存。
如果在某些情况下,我们也需要节省内存,就只能自己写。我们自己写的这个能实现迭代器功能的东西就叫生成器。
Python中提供的生成器:
1.生成器函数:常规函数定义,但是,使用yield语句而不是return语句返回结果。yield语句一次返回一个结果,在每个结果中间,挂起函数的状态,以便下次重它离开的地方继续执行。
2.生成器表达式:类似于列表推导,但是,生成器是按需返回产生结果的一个对象,而不是一次构建一个结果列表
生成器Generator:
本质:迭代器(所以自带了__iter__方法和__next__方法,不需要我们去实现)
特点:惰性运算,开发者自定义
生成器函数
一个包含yield关键字的函数就是一个生成器函数。yield可以为我们从函数中返回值,但是yield又不同于return,return的执行意味着程序的结束。
调用生成器函数不会得到返回的具体的值,而是得到一个可迭代的对象。每一次获取这个可迭代对象的值,就能推动函数的执行,获取新的返回值。直到函数执行结束。
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
import time def genrator_fun1(): a = 1 print('现在定义了a变量') yield a b = 2 print('现在又定义了b变量') yield b g1 = genrator_fun1() print('g1 : ',g1) #打印g1可以发现g1就是一个生成器 print('-'*20) #我是华丽的分割线 print(next(g1)) time.sleep(1) #sleep一秒看清执行过程 print(next(g1))
生成器有什么好处呢?就是不会一下子在内存中生成太多数据,帮我们节省了内存!
假如我想让工厂给学生做校服,生产2000000件衣服,我和工厂一说,工厂应该是先答应下来,然后再去生产,我可以一件一件的要,也可以根据学生一批一批的找工厂拿。
而不能是一说要生产2000000件衣服,工厂就先去做生产2000000件衣服,等回来做好了,学生都毕业了。。。
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
def produce(): for i in range(1,20001): yield '第%s件衣服'%i g = produce() print(g)#要一件衣服 print(next(g))#要一件衣服 print(next(g))#再要一件衣服 print(next(g))#再要一件衣服 for x in range(5):#要一批衣服,比如5件 print(next(g)) #到这里我们找工厂拿了8件衣服,我一共让我的生产函数(也就是produce生成器函数)生产2000000件衣服。 #剩下的还有很多衣服,我们可以一直拿,也可以放着等想拿的时候再拿
更多应用
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
import time def tail(filename): with open(filename,'r',encoding='utf-8') as f: f.seek(0,2)#从文件末尾算起 while True: line = f.readline()# 读取文件中新增内容 if not line: time.sleep(0.1) continue yield line# 将非空内容添加到结果集 g = tail('a') for line in g: print(line)
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
def averager(): total = 0.0 day = 0 avg = None while True: day_num = yield avg #接收send传来的值,交给接下来的代码运行 total += day_num day += 1 avg = total/day g = averager() print(g) #g是一个生成器 print(next(g))#激活生成器 此时next(g)等价于g.send(None) print(g.send(10))#send = 传值 + next print(g.send(11)) print(g.send(12))
通过这个例子,我们知道了:send方法可以往生成器中传值,但是必须先激活。
既然生成器在调用send方法前都必须激活,我们可以定义一个装饰器统一扩展这种生成器
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
def init(func): #在调用被装饰生成器函数的时候首先用next激活生成器 def inner(*args,**kwargs): g = func(*args,**kwargs) next(g) return g return inner @init def averager(): total = 0.0 day = 0 avg = None while True: day_num = yield avg #接收send传来的值,交给接下来的代码运行 total += day_num day += 1 avg = total/day g = averager() print(g) #g是一个生成器 print(g.send(10))#send = 传值 + next print(g.send(11)) print(g.send(12))
yield from iter 等价于 for i in iter : yield i
yield from是py3新增的语法,现在简单理解为将iter中的每个元素传递给生成器的调用者
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
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()))
列表推导式和生成器表达式
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
#老男孩由于峰哥的强势加盟很快走上了上市之路,alex思来想去决定下几个鸡蛋来报答峰哥 egg_list=['鸡蛋%s' %i for i in range(1,11)] #列表解析 ['鸡蛋1', '鸡蛋2', '鸡蛋3', '鸡蛋4', '鸡蛋5', '鸡蛋6', '鸡蛋7', '鸡蛋8', '鸡蛋9', '鸡蛋10'] #峰哥瞅着alex下的一筐鸡蛋,捂住了鼻子,说了句:哥,你还是给我只母鸡吧,我自己回家下 laomuji=('鸡蛋%s' %i for i in range(10))#生成器表达式 print(laomuji)#这是一个生成器 print(next(laomuji)) #next本质就是调用__next__ print(laomuji.__next__()) print(next(laomuji))
总结:
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.提高代码可读性
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
#列表解析 sum([i for i in range(100000000)])#内存占用大,机器容易卡死 #生成器表达式 sum(i for i in range(100000000))#几乎不占内存
生成器相关的面试题
生成器在编程中发生了很多的作用,善用生成器可以帮助我们解决很多复杂的问题
除此之外,生成器也是面试题中的重点,在完成一些功能之外,人们也想出了很多魔性的面试题。
接下来我们就来看一看~
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
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))
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
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))
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
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