我跟别人说我精通python，别人问我wrapper是啥，我说不知道，尼玛，原来wrapper就是装饰器，熟的不得了啊，英语真是我的克星啊。
闭包 closure
在认识装饰器之前先认识下闭包
闭包，顾名思义就是把什么东西封闭在保内，什么东西呢？变量和函数。
在一个函数里装了另一个函数，里面那个函数称为内部函数，外面那个函数称为外部函数，
在内部函数里，对在外部作用域（非全局作用域）里的变量进行引用，这个内部函数就称为闭包
定义在外部函数内但被内部函数引用或调用的变量称为*变量，所以闭包又被称为引用了*变量的函数。
内部函数和*变量同时存在构建一个闭包实体，闭包的作用就是使闭包实体可以脱离创建它的环境运行，就是变量和函数脱离了创建它的环境依然存在，而且可执行，这点跟面向对象有些类似。
闭包的语法是一个函数A内创建了一个函数B，并且函数A返回了函数B，函数B就是闭包，函数A内的变量叫*变量，包括A的参数
示例代码
def counter(start_at=):
print('act')
count=[start_at] # *变量
def incr(): # 内部函数
count[]+=
return count[]
return incr # 返回一个函数对象 count=counter() # act
print #
print count() # # count 和 incr 脱离了创建它的环境，依然可以运行
print count() # count2=counter() # act
print #
print count2() #
print count() #
闭包的作用
1. 闭包实际上是对数据或者数据操作的封装
2. 闭包可以实现一些通用的功能，它是装饰器的基础。
装饰器
装饰器本质上是个函数，一个用来包装函数的函数，返回被包装的函数对象。
被包装的函数需要作为装饰器函数的参数。
装饰器以语法糖@开头，形式如下
@decorator(dec_opt_args)
def func2Bdecorated(func_opt_args):
并且可以有多个装饰器
@deco2
@deco1
def func():
pass 等价于 func=deco2(deco1(func))
普通方式实现类似装饰器的功能，以帮助理解
def deco(func):
print("before myfunc() called.")
func()
print(" after myfunc() called.")
return func def myfunc():
print(" myfunc() called.") myfunc = deco(myfunc)
# before myfunc() called.
# myfunc() called.
# after myfunc() called. myfunc() # myfunc() called.
myfunc() # myfunc() called.
使用语法糖@装饰函数，注意这并不是装饰器
def deco(func):
print("before myfunc() called.")
func()
print("after myfunc() called.")
return func @deco
def myfunc():
print("myfunc() called.") myfunc()
# before myfunc() called.
# myfunc() called.
# after myfunc() called.
# myfunc() called.
print("*"*5)
myfunc() # myfunc() called.
可以看到第一次执行时@起了作用，第二次执行时@没起作用。为什么呢，往下看
真正的装饰器来了
无参装饰器
def deco(func):
print(33)
def _deco():
print("before myfunc() called.")
func()
print(" after myfunc() called.")
return _deco @deco
def myfunc():
print(" myfunc() called.")
return 'ok' myfunc()
#
# before myfunc() called.
# myfunc() called.
# after myfunc() called.
myfunc()
# before myfunc() called.
# myfunc() called.
# after myfunc() called.
可以看到每次执行@都起了作用，但是33只被打印了一次，又是为什么呢？
明明是执行了两次一模一样的操作，结果却不同，看来有必要深入理解一下装饰器了。
深入理解装饰器
之前讲到闭包类似于面向对象，而装饰器基于闭包，也应该类似于面向对象咯，或许吧，类似嘛，我又没说是，所以应该没错，
为什么扯这么多，因为我要用class来解释上面的问题。
对上面的无参装饰器分析一
## 上述过程类似这样
def myfunc():
print(" myfunc() called.")
return 'ok' bb = deco(myfunc) #
bb()
# before myfunc() called.
# myfunc() called.
# after myfunc() called.
bb()
# before myfunc() called.
# myfunc() called.
# after myfunc() called.
把装饰器转成普通函数，就明了了：
装饰器内的操作在创建装饰器实例时已经运行，这可以理解为class的实例化，如果在实例化时有print操作，在实例调用时不会再有
对上面的无参装饰器分析二
def deco(func):
a = 3
def _deco():
print("before myfunc() called.")
func()
print(a)
print(" after myfunc() called.")
return _deco @deco
def myfunc():
print(" myfunc() called.")
return 'ok' myfunc()
# before myfunc() called.
# myfunc() called.
#
# after myfunc() called.
myfunc()
# before myfunc() called.
# myfunc() called.
#
# after myfunc() called.
装饰器传递的是*变量和闭包，可以理解为class的实例属性和方法，在实例调用时，属性一直存在。
myfunc()第一次运行时相当于初始化了装饰器，后面只是调用实例，虽然它没有生成实例对象，在这点上不同于class。
总结
装饰器函数真的类似于面向对象
装饰器在第一次运行时相当于实例化class，实例化时可以有操作和属性，操作不被传递，属性被传递
装饰器不需要创建实例对象，运行即相当于实例化class
装饰器传递的是*变量和属性，装饰器函数内的操作不被传递
装饰器的各种语法
有参装饰器
def deco(func):
def _deco(a, b):
print("before myfunc() called.")
ret = func(a, b)
print(" after myfunc() called. result: %s" % ret)
return ret
return _deco @deco
def myfunc(a, b):
print(" myfunc(%s,%s) called." % (a, b))
return a + b myfunc(1, 2)
# before myfunc() called.
# myfunc(1,2) called.
# after myfunc() called. result: 3
myfunc(3, 4)
# before myfunc() called.
# myfunc(3,4) called.
# after myfunc() called. result: 7
装饰器带参数
外面加一层
def deco(arg):
def _deco(func):
def __deco():
print("before %s called [%s]." % (func.__name__, arg))
func()
print(" after %s called [%s]." % (func.__name__, arg))
return __deco
return _deco @deco("mymodule")
def myfunc():
print(" myfunc() called.") @deco("module2")
def myfunc2():
print(" myfunc2() called.") myfunc()
myfunc2()
装饰器带类参数
装饰器的参数是个类，也可以是实例，或者其他
class locker:
def __init__(self):
print("locker.__init__() should be not called.") @staticmethod
def acquire():
print("locker.acquire() called.（这是静态方法）") @staticmethod
def release():
print(" locker.release() called.（不需要对象实例）") def deco(cls):
'''cls 必须实现acquire和release静态方法'''
def _deco(func):
def __deco():
print("before %s called [%s]." % (func.__name__, cls))
cls.acquire()
try:
return func()
finally:
cls.release()
return __deco
return _deco @deco(locker)
def myfunc():
print(" myfunc() called.") myfunc()
myfunc()
被装饰的函数属性发生了变化
def deco(func):
def myfunc(x):
return func(x)
return myfunc @deco
def test1(x):
return x+1 print(test1(4)) #
print(test1.__name__) # myfunc 名字并非真实名字
名字并非真正函数的名字，而是装饰器函数里被装饰的函数的名字
保留被装饰的函数的属性
import time
import functools def timeit(func):
@functools.wraps(func) # 此句就是用来保留被装饰的函数的属性的 ，其余跟普通装饰器一样
def wrapper():
start = time.clock()
func()
end =time.clock()
print 'used:', end - start
return wrapper @timeit
def foo():
print 'in foo()' foo() # used: 5.13182184074e-06
print foo.__name__ # foo
name属性被保留
参考资料：
http://www.cnblogs.com/rhcad/archive/2011/12/21/2295507.html