在学习 Python 的时候，庆幸自己有 JavaScript 的基础，在学习过程中，发现许多相似的地方，如导包的方式、参数解包、lambda 表达式、闭包、引用赋值、函数作为参数等。
装饰器是 Python 语言中的一个重点，要学习装饰器的使用，应该首先从闭包看起，以掌握装饰器的基本原理。
词法作用域
闭包是函数能够访问并记住其所在的词法作用域，由于 Python 和 JavaScript 都是基于词法作用域的，所以二者闭包的概念是共通的。
为了说明 Python 是基于词法作用域，而不是动态作用域，我们可以看下面的例子：
def getA():
return a
def test():
a = 100
print(getA())
test()
运行结果为：
Traceback (most recent call last):
File "C:\Users\Charley\Desktop\py\py.py", line 8, in <module>
test()
File "C:\Users\Charley\Desktop\py\py.py", line 6, in test
print(getA())
File "C:\Users\Charley\Desktop\py\py.py", line 2, in getA
return a
NameError: name 'a' is not defined
报错了~我们再在 getA 函数所在的作用域声明一个变量 a：
def getA():
return a
a = 10010
def test():
a = 100
print(getA())
test()
运行结果为：
10010
这里输出了 10010 ，说明 getA 函数是依赖于词法作用域的，其作用域在函数定义伊始就决定的，其作用域不受调用位置的影响。
理解了词法作用域，就理解了闭包。
闭包
前面说到过：闭包是函数能够访问并记住其所在的词法作用域的特性。那么只要函数拥有这个特性，这个函数就是一个闭包，理论上，所有函数都是闭包，因为他们都可以访问其所在的词法作用域。像这样的函数也是一个闭包：
a = 100
def iAmClosure():
print(a)
iAmClosure()
理论上是如此，但在实际情况下，闭包的定义要复杂一点点，但仍然基于前面的理论：如果一个函数（外层函数）中返回另外一个函数（内层函数），内层函数能够访问外层函数所在的作用域，这就叫一个闭包。
下面是一个例子：
def outer():
a = 100
def inner():
print(a)
return inner
outer()()
运行结果如下：
100
如上所示，inner 函数就是一个闭包。
闭包中调用参数函数
同 JavaScript，Python 中也可以将函数作为参数传递，由于 Python 是引用传值，因此实际上传入的参数并不是原始函数本身，而是原始函数的一个引用。基于闭包的特性，我们也可以在闭包中访问（或者说调用）这个函数：
def outer(fn):
def inner():
# 闭包能够访问并记住其所在的词法作用域
# 因此在闭包中可以调用 fn 函数
fn()
return inner
def test():
print("We will not use 'Hello World'")
ret = outer(test)
ret()
运行结果：
We will not use 'Hello World'
装饰器引入
认识了闭包，就可以来说一说装饰器了。想象有这么一种需求：
你所在的公司有一些核心的底层方法，后来公司慢慢壮大，增加了其他的部门，这些部门都有自己的业务，但它们都会使用这些核心的底层方法，你所在的部门也是如此。
有一天，项目经理找到你，让你在核心代码的基础上加一些验证之类的玩意，但是不能修改核心代码（否则会影响到其他的部门），你该怎么做呢？
首先你可能想到这种方式：
def core():
pass
def fixCore():
doSometing()...
core()
fixCore()
通过一个外层函数将 core 函数进行包装，在执行了验证功能后再调用 core 函数。
这时项目经理又说了，你不能改变我们的调用方式呀，我们还是想以 core 的方式进行调用，于是你又修改了代码：
def core():
pass
tmp = core;
def fixCore():
tmp()
core = fixCore
core()
通过临时函数 tmp 交换了 core 和 fixCore，狸猫换太子。这下就可以愉快的直接使用 core 了。
这是项目经理又说了，我们需要对多个核心函数进行包装，总不能全部使用变量交换吧，并且这样很不优雅，再想想其他的办法？
好吧，要求真多！于是你想啊想，想到了闭包的方式：将需要包装的函数作为参数传入外层函数，外层函数返回一个内层函数，该函数在执行一些验证操作后再调用闭包函数。这样做的好处是：
- 可以对任意函数进行包装，只要将函数作为参数传入外层函数
- 可以在执行外层函数时对返回值进行任意命名
你写的代码是这个样子的：
# 外层函数，接收待包装的函数作为参数
def outer(fn):
def inner():
doSometing()...
fn()
return inner
# 核心函数1
def core1():
pass
# 核心函数2
def core2():
pass
# core1 重新指向被包装后的函数
core1 = outer(core1)
# core2 重新指向被包装后的函数
core2 = outer(core2)
# 调用核心函数
core1()
core2()
大功告成！简直完美。同时恭喜你，你已经实现了一个装饰器，装饰器的核心原理就是：闭包 + 函数实参。
Python 原生装饰器支持
在上面你已经实现了一个简单的装饰器，也知道了装饰器的基本原理。其实，在 Python 语言中，有着对装饰器的原生支持，但核心原理依旧不变，只是简化了一些我们的操作：
# 外层函数，接收待包装的函数作为参数
def outer(fn):
def inner():
print("----验证中----")
fn()
return inner
# 应用装饰器
@outer
# 核心函数1
def core1():
print("----core1----")
# 应用装饰器
@outer
# 核心函数2
def core2():
print("----core2----")
core1()
core2()
运行结果如下：
----验证中----
----core1----
----验证中----
----core2----
Python 原生的装饰器支持，省去了传参和重命名的步骤，应用装饰器时，会将装饰器下方的函数（这里为 core1 和 core2）作为参数，并生成一个新的函数覆盖原始的函数。
装饰器函数的执行时机
装饰器函数（也就是我们前面所说的外层函数）在什么时候执行呢？我们可以进行简单的验证：
def outer(fn):
print("----正在执行装饰器----")
def inner():
print("----验证中----")
fn()
return inner
@outer
def core1():
print("----core1----")
@outer
def core2():
print("----core2----")
运行结果为：
----正在执行装饰器----
----正在执行装饰器----
这里我们并没有直接调用 core1 和 core2 函数，装饰器函数执行了。也就是说，解释器执行过程中碰到了装饰器，就会执行装饰器函数。
多重装饰器
我们也可以给函数应用多个装饰器：
def outer1(fn):
def inner():
print("----outer1 验证中----")
fn()
return inner
def outer2(fn):
def inner():
print("----outer2 验证中----")
fn()
return inner
@outer2
@outer1
def core1():
print("----core1----")
core1()
运行结果如下：
----outer2 验证中----
----outer1 验证中----
----core1----
从输出效果中可以看到：装饰器的执行是从下往上的，底层装饰器执行完成后返回函数再传给上层的装饰器，以此类推。
给被装饰函数传参
如果我们需要给被装饰函数传参，就需要在装饰器函数返回的 inner 函数上做文章了，让其代理接受被装饰器函数的参数，再传递给被装饰器函数：
def outer(fn):
def inner(*args,**kwargs):
print("----outer 验证中----")
fn(*args,**kwargs)
return inner
@outer
def core(*args,a,b):
print("----core1----")
print(a,b)
core(a = 1,b = 2)
运行结果为：
----outer 验证中----
----core1----
1 2
这里提一下 参数解包的问题：在 inner 函数中的 * 和 ** 表示该函数接受的可变参数和关键字参数，而调用参数函数 fn 时使用 * 和 ** 表示对可变参数和关键字参数进行解包，类似于 JavaScript 中的扩展运算符 ...。如果直接将 args 和 kwargs 作为参数传给被装饰函数，那么被装饰函数接收到的只是一个元组和字典，所以需要在解包后传入。
对有返回值的函数进行包装
如果被包装函数有返回值，如何在包装获取返回值呢？先看一下下面的例子：
def outer(fn):
def inner():
print("----outer 验证中----")
fn()
return inner
@outer
def core():
return "Hello World"
print(core())
运行结果为：
----outer 验证中----
None
为什么函数执行的返回值是 None 呢？不应该是 Hello World 吗？这是因为装饰的过程其实是引用替换的过程，在装饰之前，core 变量指向其自初始的函数体，在装饰后就重新进行了指向，指向到了装饰器函数所返回的 inner 函数，我们没有给 inner 函数定义返回值，自然在调用装饰后的 core 函数也是没有返回值的。为了让装饰后的函数仍有返回值，我们只需让 inner 函数返回被装饰前的函数的返回值即可：
def outer(fn):
def inner():
print("----outer 验证中----")
return fn()
return inner
@outer
def core():
return "Hello World"
print(core())
运行结果如下：
----outer 验证中----
Hello World
装饰器的参数
有时候我们想要根据不同的情况对函数进行装饰，可以有以下两种处理方式：
- 定义多个不同条件下的装饰器，根据条件应用不同的装饰器
- 定义一个装饰器，在装饰器内部根据条件的不同进行装饰
第一种方法很简单，这里说一下第二种方式。
要在装饰器内部对不同条件进行判断，我们就需要一个或多个参数，将参数传入：
# main 函数接受参数，根据参数返回不同的装饰器函数
def main(flag):
# flag 为 True
if flag:
def outer(fn):
def inner():
print("立下 Flag")
fn()
return inner
return outer
# flag 为 False
else:
def outer(fn):
def inner():
print("Flag 不见了！")
fn()
return inner
return outer
# 给 main 函数传入 True 参数
@main(True)
def core1():
pass
# 给 main 函数传入 False 参数
@main(False)
def core2():
pass
core1()
core2()
运行结果如下：
立下 Flag
Flag 不见了！
上面我们根据给 main 传入不同的参数，对 core1 和 core2 函数应用不同的装饰器。这里的 main 函数并不是装饰器函数，其返回值才是装饰器函数，我们是根据 main 函数的返回值对目标函数进行装饰的。
类作为装饰器
除了函数，类也可以作为装饰器，在说类作为装饰器之前，首先需要了解 __call__ 方法。
__call__ 方法
我们创建的实例也是可以调用的， 调用实例对象将会执行其内部的 __call__ 方法，该方法需要我们手动实现，如果没有该方法，实例就不能被调用：
class Test(object):
def __call__(self):
print("我被调用了呢")
t = Test()
t()
运行结果：
我被调用了呢
类作为装饰器
我们已经知道对象的 __call__ 方法在对象被调用时执行，其实类作为装饰器的结果就是将被装饰的函数指向该对象，在调用该对象时就会执行对象的 __call__ 方法，要想让被装饰的函数执行 __call__ 方法，首先会创建一个对象，因此会连带调动 __new__ 和 __init__ 方法，在创建对象时，test 函数会被当做参数传入对象的 __init__ 方法。
class Test(object):
# 定义 __new__ 方法
def __new__(self,oldFunc):
print("__new__ 被调用了")
return object.__new__(self)
# 定义 __init__ 方法
def __init__(self,oldFunc):
print("__init__ 被调用了")
# 定义 __call__ 方法
def __call__(self):
print("我被调用了呢")
# 定义被装饰函数
@Test
def test():
print("我是test函数~~")
test()
运行结果：
__new__ 被调用了
__init__ 被调用了
我被调用了呢
保存原始的被装饰函数
装饰后的 test 函数指向了新建的对象，那么有没有办法保存被装饰之前的原始函数呢？通过前面我们已经知道，在新建对象的时候，被装饰的函数会作为参数传入 __new__ 和 __init__ 方法，因此我们可以在这两个方法中获取原始函数的引用：
class Test(object):
# 定义 __new__ 方法
def __new__(self,oldFunc):
print("__new__ 被调用了")
return object.__new__(self)
# 定义 __init__ 方法
def __init__(self,oldFunc):
print("__init__ 被调用了")
self.__oldFunc = oldFunc
# 定义 __call__ 方法
def __call__(self):
print("我被调用了呢")
self.__oldFunc()
# 定义被装饰函数
@Test
def test():
print("我是test函数~~")
test()
运行结果如下：
__new__ 被调用了
__init__ 被调用了
我被调用了呢
我是test函数~~
总结
本文主要讲到了 Python 中闭包和装饰器的概念，主要有以下内容：
- Python 是基于词法作用域
- 闭包是函数能记住并访问其所在的词法作用域
- 利用礼包实现简单的装饰器
- Python 原生对装饰器的支持
- 给函数应用多个装饰器
- 如何给被装饰函数传参
- 如何给有返回值的函数应用装饰器
- 如何根据不同条件为函数应用不同的装饰器
- 类作为装饰器的情况以及
__call__方法
完。
网友评论