装饰器，迭代器，生成器

一、装饰器

无参装饰器：

 1、示例1：

1 import time #加载时间模块 2 def war(name): #定义装饰器 3 def wari(): 4 start = time.time() #定义开始时间 5 name() #相当于执行下面的函数 6 stop = time.time() #定义结束时间 7 print("run time is %s" %(stop-start)) #给原来函数加入的新功能 8 return wari 9 @war 10 def info(): 11 time.sleep(3) 12 print('we are famly!!') 13 14 info()

执行@war的时候就表示运行了war(name)这个函数，然后把下面的函数名赋值给name，就表示info=war(info)，现在取到的只是info这个函数的内存地址，在装饰器上运行name()就相当于执行这个info()函数

示例2：

1 def war(name): 2 def wari(*args,**kwargs): 3 start = time.time() 4 name(*args,**kwargs) 5 stop = time.time() 6 print("run time is %s" %(stop-start)) 7 return wari 8 @war 9 def info(): 10 time.sleep(3) 11 print('we are famly!!') 12 13 @war 14 def auth(name,password): 15 time.sleep(2) 16 print('login success!') 17 18 @war 19 def ero(x): 20 time.sleep(1) 21 print('hello %s' %x) 22 23 info() 24 25 auth('xyy',123) 26 ero('xyp')

有参装饰器：

示例1：

1 def auth1(auth_type): 2 def auth(func): 3 def war(*args,**kwargs): 4 if auth_type == 'file': 5 name = input("username: ") 6 pwd = int(input("password: ")) 7 if name == "xyy" and pwd == 123: 8 print("login successfull!") 9 func(*args,**kwargs) 10 else: 11 print("login error!") 12 elif auth_type == 'sql': 13 print('输入错误') 14 return war 15 return auth 16 17 18 @auth1(auth_type='sql') #write=auth(write) 19 def write(): 20 print('welcome to my home!') 21 write()

 

二、迭代器
1、例子1：有下标的类型

1 l = ['a','b','c','d','e'] #定义一个列表 2 i = l.__iter__() #生成一个迭代器 3 4 while True: #循环这个生成器 5 　　try: #监听 6 　　　　print(i.__next__()) #循环取下一个值 7 except StopIteration: #监听的关键字 8 　　break #退出循环 9 10 或： 11 i = 0 12 while i < len(l): 13 　　print(l[i]) 14 　　i += 1 15 16 或： 17 for i in l: #直接循环遍历一遍 18 　　print(i) 19 20 或: 21 for i in range(len(l)): #先取下标的的长度再取对应的值 22 　　print(l[i]) 23 PS:try和except相当于一个if判断

例子2：没下标的类型

1 dic = {'a':1,'b':2,'c':3} 2 i = dic.__iter__() 3 while True: 4 　　try: 5 　　　　print(i.__next__()) 6 except StopIteration: 7　　 break

例子3：文件类型

1 with open('war.txt','r+',encoding='utf8') as f: 2 a = f.__iter__() 3 while True: 4 　　try: 5 　　　　print(a.__next__(),end='') 6 except StopIteration: 7 　　break

 

2、判断是否是可迭代和是否是迭代器：

1 from collections import Iterable,Iterator #加载模块 2 s = "xyyp" 3 l = ['a','b','c'] 4 t = (1,2,3,4) 5 d = {"s":1,"a":4} 6 f = open('war.txt') 7 （1）Iterable判断是否可迭代： 8 print(isinstance(s,Iterable)) -->True 9 print(isinstance(l,Iterable)) -->True 10 print(isinstance(t,Iterable)) -->True 11 print(isinstance(d,Iterable)) -->True 12 print(isinstance(f,Iterable)) -->True 13 （2）Iterator判断是否是迭代器： 14 print(isinstance(s,Iterator)) -->False 15 print(isinstance(l,Iterator)) -->False print(isinstance(t,Iterator)) -->False 16 print(isinstance(d,Iterator)) -->False 17 print(isinstance(f,Iterator)) -->True

PS：只有文件是可迭代对象并且是迭代器。

