装饰器，迭代器与生成器
装饰器
从一个简单的计时功能来了解装饰器的功能与基本概念。
import time def foo(): time.sleep(2) print("Hello world!") foo()
这是一个简单的打印延时程序，现在想要计算出程序运行的过程用了多长时间，并且不改动源代码，这时候就需要使用装饰器来完成需求了。
import time def timmer(func): def wrapper(): """计时功能""" time_start=time.time() func() time_end=time.time() print("Run time is %s "%(time_end-time_start)) return wrapper @timmer def foo(): time.sleep(2) print("Hello world!") foo()
在这个函数中，只是加入了一个@timmer就使得没有更改原程序代码而直接增加了一个计时的功能，这真的是有些神奇呢，那这个所谓的装饰器是怎样工作的呢？
@timmer其实是调用装饰器的语法，在调用前我们必须遵守先定义再调用的原则，@timmer其实相当于foo=timmer（foo），程序运行timmer函数，将foo作为参数func，定义函数wrapper并返回wrapper的地址空间，运行foo（）其实就是运行了wrapper，而wrapper中的func（）就是foo（），运行前后的时间差打印出来，就是我们要的计时功能了。
因为这里我们定义的foo()是一个无参函数，无需传递参数，当我们需要传递参数时，则需要将wrapper后加入动态参数*args，**kwargs来接收传入的参数。
有参装饰器
def auth(func): def wrapper(*args, **kwargs): username = input("Please input your username:") passwd = input("Please input your password：") if passwd == '123' and username == 'jeff': print("Login successful") func() else: print("login error!") return wrapper @auth def index(): print("Welcome to China") index()
这里有一个登录的装饰器，当我们需要使函数中认证的信息存放在多种途径，并且再认证前确认认证信息，那么我们这个函数主体就需要加入一个参数存放认证途径，并且装饰器也需要传递参数，这个时候，我们把函数改为
def auth(filetype): def auth2(func): def wrapper(*args,**kwargs): if filetype == "file": username=input("Please input your username:") passwd=input("Please input your password：") if passwd == '123' and username == 'jeff': print("Login successful") func() else: print("login error!") if filetype == 'SQL': print("No SQL") return wrapper return auth2 @auth(filetype='file') def index(): print("welcome") index()
@auth(filetype='file') 就是运行auth函数，将filetype参数传进auth的参数，并且运行auth返回auth2的地址，函数等同运行index=auth2（index），并且附带了外层filetype的参数，auth2（index）返回wrapper后执行wrapper，判断filetype，然后登陆。
这样就是的参数传进了装饰器内部。这就是有参装饰器。
当一个函数有多个装饰器时，
@ccc @bbb @aaa def func() pass func=ccc(bbb(aaa(func)))
# @ccc('c')
# @bbb('b')
# @aaa('a')
# def func():
# pass
#
# func=ccc('c')(bbb('b')(aaa('a')(func)))
迭代器
在了解迭代器之前，首先要知道可迭代对象的概念，在python中可以调用__iter__()对象那就是可迭代对象，调用iter方法就变成一个迭代器，可以调用__next__()就是一个迭代器，__next__()用于迭代器取值。
当next超出迭代器的范围时，python解释器会提示stopiteration，可以使用以下方式解决。
try: pass expect StopIteration: break
或者我们还可以使用for循环遍历迭代器，for循环其实就是将对象转化为迭代器再遍历，并且自动完成不会提示stopiteration。
迭代器的优缺点：
优点：
迭代器提供了一种不依赖于索引的取值方式，这样就可以遍历那些没有索引的可迭代对象了（字典，集合，文件），
迭代器是惰性计算，每next一次就出一个值，这样更节省内存空间。
缺点：
在运行完以前无法获取迭代器的长度，没有列表灵活，
只能往后取值，不能倒着取值。
可以使用内置函数isinstance来判断是否可迭代。
from collections import Iterable,Iterator isinstance(*,iterable) isinstance(*,iterator)
生成器
函数体中有yield就是一个生成器。
生成器的本质是一个迭代器，所以迭代器的操作也适用于生成器。
yield与return不同的是，return返回第一个值（元组也是一个整体）函数就结束了，但是yield可以返回多个值，在生成器函数中，每次执行到yield函数就暂停了，需要使用next去触发执行下一步。yield保留了暂停的状态，收到next触发会运行直到下一个yield停下，保留当前位置状态。
def test(): print('one') yield 1 #return 1 print('two') yield 2 #return 2 print('three') yield 3 #return 2 print('four') yield 4 #return 2 print('five') yield 5 #return 2 g=test() for i in g: print(i)
生成器的小应用
import time def tail(file_path): with open(file_path,'r') as f: f.seek(0,2) while True: line=f.readline() if not line: time.sleep(0.3) continue else: # print(line) yield line g=tail('/tmp/a.txt') for line in g: print(line)
协程函数
def eater(name): print('%s start to eat food'%name) while True: food=yield print('%s get %s ,to start eat'%(name,food)) print('done') e=eater('xx') next(e) e.send('egg') e.send('food')
先定义一个协程函数，将yield作为参数赋值给food，next()协程函数就是初始化此函数，将函数运行到yield处停止住，然后使用send方法将值传给变量food，并同时执行一次next()。
也就是说yield如果是表达式形式，执行前必定先next()，send与next当可以让函数在上一次暂停的位置继续运行，但是只有send可以在触发运行前给yield传一个值。
总结一下yield的功能，1.相当于将__iter__和__next__方法封装到函数内部，2.与return相比，yield可返回多次值，3.函数暂停已经继续运行的状态是通过yield保存的。
协程函数每次使用前都要初始化，所以可以使用装饰器完成初始化。
def init(func): def wrapper(*args,**kwargs): res=func(*args,**kwargs) next(res) return res return wrapper @init #eater=init(eater) def eater(name): print('%s start to eat' % name) food_list=[] while True: food = yield food_list print('%s eat %s' % (name, food)) food_list.append(food) e = eater('zhejiangF4') #wrapper('zhengjiangF4') print(e.send('123')) print(e.send('123'))
from urllib.request import urlopen def get(): while True: url=yield res=urlopen(url).read() print(res) g=get() next(g) g.send('http://www.python.org')
#找出目录下所有文件里写有python的文件名 #grep -rl 'python' C:\egon #-*-coding=utf-8-*- import os,time def init(func): def wrapper(*args,**kwargs): res=func(*args,**kwargs) next(res) return res return wrapper #找到一个绝对路径，往下一个阶段发一个 @init def search(target): '找到文件的绝对路径' while True: dir_name=yield #dir_name='C:\\egon' print('车间search开始生产产品：文件的绝对路径') time.sleep(2) g = os.walk(dir_name) for i in g: # print(i) for j in i[-1]: file_path = '%s\\%s' % (i[0], j) target.send(file_path) @init def opener(target): '打开文件，获取文件句柄' while True: file_path=yield print('车间opener开始生产产品：文件句柄') time.sleep(2) with open(file_path) as f: target.send((file_path,f)) @init def cat(target): '读取文件内容' while True: file_path,f=yield print('车间cat开始生产产品：文件的一行内容') time.sleep(2) for line in f: target.send((file_path,line)) @init def grep(pattern,target): '过滤一行内容中有无python' while True: file_path,line=yield print('车间grep开始生产产品：包含python这一行内容的文件路径') time.sleep(0.2) if pattern in line: target.send(file_path) @init def printer(): '打印文件路径' while True: file_path=yield print('车间printer开始生产产品：得到最终的产品') time.sleep(2) print(file_path) g=search(opener(cat(grep('py',printer())))) g.send('C:\\egon') g.send('D:\\dir1') g.send('E:\\dir2')
import os g=os.walk('C:\\egon') for i in g: # print(i) for j in i[-1]: file_path='%s\\%s' %(i[0],j) print(file_path)
g=os.walk('C:\\egon') l1=['%s\\%s' %(i[0],j) for i in g for j in i[-1]] print(l1)
列表解析一次性将所有值都读取到列表。
l=['egg%s' %i for i in range(100)] print(l)
使用生成器可以减少内存一次只拿一个值。
g=l=('egg%s' %i for i in range(10000000000000000000)) print(g) for i in g: print(i)
读大文件时使用这种方法很节约空间。
总的来说：
1、把列表解析的[]换成()得到的就是生成器表达式，
2、列表解析与生成器表达式都是一种便利的编程方式，只不过生成器表达式更节省内存，
3、Python不但使用迭代器协议，让for循环变得更加通用。大部分内置函数，也是使用迭代器协议访问对象的。例如， sum函数是Python的内置函数，该函数使用迭代器协议访问对象，而生成器实现了迭代器协议，所以，我们可以直接这样计算一系列值的和。
迭代器转化为列表：
l=list(g)#g是迭代器 print(l)
