装饰器，迭代器，生成器

一、装饰器

无参装饰器：

 1、示例1：

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

info()

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

示例2：

def war(name):
    def wari(*args,**kwargs):
        start = time.time()
        name(*args,**kwargs)
        stop = time.time()
        print("run time is %s" %(stop-start))
    return wari
@war
def info():
    time.sleep(3)
    print('we are famly!!')

@war
def auth(name,password):
    time.sleep(2)
    print('login success!')

@war
def ero(x):
    time.sleep(1)
    print('hello %s' %x)
    
info()

auth('xyy',123)
ero('xyp')

有参装饰器：

示例1：

def auth1(auth_type):
        def auth(func):
             def war(*args,**kwargs):
                 if auth_type == 'file':
                    name = input("username: ")
                    pwd =  int(input("password: "))
                    if name  == "xyy" and pwd == 123:
                        print("login successfull!")
                        func(*args,**kwargs)
                    else:
                        print("login error!")
                elif auth_type == 'sql':
                    print('输入错误')
           return war 
       return auth


@auth1(auth_type='sql') #write=auth(write)
def write():
print('welcome to my home!')
write()

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

l = ['a','b','c','d','e'] #定义一个列表
i = l.__iter__() #生成一个迭代器

while True: #循环这个生成器
　　try: #监听
　　　　print(i.__next__()) #循环取下一个值
except StopIteration: #监听的关键字
　　break    #退出循环

或：
i = 0
while i < len(l):
　　print(l[i])
　　i += 1

或：
for i in l: #直接循环遍历一遍
　　print(i)

或:
for i in range(len(l)): #先取下标的的长度再取对应的值
　　print(l[i])    
PS:try和except相当于一个if判断

例子2：没下标的类型

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

例子3：文件类型

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

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

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

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

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

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

三、生成器和协程函数

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

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

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

示例1：

def count(x): #定义函数
 2　　 print('start count')
 3　　 while x > 0: #函数内容
　　yield x    #返回值
 5　　 x -= 1
print('done')

g = count(5) #执行函数 并把返回值赋给一个变量，最后生成迭代器
while True:    #while循环迭代器
　　try:
11　　　　 print(next(g))
except StopIteration:
　　break

4、协程函数：
示例1：

def eater(name): #定义函数
　　print('%s waiting food' %name)
　　food_list=[] #定义空列表
　　while True:
　　　　food = yield food_list #yield返回值赋值给food
　　　　print('%s get %s,to start eat' %(name,food))
　　　　food_list.append(food) #每传入一个值添加到列表里面去

e = eater('钢蛋') #生成迭代器
print(next(e)) #输出迭代器内容
print(e.send('包子')) #send传入的值可以直接赋给yield
print(e.send('大葱包子'))
print(e.send('大蒜包子'))
print(e.send('韭菜包子'))

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

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

import os #加载os模块
def decorate(func): #定义next装饰器
　　def t_layer(*args,**kwargs):
　　　　res = func(*args,**kwargs)
　　　　next(res)
　　　　return res
 7　　 return t_layer

@decorate #调用装饰器
def path(target): #定义文件路径生成器
　　while True:
　　　　dir_name = yield
　　　　g = os.walk(dir_name)
　　　　for i in g:
　　　　　　for x in i[-1]:
　　　　　　　　file_path = "%s\%s" %(i[0],x)
17　　　　　　　　 target.send(file_path)

@decorate
def opener(target): #定义读取文件内容的生成器
　　while True:
　　　　file_path = yield
　　　　with open(file_path) as f:
　　　　　　target.send((file_path,f))

@decorate
def cat(target):    #定义看文件内容的生成器
　　while True:
　　　　file_path,f = yield
　　　　for line in f:
　　　　target.send((file_path,line))

@decorate
def grep(pattern,target): #定义一个过滤文件内容的生成器
　　while True:
　　　　file_path,line = yield
　　　　if pattern in line:
　　　　target.send(file_path)

@decorate
def printer():    #定义输出指定文件路径的生成器
　　while True:
　　　　file_path =yield
　　　　print(file_path)

g = path(opener(cat(grep('xlinux',printer())))) #调用生成器
g.send('D:\xyyp')

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