12步入门Python中的decorator装饰器使用方法

>>> def outer():
...   x = 1
...   def inner():
...     print x # 1
...   return inner
>>> foo = outer()
>>> foo.func_closure
(<cell at 0x...: int object at 0x...>,)

在上一个例子中我们了解到，inner作为一个函数被outer返回，保存在一个变量foo，并且我们能够对它进行调用foo()。不过它会正常的运行吗？我们先来看看作用域规则。
所有的东西都在python的作用域规则下进行工作：“x是函数outer里的一个局部变量。当函数inner在#1处打印x的时候，python解释器会在inner内部查找相应的变量，当然会找不到，所以接着会到封闭作用域里面查找，并且会找到匹配。
但是从变量的生存周期来看，该怎么理解呢？我们的变量x是函数outer的一个本地变量，这意味着只有当函数outer正在运行的时候才会存在。根据我们已知的python运行模式，我们没法在函数outer返回之后继续调用函数inner，在函数inner被调用的时候，变量x早已不复存在，可能会发生一个运行时错误。
万万没想到，返回的函数inner居然能够正常工作。Python支持一个叫做函数闭包的特性，用人话来讲就是，嵌套定义在非全局作用域里面的函数能够记住它在被定义的时候它所处的封闭命名空间。这能够通过查看函数的func_closure属性得出结论，这个属性里面包含封闭作用域里面的值（只会包含被捕捉到的值，比如x，如果在outer里面还定义了其他的值，封闭作用域里面是不会有的）
记住，每次函数outer被调用的时候，函数inner都会被重新定义。现在变量x的值不会变化，所以每次返回的函数inner会是同样的逻辑，假如我们稍微改动一下呢？

>>> def outer(x):
...   def inner():
...     print x # 1
...   return inner
>>> print1 = outer(1)
>>> print2 = outer(2)
>>> print1()
1
>>> print2()
2

>>> def outer(some_func):
...   def inner():
...     print "before some_func"
...     ret = some_func() # 1
...     return ret + 1
...   return inner
>>> def foo():
...   return 1
>>> decorated = outer(foo) # 2
>>> decorated()
before some_func
2

>>> foo = outer(foo)
>>> foo # doctest: +ELLIPSIS
<function inner at 0x...>

>>> class Coordinate(object):
...   def __init__(self, x, y):
...     self.x = x
...     self.y = y
...   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)
>>> one = Coordinate(100, 200)
>>> two = Coordinate(300, 200)
>>> add(one, two)
Coord: {'y': 400, 'x': 400}

>>> one = Coordinate(100, 200)
>>> two = Coordinate(300, 200)
>>> three = Coordinate(-100, -100)
>>> sub(one, two)
Coord: {'y': 0, 'x': -200}
>>> add(one, three)
Coord: {'y': 100, 'x': 0}

>>> def wrapper(func):
...   def checker(a, b): # 1
...     if a.x < 0 or a.y < 0:
...       a = Coordinate(a.x if a.x > 0 else 0, a.y if a.y > 0 else 0)
...     if b.x < 0 or b.y < 0:
...       b = Coordinate(b.x if b.x > 0 else 0, b.y if b.y > 0 else 0)
...     ret = func(a, b)
...     if ret.x < 0 or ret.y < 0:
...       ret = Coordinate(ret.x if ret.x > 0 else 0, ret.y if ret.y > 0 else 0)
...     return ret
...   return checker
>>> add = wrapper(add)
>>> sub = wrapper(sub)
>>> sub(one, two)
Coord: {'y': 0, 'x': 0}
>>> add(one, three)
Coord: {'y': 200, 'x': 100}

>>> add = wrapper(add)

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

>>> def one(*args):
...   print args # 1
>>> one()
()
>>> one(1, 2, 3)
(1, 2, 3)
>>> def two(x, y, *args): # 2
...   print x, y, args
>>> two('a', 'b', 'c')
a b ('c',)

>>> def add(x, y):
...   return x + y
>>> lst = [1,2]
>>> add(lst[0], lst[1]) # 1
3
>>> add(*lst) # 2
3

>>> def foo(**kwargs):
...   print kwargs
>>> foo()
{}
>>> foo(x=1, y=2)
{'y': 2, 'x': 1}

>>> dct = {'x': 1, 'y': 2}
>>> def bar(x, y):
...   return x + y
>>> bar(**dct)
3

>>> def logger(func):
...   def inner(*args, **kwargs): #1
...     print "Arguments were: %s, %s" % (args, kwargs)
...     return func(*args, **kwargs) #2
...   return inner

>>> @logger
... def foo1(x, y=1):
...   return x * y
>>> @logger
... def foo2():
...   return 2
>>> foo1(5, 4)
Arguments were: (5, 4), {}
20
>>> foo1(1)
Arguments were: (1,), {}
1
>>> foo2()
Arguments were: (), {}
2