装饰器学习（1）------12步搞懂装饰器

1. 函数

在python中，函数通过def关键字、函数名和可选的参数列表定义。通过return关键字返回值。我们举例来说明如何定义和调用一个简单的函数。

# ***************  1 function  函数 ***************
def foo():
    a=5
    return a

if __name__=="__main__":
    s=foo()
    print(s)

输出5。方法体（函数体）是必须的，调用的时候在方法体后面加上（）。

2. 作用域

在python中，函数会创建一个新的作用域。意味着在函数内部碰到一个变量的时候函数会优先在自己的作用域里面去寻找。让我们写一个简单的函数看一下 本地作用域 和 全局作用域有什么不同：

# ***************  2 scope  作用域  ***************
a = "This is a global variable."

def foo():
    a=5
    return a

if __name__=="__main__":
    s=foo()
    print(s)

输出的是5，而不是一个字符串。如果不明白，我们再看下面的例子：

# # ***************  2 scope  作用域  ***************
a = "This is a global variable."

def foo():
    print(locals())

if __name__=="__main__":
    print(globals())
    foo()

第一个globals()返回的是python解释器所知道的所有变量名称的字典，大概如下的这样：

{'__name__': '__main__',

 '__doc__': None, 

'__package__': None,

 '__builtins__': <module 'builtins' (built-in)>, 

'__file__': 'C:/Users/zhangping/Desktop/decorator/decorator.py',

 'a': 'This is a global variable.', 

'foo': <function foo at 0x000002C020EF2E18>}

而第二个locals()返回的是函数foo内部的作用域中所有的变量名称的字典。

3. 变量解析规则

在python的作用域规则里面，一定会在当前作用域（命名空间）里创建一个变量，但是访问或者修改变量时会先在当前作用域查找变量，没有找到匹配变量的话会依次向上在闭合的作用域里面进行查看找。所以如果我们修改函数foo的实现让它打印全局的作用域里的变量也是可以的：

# # ***************  3 变量解析规则  ***************
a = "This is a global variable."
b = "This is also a global variable."
c = "This is also also a global variable."
def foo():
    b="test"
    global c
    c="zhangping"
    print(a)
    print(b)
    print(c)

if __name__=="__main__":
    foo()
    print(a)
    print(b)
    print(c)

python对于变量a，首先在自己内部函数中找，找不到，所以就会输出a的本身，然后找到了b，这个b是foo函数内部新建的，和外部的b无关，因此打印出的是“test”，然后是c，c被标记成为了全局变量，意味着c永远是随着函数的更改而更改（这点和a不一样，a如果要在函数内修改，则必须重新定义一个变量，就不再是原来的a了，故在函数内，a只能是只读的）。在main函数内，打印a和b都是一开始定义的全局变量，而c被修改了。

This is a global variable.
test
zhangping
This is a global variable.
This is also a global variable.
zhangping

4. 变量生存周期

值得注意的一个点是，变量不仅是生存在一个个的命名空间内，他们都有自己的生存周期，请看下面这个例子：

#  ***************  4 变量生存周期  ***************
def foo():
    x=1

if __name__=="__main__":
    foo()
    print(x)

不出所料会报错，因为x这个变量作用域就是在foo函数内部，所以其生命周期在foo函数调用结束就结束了。一句话：函数的命名空间随着函数调用开始而开始，结束而销毁。

Traceback (most recent call last):
  File "C:/Users/zhangping/Desktop/decorator/decorator.py", line 63, in <module>
    print(x)
NameError: name 'x' is not defined

5. 参数传递

python允许我们向函数传递参数，参数会变成本地变量存在于函数内部。而且参数可以用位置来进行设置：

# #  ***************  5 函数参数  ***************
def foo(x,y=0):
    return x*x,y-3

if __name__=="__main__":
    print(foo(4))
    print(foo(4,2))
    print(foo(y=2,x=5))

输出：

(16, -3)
(16, -1)
(25, -1)

我们可以通过显示地指出参数所代表的具体名称来改变传入实参的顺序。

以上我们说明，函数的参数可以有名称和位置。

6. 嵌套函数

