一、函数相关基础
1、Python是从上往下顺序执行代码，当碰到定义函数的代码块时，并不会立即执行。只有等到该函数被调用时，才会执行相应的代码块。
def foo():
print("foo函数被运行了！")
如果就这样定义了函数，foo函数里面的语句是不会执行的。
python解释器只是简单地在内存定义了一个名为foo的内存地址。
相当于：
foo = print("foo函数被运行了！")
再看看，下面的例子：
def foo():
print("我是上面的函数定义！")
def foo():
print("我是下面的函数定义!")
foo()
运行结果：
我是下面的函数定义!
可见，Python是从上往下顺序执行代码，下面的foo将上面的foo覆盖了。因此，最后执行是第二个定义的函数foo。在Python中代码的放置位置是有一定要求的，不能随意摆放，函数体要放在被调用的语句之前。
2、函数体
def foo():
print("foo函数被运行了！")
return "OK"
分别运行：
foo
foo()
函数名：foo
函数体：1-3行
返回值：字符串"OK"，如不定义，默认返回NONE
函数的内存地址:当函数体被python解释器读进内存后，它有标识符即函数名foo引用，
简单的说，foo指向的是函数体在内存中的保存位置
函数名加括号：foo()，函数的调用方法，只有见到这个括号，程序才会根据函数名从内存中找到函数体并执行。
二、装饰器
先看下面的例子：
def outer(func):
def inner():
print("我是内层函数！")
return inner
def foo():
print("我是原始函数！")
outer(foo)
outer(foo())
在python中，一切都是对象，函数也不例外。因此可以将函数名，甚至函数名加括号进行调用的方式作为另一个函数的返回值。
上面代码中，outer和foo是两个函数，outer(foo)表示将foo函数名当作参数传递给outer函数并执行outer函数；outer(foo())表示将foo函数执行后的返回值当作参数传递给outer函数并执行outer函数，由于foo函数没有指定返回值，实际上它传递给了outer函数一个None。注意其中的差别，有没有括号是关键！
同样，在outer函数内部，返回了一个inner，inner是在outer函数内部定义的一个函数，注意，由于inner后面没有加括号，所以返回的是inner的函数体，实际上也就是inner这个名字，一个简单的引用而已。
那么，如果outer函数返回的是inner()呢？现在你应该已经很清楚了，它会先执行inner函数的内容，然后返回个None给outer，outer再把这个None返回给调用它的对象。
请记住，函数名、函数加括号可以被当做参数传递，也可以被当做返回值return，有没有括号是两个截然不同的意思！
三、装饰器的使用场景
装饰器通常用于在不改变原有函数代码和功能的情况下，为其添加额外的功能。比如在原函数执行前先执行点什么，在执行后执行点什么。
软件开发中有一个原则“开放-封闭”原则，简单来说，他规定已经实现的功能代码不允许被修改，但可以被扩展，即：
- 封闭：已实现的功能代码块
- 开放：对扩展开发
有一个大公司，下属的基础平台部负责内部应用程序及API的开发
有上百个业务部门负责不同的业务，他们各自调用基础平台部提供的不同函数处理自己的业务
情况如下：
# 基础平台部门开发了上百个函数
def f1():
print("业务部门1数据接口......")
def f2():
print("业务部门2数据接口......")
def f3():
print("业务部门3数据接口......")
def f100():
print("业务部门100数据接口......")
#各部门分别调用
f1()
f2()
f3()
f100()
由于公司在创业初期，基础平台部开发这些函数时，
由于各种原因，比如时间，比如考虑不周等等，没有为函数调用进行安全认证。
现在，平台部主管决定弥补这个缺陷，于是：
def f1():
#加入认证程序代码
print("业务部门1数据接口......")
def f2():
# 加入认证程序代码
print("业务部门2数据接口......")
def f3():
# 加入认证程序代码
print("业务部门3数据接口......")
def f100():
#加入认证程序代码
print("业务部门100数据接口......")
#各部门分别调用
f1()
f2()
f3()
f100()
##########################
def login():
print("认证成功！")
def f1():
login()
print("业务部门1数据接口......")
def f2():
login()
print("业务部门2数据接口......")
def f3():
login()
print("业务部门3数据接口......")
def f100():
login()
print("业务部门100数据接口......")
#各部门分别调用
f1()
f2()
f3()
f100()
##########################
以上实现方法虽然可行，但是它对已经实现的功能代码内部进行了修改。违反了“开放-封闭”原则
再继续往下看：
def outer(func):
def inner():
print("认证成功！")
result = func()
print("日志添加成功")
return result
return inner
@outer
def f1():
print("业务部门1数据接口......")
@outer
def f2():
print("业务部门2数据接口......")
@outer
def f3():
print("业务部门3数据接口......")
@outer
def f100():
print("业务部门100数据接口......")
#各部门分别调用
f1()
f2()
f3()
f100()
对于上述代码，也是仅需对基础平台的代码进行拓展，就可以实现在其他部门调用函数 f1 f2 f3 f100 之前都进行认证操作。
在操作结束后保存日志，并且其他业务部门无需他们自己的代码做任何修改，调用方式也不用变。
分析上面的这段代码：
1、程序开始运行，从上往下读取，发现函数体并将函数体加载到内存中，然后继续往下读取。
2、读到@outer的时候，python知道@outer是个装饰器（语法糖）后，立即执行outer这个函数。
3、由于outer函数做了2件事，一是定义了inner这个函数，二是返回inner在内存中的地址。
4、由于装饰器的语法规则，被装饰的函数的名字会被当作参数传递给装饰函数。装饰函数按顺序执行自己的代码后，将它的返回值赋值给被装饰的函数。
5、执行outer函数的时候，python解释器又发现了另外一个函数inner，但是并不会马上执行inner代码块的内容。下一步，就是return inner。返回值是个函数名。由第四点得出，inner这个函数名会被复制给f1这个被装饰的函数，也就是f1 = inner。此时f1函数被新的函数inner覆盖。（即f1这个函数名的内存地址指向到inner的函数内存地址）
一个装饰器：
def deco(func):
def inner():
print("这是inner函数")
result = func()
return result
return inner
@deco
def func1():
print("这个是func1")
func1()
实际上相当于：
fun1 = deco(func1)
6、业务部门依然通过f1()的方式调用f1函数，但执行的不再是原本f1函数的代码，而是inner函数的代码。
注意：
1、@outer和@outer()是有区别的，没有括号时，outer函数依然会被执行。这和传统的用括号才能调用函数不同，需要特别注意。
2、f1这个函数名当作参数传递给装饰函数outer，func = f1，@outer等于outer(f1)，实际上传递了f1的函数体，而不是执行f1后的返回值。
3、outer函数return的是inner这个函数名，而不是inner()被调用后的返回值。
四、装饰器的参数传递
一个参数的情况：
def outer(func):
def inner(username):
print("认证成功！")
result = func(username)
print("日志添加成功")
return result
return inner
@outer
def f1(name):
print("%s 正在连接业务部门1数据接口......"%name)
# 调用方法
f1("jack")
在inner函数的定义部分也加上一个参数，调用func函数的时候传递这个参数，很好理解吧？
可问题又来了，那么另外一个部门调用的f2有2个参数呢？f3有3个参数呢？你怎么传递？
很简单，我们有*args和**kwargs嘛！号称“万能参数”！简单修改一下上面的代码：
def outer(func):
def inner(*args,**kwargs):
print("认证成功！")
result = func(*args,**kwargs)
print("日志添加成功")
return result
return inner
@outer
def f1(name,age):
print("%s 正在连接业务部门1数据接口......"%name)
# 调用方法
f1("jack",18)
五、装饰器高级用法
1、一个函数被多个装饰器装饰：
def outer1(func):
def inner(*args,**kwargs):
print("认证成功！")
result = func(*args,**kwargs)
print("日志添加成功")
return result
return inner
def outer2(func):
def inner(*args,**kwargs):
print("一条欢迎信息。。。")
result = func(*args,**kwargs)
print("一条欢送信息。。。")
return result
return inner
@outer1
@outer2
def f1(name,age):
print("%s 正在连接业务部门1数据接口......"%name)
# 调用方法
f1("jack",18)
执行结果：
认证成功！
一条欢迎信息。。。
jack 正在连接业务部门1数据接口......
一条欢送信息。。。
日志添加成功
分析：
多个装饰器：
f1 = outer1(outer2(f1))
2、带参数的装饰器：
# 认证函数
def auth(request,kargs):
print("认证成功！")
# 日志函数
def log(request,kargs):
print("日志添加成功")
# 装饰器函数。接收两个参数，这两个参数应该是某个函数的名字。
def Filter(auth_func,log_func):
# 第一层封装，f1函数实际上被传递给了main_fuc这个参数
def outer(main_func):
# 第二层封装，auth和log函数的参数值被传递到了这里
def wrapper(request,kargs):
# 下面代码的判断逻辑不重要，重要的是参数的引用和返回值
before_result = auth(request,kargs)
if(before_result != None):
return before_result;
main_result = main_func(request,kargs)
if(main_result != None):
return main_result;
after_result = log(request,kargs)
if(after_result != None):
return after_result;
return wrapper
return outer
# 注意了，这里的装饰器函数有参数哦，它的意思是先执行filter函数
# 然后将filter函数的返回值作为装饰器函数的名字返回到这里，所以，
# 其实这里，Filter(auth,log) = outer , @Filter(auth,log) = @outer
@Filter(auth,log)
def f1(name,age):
print("%s 正在连接业务部门1数据接口......"%name)
# 调用方法
f1("jack",18)
运行结果：
认证成功！
jack 正在连接业务部门1数据接口......
日志添加成功
分析：
带参数的装饰器：
f1 = Filter(auth,log)(f1)
3、带有参数的多个装饰器：
带有参数的多个装饰器：
@deco1(deco_arg)
@deco2()
def foo():
pass
实际上相当于：
def foo():
pass
foo = deco1(deco_arg)(deco2(foo))
分析：
带有参数的多个装饰器：
deco1接受参数deco_arg，处理完成后的结果作为装饰器去装饰deco2(foo)