注：该文是参考（或转载）于：
http://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/0014318435599930270c0381a3b44db991cd6d858064ac0000#0 装饰器1、要了解装饰器，就需要知道什么是高阶函数，高阶函数就是将函数作为参数赋值给另一个函数
2、python的 decorator 本质上就是一个高阶函数，它接收一个函数作为参数，然后，返回一个新函数
3、decorator是在被装饰的函数前加@函数名的函数来修饰下面的函数
#被装饰函数 def now(): print(‘2015-3-3’)想要对被装饰函数添加（修饰）什么功能，就可以写一个特定的函数，然后在被装饰的函数前加@函数名
#需要装饰其它函数时的新功能函数 def log(func): def wrapper(*args,**kw): print(‘call %s(): ’ % func.__name__) return func(*args,**kw) return wrapper完成装饰
@log def now(): return print(‘2015-3-3’)调用now()函数，不仅会运行now()函数本身，还会在运行now()函数前打印一行日志：
>>> now() call now(): 2015-3-3把@log放到new()函数的定义处，相当于执行了语句：
now = log(now)
由于log()是一个decorator，返回一个函数，所以，原来的now()函数仍然存在，只是现在同名的now变量指向了新的函数，于是调用now()将执行新函数，即在log()函数中返回的wrapper()函数。
++++++++++++++++++++++++++++++++++++++
带参数的装饰器
def log(text): def decorator(func): def wrapper(*args,**kw): print(‘%s %s():’ % (text,fun.__name__)) return func(*args,**kw) return wrapper return decorator这个3层嵌套的decorator用法如下：
@log('execute') def now(): print('2015-3-25')执行结果如下：
>>> now() execute now(): 2015-3-25和两层嵌套的decorator相比，3层嵌套的效果是这样的：
>>> now = log('execute')(now)我们来剖析上面的语句，首先执行log(‘execute’)，返回的是decorator函数，再调用返回的函数，参数是now函数，返回值最终是wrapper函数。
以上两种decorator的定义都没有问题，但还差最后一步。因为我们讲了函数也是对象，它有 name 等属性，但你去看经过decorator装饰之后的函数，它们的 name 已经从原来的’now’变成了’wrapper’：
>>> now.__name__ 'wrapper'因为返回的那个wrapper()函数名字就是’wrapper’，所以，需要把原始函数的 name 等属性复制到wrapper()函数中，否则，有些依赖函数签名的代码执行就会出错。
不需要编写wrapper. name = func. name 这样的代码，Python内置的functools.wraps就是干这个事的，所以，一个完整的decorator的写法如下：
import functools def log(func): @functools.wraps(func) def wrapper(*args, **kw): print('call %s():' % func.__name__) return func(*args, **kw) return wrapper或者针对带参数的decorator：
import functools def log(text): def decorator(func): @functools.wraps(func) def wrapper(*args, **kw): print('%s %s():' % (text, func.__name__)) return func(*args, **kw) return wrapper return decoratorimport functools是导入functools模块。模块的概念稍候讲解。现在，只需记住在定义wrapper()的前面加上@functools.wraps(func)即可。
类装饰器 #mylocker.py class mylocker: def __init__(self): print("mylocker.__init__() called.") @staticmethod def acquire(): print("mylocker.acquire() called.") @staticmethod def unlock(): print(" mylocker.unlock() called.") class lockerex(mylocker): @staticmethod def acquire(): print("lockerex.acquire() called.") @staticmethod def unlock(): print(" lockerex.unlock() called.") def lockhelper(cls): '''cls 必须实现acquire和release静态方法''' def _deco(func): def __deco(*args, **kwargs): print("before %s called." % func.__name__) cls.acquire() #这里需要不创建实例调用类的方法，所以需要在acquire方法的上方使用@staticmethod try: return func(*args, **kwargs) finally: cls.unlock() #这里需要不创建实例调用类的方法，所以需要在unlock方法的上方使用@staticmethod return __deco return _deco #decorate.py from mylocker import * class example: @lockhelper(mylocker) def myfunc(self): print(" myfunc() called.") @lockhelper(mylocker) @lockhelper(lockerex) def myfunc2(self, a, b): print(" myfunc2() called.") return a + b if __name__=="__main__": a = example() a.myfunc() print(a.myfunc()) print(a.myfunc2(1, 2)) print(a.myfunc2(3, 4)) @staticmethod与@classmethod的区别一般来说，要使用某个类的方法，需要先实例化一个对象再调用方法。
而使用@staticmethod或@classmethod，就可以不需要实例化，直接类名.方法名()来调用。
这有利于组织代码，把某些应该属于某个类的函数给放到那个类里去，同时有利于命名空间的整洁。
既然@staticmethod和@classmethod都可以直接类名.方法名()来调用，那他们有什么区别呢
从它们的使用上来看,
@staticmethod不需要表示自身对象的self和自身类的cls参数，就跟使用函数一样。
@classmethod也不需要self参数，但第一个参数需要是表示自身类的cls参数。
如果在@staticmethod中要调用到这个类的一些属性方法，只能直接类名.属性名或类名.方法名。
而@classmethod因为持有cls参数，可以来调用类的属性，类的方法，实例化对象等，避免硬编码。
下面上代码。
[python] view plain copy class A(object): bar = 1 def foo(self): print 'foo' @staticmethod def static_foo(): print 'static_foo' print A.bar @classmethod def class_foo(cls): #这里用了cls参数，即A这个类本身，后面要使用类.属性或类.方法时就可以用cls.属性或cls.方法，避免硬编码 print 'class_foo' print cls.bar cls().foo() #类.方法的调用，没有使用类的名字(A)，避免硬编码 A.static_foo() A.class_foo() 输出 static_foo 1 class_foo 1 foo