小结：
迭代器优点：
1，迭代器提供了一种不依赖于索引的取值方式，这样可以遍历那些没有索引的可迭代对象，比如：字典，集合，文件。
2，迭代器于列表比较，迭代器是惰性计算的，更节省内存空间。

迭代器缺点：
1，无法获取迭代器的长度，使用不如列表索引取值灵活。
2，一次性，只能往后取值，不能倒着取值

 

三、生成器和协程函数

1、生成器就是一个函数，这个函数内包含有yield这个关键字。

2、生成器和和return的区别在于return只能返回一次函数的值就结束了，yield能返回多次值。

3、yield把函数变成了生成器，生成器也就是迭代器。

示例1：

1 def count(x): #定义函数 2　　 print('start count') 3　　 while x > 0: #函数内容 4 　　yield x #返回值 5　　 x -= 1 6 print('done') 7 8 g = count(5) #执行函数 并把返回值赋给一个变量，最后生成迭代器 9 while True: #while循环迭代器 10 　　try: 11　　　　 print(next(g)) 12 except StopIteration: 13 　　break

4、协程函数：
示例1：

1 def eater(name): #定义函数 2 　　print('%s waiting food' %name) 3 　　food_list=[] #定义空列表 4 　　while True: 5 　　　　food = yield food_list #yield返回值赋值给food 6 　　　　print('%s get %s,to start eat' %(name,food)) 7 　　　　food_list.append(food) #每传入一个值添加到列表里面去 8 9 e = eater('钢蛋') #生成迭代器 10 print(next(e)) #输出迭代器内容 11 print(e.send('包子')) #send传入的值可以直接赋给yield 12 print(e.send('大葱包子')) 13 print(e.send('大蒜包子')) 14 print(e.send('韭菜包子'))

小结：
send和next()的区别：
1、如果函数内yield是表达式形式(food=yield)，那么必须先next触发函数的执行。
2、二者的共同之处都可以让函数在上一次暂停的位置继续运行，不同之处在于send在触发下一次代码的执行时，会顺便给yield传一个值。

 

四、面向过程函数编程：
示例：

1 import os #加载os模块 2 def decorate(func): #定义next装饰器 3 　　def t_layer(*args,**kwargs): 4 　　　　res = func(*args,**kwargs) 5 　　　　next(res) 6 　　　　return res 7　　 return t_layer 8 9 @decorate #调用装饰器 10 def path(target): #定义文件路径生成器 11 　　while True: 12 　　　　dir_name = yield 13 　　　　g = os.walk(dir_name) 14 　　　　for i in g: 15 　　　　　　for x in i[-1]: 16 　　　　　　　　file_path = "%s\\%s" %(i[0],x) 17　　　　　　　　 target.send(file_path) 18 19 @decorate 20 def opener(target): #定义读取文件内容的生成器 21 　　while True: 22 　　　　file_path = yield 23 　　　　with open(file_path) as f: 24 　　　　　　target.send((file_path,f)) 25 26 @decorate 27 def cat(target): #定义看文件内容的生成器 28 　　while True: 29 　　　　file_path,f = yield 30 　　　　for line in f: 31 　　　　target.send((file_path,line)) 32 33 @decorate 34 def grep(pattern,target): #定义一个过滤文件内容的生成器 35 　　while True: 36 　　　　file_path,line = yield 37 　　　　if pattern in line: 38 　　　　target.send(file_path) 39 40 @decorate 41 def printer(): #定义输出指定文件路径的生成器 42 　　while True: 43 　　　　file_path =yield 44 　　　　print(file_path) 45 46 g = path(opener(cat(grep('xlinux',printer())))) #调用生成器 47 g.send('D:\\xyyp')

优点：
　　1、体系结构更加清晰。
　　2、简化程序的复杂度。
缺点：
　　1、可扩展极其的差，所以面向过程的应用场景是：不需要经常变化的软件。

 

转载于:https://www.cnblogs.com/xyp-blog123/p/7028892.html

总结

以上是生活随笔为你收集整理的装饰器，迭代器，生成器的全部内容，希望文章能够帮你解决所遇到的问题。

如果觉得生活随笔网站内容还不错，欢迎将生活随笔推荐给好友。