装饰器：
学前必备知识：
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'