Python允许创建嵌套函数。这意味着我们可以在函数里面定义函数而且现有的作用域和变量生存周期依旧适用。

#  ***************  6 嵌套函数  ***************
def outer():
    x=1
    def inner():
        x=6
        print(x)
    inner()
    print(x)

if __name__=="__main__":
    outer()

输出 1。

注意一下，这里的第6行是不可缺少的，就是说，如果你不在outer()函数内写一句inner()，别人会认为你定义了一个函数（和定义一个变量没区别），但你没有将这个函数进行调用！！！

在上面这个例子中，print(x)首先在inner内部寻找x的定义，没有找到，就得到inner的外一层去寻找，找到了，于是打印出来。对函数outer来说，变量x是一个本地变量，但是如先前提到的一样，函数inner可以访问封闭的作用域（至少可以读和修改）。在#2处，我们调用函数inner，非常重要的一点是，inner也仅仅是一个遵循python变量解析规则的变量名，python解释器会优先在outer的作用域里面对变量名inner查找匹配的变量。

7. 函数是python世界里的一级类对象

Python里面函数和其他东西一样是对象，而且函数是function这个类对象。而function这个类和int这个类一样，都继承自object类。object是python中所有东西的父类。

#  ***************  7 函数是python世界里的一级类对象  ***************
print(issubclass(int ,object)) # all objects in Python inherit from a common baseclass
def foo():
    pass
if __name__=="__main__":
    print(foo.__class__)
    print(issubclass(foo.__class__, object))

输出：

True
<class 'function'>
True

既然函数和int没啥区别，那么int可以作为实参传递，函数也可以作为实参传递给其他的函数。

# ***************  7 函数是python世界里的一级类对象  ***************
def add(x,y):
    return x+y
def sub(x,y):
    return x-y
def apply(func,x,y):
    return func(x,y)

if __name__=="__main__":
    print(apply(add,2,6))

输出8。

你们也许看到过这样的行为：python把频繁要用的操作变成函数作为参数进行使用，像通过传递一个函数给内置排序函数的key参数从而来自定义排序规则。那把函数当做返回值回事这样的情况呢：

def outer():
    def inner():
        print("zhangping")
    return inner

if __name__=="__main__":
    foo=outer()
    print(foo)
    print(foo())

输出：

<function outer.<locals>.inner at 0x000001D56BBD67B8>
zhangping
None

这个看上去会很奇怪：为什么要把一个函数标识符作为变量返回？？还记得变量的生存周期吗？每次函数outer被调用的时候，函数inner都会被重新定义，如果它不被当做变量返回的话，每次执行过后它将不复存在。

所以我们在主函数里面，首先调用了outer()，返回的是inner函数，这个函数被捕获了，赋给了foo，于是打印foo的时候，会表示这是一个函数，属于outer的本地变量，名为inner。然后打印foo()的时候，相当于是在调用inner函数，所以会打印出“zhangping”，然而inner这个函数没有返回值，所以inner()的返回值是None，所以print(foo())第二次打印的实际是foo()的返回值，是None。

代码可以看成是s=foo()     print(s)的合成。

8. 闭包

我们先不急着定义什么是闭包，先来看看一段代码，仅仅是把上一个例子简单的调整了一下：

# # ***************  8 闭包  ***************
def outer():
    x=1
    def inner():
        print(x)
    return inner

if __name__=="__main__":
    foo=outer()
    print(foo.__closure__) # python2中是foo.func_closure

输出：(<cell at 0x00000249394E0A08: int object at 0x00000000627460A0>,)

在上一个例子中我们了解到，inner作为一个函数被outer返回，保存在一个变量foo，并且我们能够对它进行调用foo()。不过它会正常的运行吗？我们先来看看作用域规则。

所有的东西都在python的作用域规则下进行工作：“x是函数outer里的一个局部变量。当函数inner在打印x的时候，python解释器会在inner内部查找相应的变量，当然会找不到，所以接着会到封闭作用域里面查找，并且会找到匹配。

