python之路第五篇之装饰器:（进阶篇）

gggggds

装饰器：

学前必备知识：
　　

def f1():　　print "f1"
　　
　　
f1() #表示函数执行
　　
f1   #表示函数，指向内存地址
　　
　　
f1 = lambda x: x + 1
　　
f1() # 执行这个lambda表达式，而不再是原来的f1函数，因为函数f1被重新定义了
　　

装饰器代码剖析：
　　假如有这么一个需求，公司临时规定将某块业务加上访问权限，因为代码太多，又不想改变原有已经封装好的
　　
代码，于是乎，基础平台的同志们想出了这么一个解决办法：利用装饰器解决
　　那么什么是装饰器？这个问题先留着，直接看代码：(代码剖析：)
　　

def auth_login(func):    # func = f1 ，func() = f1()　　def inner():
　　print "welcome to login ..."     #验证的内容加在这里
　　func()           # func() = f1() #相当于执行f1()
　　reture inner         # 返回 inner函数体
　　
　　
def f1():
　　#print "welcome to login ..."  #需求是在这块加上验证(那么怎么实现？)
　　print "f1..."
　　
　　
result = auth_login(f1)            #等于inner函数（包括它下面那一段代码）
　　
f1 = result
　　
f1()  #函数执行
　　

上面代码梳理：
　　基础平台代码：（在业务平台不需要修改调用方式的时候，直接调用基础平台这块代码）
　　bash.py #代码名称
　　

#!/usr/bin/env python　　
#-*- coding:utf-8 -*-
　　
def auth_login(func):
　　def inner():
　　print "auth user ..."  # 认证模块
　　func()
　　return inner
　　

　　
@auth_login  #@auth_login 是python默认封装好的一种方法，#相当于 result=auth_login(f1) # f1() = result(）#（和上面的执行效果一样）            
　　
def f1():
　　print "I'm f1"
　　

　　
def f2():
　　print "I'm f2"
　　

　　
f1()  #函数执行，这个是属于业务部门来调用执行的，单独拿出来调用，如下：
　　

　　业务部门调用bash.py函数下的某个方法：
　　yw.py #业务程序名称
　　

#!/usr/bin/env python　　#-*- coding:utf-8 -*-
　　import bash
　　bash.f1()  #调用bash.f1 方法
　　
　　

　　执行业务程序 yw.py 结果如下：
　　

auth user ...　　
I'm f1
　　
　　

　　显然上面已经达到我们的需求了，@auth_login 就是我们的装饰器，上面的列子就是对它使用的
　　
其中一种方式；
　　那么问题来了：如果平台需要再调用基础平台的 f2 方法，并且还是带参数的”传入参数“的方法去调用，
　　
显然上面的程序已经不再满足需求了；
　　那么我们可以不可以这么做？就是我们再另外定义另外一个装饰器，而这个装饰器是可以接受参数的；

代码如下：
　　bash.py #代码名称
　　

def auth_login(func):　　
def inner():
　　print "auth user ..."
　　func()
　　
return inner
　　

　　
def auth_arg_login(func):   #这块代码是新加入的，传入参数
　　def inner(arg):         #参数
　　print "auth user arg ..."
　　func(arg)
　　return inner
　　

　　

　　
@auth_login
　　
def f1():
　　print "I'm f1"
　　

　　
@auth_arg_login   # 调用新装饰器
　　
def f2(arg):      #参数
　　print "I'm f2",arg
　　

　　业务部门再次调用bash.py函数下的方法：
　　
yw.py #业务程序名称
　　

#!/usr/bin/env python　　#-*- coding:utf-8 -*-
　　import bash
　　base.f1()
　　base.f2(”new programs")  # 传入参数
　　

　　执行业务程序 yw.py 结果如下：
　　

auth user ...　　
I'm f1
　　
auth user arg ...    #这块输出
　　
I'm f2 new programs  #这块输出
　　
　　

　　这个时候，需求又变了，业务部门说，我们需要传递2个参数，于是乎，基础平台啪啪啪，又写了几个方法，
　　
又实现了，过了一段时间，业务平台的同志来的时候说了一句话，兄弟，不好意思，我还需要传递几个参数，
　　
这个时候基础平台的同志发现自己快疯了，CTO 老大看不下去了，这个时候，他告诉基础平台这么一个方法，
　　
也就是下面的代码（传递动态参数）
　　bash.py #代码名称
　　

#!/usr/bin/env python　　
#-*- coding:utf-8 -*-
　　
def auth_login(func):
　　def inner(*arg,**kwagrs):   #动态参数
　　print "auth user ..."    #认证模块
　　func(*arg,**kwargs)     #动态参数
　　return inner
　　

　　
@auth_login  #在函数上面加上这么一句 @auth_login： 这个是python默认封装好的一种方法，
　　#相当于 result = auth_login(f1) # f1() = result(）
　　#（和上面的执行效果一样）            
　　
def f1(arg):
　　print "I'm f1",arg
　　

　　业务部门调用bash.py函数下的某个方法：
　　yw.py #业务程序名称
　　

#!/usr/bin/env python　　#-*- coding:utf-8 -*-
　　import bash
　　bash.f1('test')  #调用bash.f1 方法
　　
　　

　　执行业务程序 yw.py 结果如下：
　　

auth user ...　　
I'm f1 test  # 执行结果
　　

装饰器总结：
　　

1.装饰器是一个函数　　
2. 执行auth_login 函数，被装饰的函数作为参数auth_login(f1) auth_login 函数的返回值，
　　
赋值给被装饰的函数的函数名
　　

　　
@auth_login
　　
def f1():
　　pass
　　

　　
3.动态参数，可以装饰含有n个参数的函数
　　
4.函数返回值
　　
5.多装饰器
　　
6.至少3层，3层的如何使用？
　　
@auth_login
　　1.执行auth_login函数
　　2.将auth_login函数的返回值给赋值给被装饰器的函数的函数名
　　
@auth_login(arg)
　　1.执行auth_login函数，得到返回值，result
　　2.创建装饰器，@ + result结合：@result
　　3...
　　1).执行result 函数
　　2).将result函数的返回值给被装饰器的函数的函数名
　　

