一、装饰器
无参装饰器：
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、可扩展极其的差，所以面向过程的应用场景是：不需要经常变化的软件。