但是从变量的生存周期来看，该怎么理解呢？我们的变量x是函数outer的一个本地变量，这意味着只有当函数outer正在运行的时候才会存在。根据我们已知的python运行模式，我们没法在函数outer返回之后继续调用函数inner，在函数inner被调用的时候，变量x早已不复存在，可能会发生一个运行时错误。

万万没想到，返回的函数inner居然能够正常工作。Python支持一个叫做函数闭包的特性，用人话来讲就是，嵌套定义在非全局作用域里面的函数能够记住它在被定义的时候它所处的封闭命名空间。这能够通过查看函数的func_closure属性得出结论，这个属性里面包含封闭作用域里面的值（只会包含被捕捉到的值，比如x，如果在outer里面还定义了其他的值，封闭作用域里面是不会有的)。比如在outer里面还定义了s="z"，那么不会在这里显示str类型的值，除非你在inner中print(s)。

记住，每次函数outer被调用的时候，函数inner都会被重新定义。现在变量x的值不会变化，所以每次返回的函数inner会是同样的逻辑，假如我们稍微改动一下呢？

# # ***************  8 闭包  ***************
def outer(x):
    def inner():
        print(x)
    return inner

if __name__=="__main__":
    print1=outer(1)
    print2=outer(2)
    print1()
    print2()
    print(print1())
    print(print2())

输出如下：

1
2
1
None
2
None

事实上我们并不是传递参数1或者2给函数inner，我们实际上是创建了能够打印各种数字的各种自定义版本。

闭包单独拿出来就是一个非常强大的功能， 在某些方面，你也许会把它当做一个类似于面向对象的技术：outer像是给inner服务的构造器，x像一个私有变量。使用闭包的方式也有很多：你如果熟悉python内置排序方法的参数key，你说不定已经写过一个lambda方法在排序一个列表的列表的时候基于第二个元素而不是第一个。现在你说不定也可以写一个itemgetter方法，接收一个索引值来返回一个完美的函数，传递给排序函数的参数key。

不过，我们现在不会用闭包做这么low的事(⊙o⊙)…！相反，让我们再爽一次，写一个高大上的装饰器!

9. 装饰器

装饰器其实就是一个闭包，把一个函数当做参数然后返回一个替代版函数。我们一步步从简到繁来瞅瞅：

# # ***************  9 装饰器  ***************
def outer(some_func):
    def inner():
        print("before some_func")
        ret=some_func()
        return ret+1
    return inner

def foo():
    return 1

if __name__=="__main__":
    decorated=outer(foo)
    s=decorated()
    print(s)

输出：

before some_func
2

定义了一个函数outer，它只有一个some_func的参数，里面我们定义了一个嵌套的函数inner。inner会打印一串字符串，然后调用some_func，得到它的返回值。在outer每次调用的时候some_func的值可能会不一样，但是不管some_func的之如何，我们都会调用它。最后，inner返回some_func() + 1的值 – 我们通过调用在存储在变量decorated里面的函数能够看到被打印出来的字符串以及返回值2，而不是期望中调用函数foo得到的返回值1。

我们可以认为变量decorated是函数foo的一个装饰版本，一个加强版本。事实上如果打算写一个有用的装饰器的话，我们可能会想愿意用装饰版本完全取代原先的函数foo，这样我们总是会得到我们的”加强版“foo。想要达到这个效果，完全不需要学习新的语法，简单地赋值给变量foo就行了：

想象我们有一个库，这个库能够提供类似坐标的对象，也许它们仅仅是一些x和y的坐标对。不过可惜的是这些坐标对象不支持数学运算符，而且我们也不能对源代码进行修改，因此也就不能直接加入运算符的支持。我们将会做一系列的数学运算，所以我们想要能够对两个坐标对象进行合适加减运算的函数，这些方法很容易就能写出：