装饰器返回值（return）：

获取主机列表：
　　bash.py #代码名称
　　

def auth_login(func):　　def inner(*arg,**kwargs)
　　print "welcome to login..."
　　temp = func(*arg,**kwargs)
　　print "login after..."
　　return temp
　　return inner
　　
　　
@auth_login
　　
def fetch_server_list():
　　server_list = ['server1','server2','server3']
　　return server_list
　　

　　执行业务程序 yw.py 结果如下：
　　

import base　　
server_list = base.fetch_server_list('test')
　　
print server_list
　　

　　程序执行结果：
　　

welcome to login...　　
login after...
　　
['server1', 'server2', 'server3']
　　

　　上面的列子说了这么多，好，现在我们来做一个用户登陆验证：
　　

def login():   # 这里定义一个login 函数　　name = "Allen"   # 如果这里是“Allen“，则下面的函数调用，验证成功，否则失败
　　if name == "Allen":
　　return True
　　else:
　　return False
　　

　　
def auth_login(func):
　　def inner(*arg,**kwargs):  
　　is_login = login()    #这里加入一个验证判断
　　if not is_login:
　　print "非法用户"
　　

　　print "welcome to login..."
　　temp = func(*arg,**kwargs)
　　print "login after..."
　　return temp
　　return inner
　　

　　
@auth_login
　　
def fetch_server_list(arg):
　　server_list = ['server1','server2','server3']
　　return server_list
　　

　　执行业务程序 yw.py 结果如下：
　　

import base　　
server_list = base.fetch_server_list('test')
　　
print server_list
　　

函数执行结果：
　　

welcome to login...　　
login after...
　　
['server1', 'server2', 'server3']
　　

　　如果name = ”aaaa“, 不是”Allen“，则执行结果：验证失败：
　　

非法用户　　
welcome to login...
　　
login after...
　　
['server1', 'server2', 'server3']
　　

　　那么又有人问，这个有个鸟用，我还需要密码验证，那么这个怎么做呢？
　　
少废话，直接上代码：
　　

def login(key):　　local_key = "123456"   #这里做个一个key验证
　　if local_key == key:
　　return True
　　else:
　　return False
　　
　　
　　
def auth_login(func):
　　def inner(*arg,**kwargs):
　　#key = kwargs['token']     #注意这里
　　#del kwargs['token']
　　key = kwargs.pop('token')  #这一句等于 上面注释的两句 #这句含义：因为下面的login 只接受一个参数，这里多一个参数，所有删除
　　is_login = login(key)      #注意这里
　　if not is_login:
　　print "非法用户"
　　
　　print "welcome to login..."
　　temp = func(*arg,**kwargs)
　　print "login after..."
　　return temp   
　　return inner
　　
　　
@auth_login
　　
def fetch_server_list(arg):
　　server_list = ['server1','server2','server3']
　　return server_list
　　

　　执行业务程序 yw.py 结果如下：
　　

import base　　
server_list = base.fetch_server_list('test'，token=‘key1111’)  #注意这里
　　
print server_list
　　

多装饰器：
　　

@auth_login　　
@auth_login
　　
def f1():
　　pass
　　
　　
执行的结果：
　　
就是一层套一层
　　

　　双装饰用途：
　　

双层装饰器，可以用在以下途径：　　
比如用户权限管理，第一层装饰器用于用户名密码验证，
　　
第二层用在 判断用户是什么身份的用户，比如：普通用户，超级用户等
　　

需求：
　　需求又来了，在上面获取 fetch_server_list 之前执行一个函数，
　　
可不可以在fetch_server_list 之后再执行一个函数？

作业1：
　　将如下三层装饰器用语言解释一遍：
　　

#!/usr/bin/env python　　
#coding:utf-8
　　
　　
def Before(request,kargs):
　　print 'before'
　　
　　
def After(request,kargs):
　　print 'after'
　　
　　
　　
def Filter(before_func,after_func):
　　def outer(main_func):
　　def wrapper(request,kargs):
　　
　　before_result = before_func(request,kargs)
　　if(before_result != None):
　　return before_result;
　　
　　main_result = main_func(request,kargs)
　　if(main_result != None):
　　return main_result;
　　
　　after_result = after_func(request,kargs)
　　if(after_result != None):
　　return after_result;
　　
　　return wrapper
　　return outer
　　
　　
@Filter(Before, After)
　　
def Index(request,kargs):
　　print 'index'
　　

　　更多链接：http://www.cnblogs.com/wupeiqi/articles/4980620.html