# # ***************  9 装饰器  ***************
class Coordinate(object):
    def __init__(self, x, y):
        self.x=x
        self.y=y

    # Python中这个_repr_函数，对应repr(object)
    # 这个函数，返回一个可以用来表示对象的可打印字符串；
    # 否则，生成用尖括号包住的字符串，包含类型名和额外的信息(比如地址) ；
    # 一个类(class)可以通过 __repr__() 成员来控制repr()函数作用在其实例上时的行为。
    # print(a)这个函数内部，在实现的时候，会首先对a是这个对象是什么类进行调查，
    # 然后调用Type(a)的__repr__方法来执行打印输出，所以修改这个函数，可以修改print的值
    # 这个__repr__继承自object的同名方法，返回值必须是str格式的。
    def __repr__(self):
        return "Coord: "+str(self.__dict__)

def add(a,b):
    return Coordinate(a.x+b.x,a.y+b.y)

def sub(a,b):
    return Coordinate(a.x-b.x,a.y-b.y)

if __name__=="__main__":
    one = Coordinate(100, 200)
    two = Coordinate(300, 200)
    s=add(one,two)
    print(s)

输出为：Coord: {'x': 400, 'y': 400}

如果加减函数同时需要一些边界检查的行为那该怎么办呢？搞不好你只能够对正的坐标对象进行加减操作，任何返回的值也都应该是正的坐标。所以现在的期望是这样：

    one = Coordinate(100, 200)
    two = Coordinate(300, 200)
    three=Coordinate(-100,-100)
    s=sub(one,two)
    print(s)
    t=add(one,three)
    print(t)

我们期望在不更改坐标对象one, two, three的前提下one减去two的值是{x: 0, y: 0}，one加上three的值是{x: 100, y: 200}。与其给每个方法都加上参数和返回值边界检查的逻辑，我们来写一个边界检查的装饰器！

# # ***************  9 装饰器  ***************
class Coordinate(object):
    def __init__(self, x, y):
        self.x=x
        self.y=y

    # Python中这个_repr_函数，对应repr(object)
    # 这个函数，返回一个可以用来表示对象的可打印字符串；
    # 否则，生成用尖括号包住的字符串，包含类型名和额外的信息(比如地址) ；
    # 一个类(class)可以通过 __repr__() 成员来控制repr()函数作用在其实例上时的行为。
    # print(a)这个函数内部，在实现的时候，会首先对a是这个对象是什么类进行调查，
    # 然后调用Type(a)的__repr__方法来执行打印输出，所以修改这个函数，可以修改print的值
    # 这个__repr__继承自object的同名方法，返回值必须是str格式的。
    def __repr__(self):
        return "Coord: "+str(self.__dict__)

def add(a,b):
    return Coordinate(a.x+b.x,a.y+b.y)

def sub(a,b):
    return Coordinate(a.x-b.x,a.y-b.y)

def wrapper(func):
    def checker(a,b):
        a=Coordinate(a.x if a.x>0 else 0, a.y if a.y>0 else 0)
        b=Coordinate(b.x if b.x>0 else 0, b.y if b.y>0 else 0)
        ret = func(a,b)
        ret=Coordinate(ret.x if ret.x>0 else 0, ret.y if ret.y>0 else 0)
        return ret
    return checker

if __name__=="__main__":
    add=wrapper(add)
    sub=wrapper(sub)
    one = Coordinate(100, 200)
    two = Coordinate(300, 200)
    three=Coordinate(-100,-100)
    s=sub(one,two)
    print(s)
    t=add(one,three)
    print(t)

输出：

Coord: {'x': 0, 'y': 0}

Coord: {'x': 100, 'y': 200}

这个装饰器能想先前的装饰器例子一样进行工作，返回一个经过修改的函数，但是在这个例子中，它能够对函数的输入参数和返回值做一些非常有用的检查和格式化工作，将负值的x和 y替换成0。

显而易见，通过这样的方式，我们的代码变得更加简洁：将边界检查的逻辑隔离到单独的方法中，然后通过装饰器包装的方式应用到我们需要进行检查的地方。另外一种方式通过在计算方法的开始处和返回值之前调用边界检查的方法也能够达到同样的目的。但是不可置否的是，使用装饰器能够让我们以最少的代码量达到坐标边界检查的目的。事实上，如果我们是在装饰自己定义的方法的话，我们能够让装饰器应用的更加有逼格。

10. 使用@标识符将装饰器应用到函数

标识符@将装饰器应用在函数上，只需要在函数的定义前加上@和装饰器的名称。在上一节的例子里我们是将原本的方法用装饰后的方法代替，python只是让代码更加简洁而已，原理一样：（上面的代码用下面的方式代替）

def add(a,b):
    return Coordinate(a.x+b.x,a.y+b.y)
add=wrapper(add)

@wrapper
def sub(a,b):
    return Coordinate(a.x-b.x,a.y-b.y)

11.*args and **kwargs

我们已经完成了一个有用的装饰器，但是由于硬编码的原因它只能应用在一类具体的方法上，这类方法接收两个参数，传递给闭包捕获的函数。如果我们想实现一个能够应用在任何方法上的装饰器要怎么做呢？再比如，如果我们要实现一个能应用在任何方法上的类似于计数器的装饰器，不需要改变原有方法的任何逻辑。这意味着装饰器能够接受拥有任何签名的函数作为自己的被装饰方法，同时能够用传递给它的参数对被装饰的方法进行调用。

非常巧合的是Python正好有支持这个特性的语法。可以阅读 Python Tutorial 获取更多的细节。当定义函数的时候使用了*，意味着那些通过位置传递的参数将会被放在带有*前缀的变量中， 所以：

# # ***************  11 *args and **kwargs  ***************
def one(*args):
    print(args)

def two(x,y,*args):
    print(x,y,args)

if __name__=="__main__":
    one()
    one(1,2,3)
    two('a','b','c','d','e','f')

输出：

()
(1, 2, 3)
a b ('c', 'd', 'e', 'f')

第一个函数one只是简单地讲任何传递过来的位置参数全部打印出来而已，你们能够看到，我们只是引用了函数内的变量args, *args仅仅只是用在函数定义的时候用来表示位置参数应该存储在变量args里面。Python允许我们制定一些参数并且通过args捕获其他所有剩余的未被捕捉的位置参数。

*操作符在函数被调用的时候也能使用。意义基本是一样的。当调用一个函数的时候，一个用*标志的变量意思是变量里面的内容需要被提取出来然后当做位置参数被使用。同样的，来看个例子：

# # ***************  11 *args and **kwargs  ***************
def add(x,y):
    return x+y

lst=[1,2]

if __name__=="__main__":
    print(add(lst[0],lst[1]))
    print(add(*lst))

输出：3       3

*args要么是表示调用方法大的时候额外的参数可以从一个可迭代列表中取得，要么就是定义方法的时候标志这个方法能够接受任意的位置参数。

接下来提到的**会稍多更复杂一点，**代表着键值对的餐宿字典，和*所代表的意义相差无几，也很简单对不对：

# # ***************  11 *args and **kwargs  ***************
def foo(**kwargs):
    print(kwargs)

lst=[1,2]

if __name__=="__main__":
    print(foo())
    print(foo(x=1,y=2))

当我们定义一个函数的时候，我们能够用**kwargs来表明，所有未被捕获的关键字参数都应该存储在kwargs的字典中。如前所诉，args 和 kwargs并不是python语法的一部分，但在定义函数的时候，使用这样的变量名算是一个不成文的约定。和*一样，我们同样可以在定义或者调用函数的时候使用**。

# # ***************  11 *args and **kwargs  ***************
def bar(x,y):
    return x+y

dct={'x':1,'y':2}

if __name__=="__main__":
    print(bar(**dct))

12.更通用的装饰器

有了这招新的技能，我们随随便便就可以写一个能够记录下传递给函数参数的装饰器了。先来个简单地把日志输出到界面的例子：

# # ***************  12 更通用的装饰器  ***************
def logger(func):
    def inner(*args,**kwargs):
        print("Arguments were: %s, %s" % (args,kwargs))
        return func(*args, **kwargs)
    return inner

@logger
def foo1(x,y=1):
    return x*y

@logger
def foo2():
    return 2

if __name__=="__main__":
    print(foo1(5,4))
    print(foo1(1))
    print(foo2())

输出

Arguments were: (5, 4), {}
20
Arguments were: (1,), {}
1
Arguments were: (), {}
2