Python 入门：装饰器(decorator)、@functools.wraps、@staticmethod、@classmethod

注：该文是参考（或转载）于：

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放到now()函数的定义处，相当于执行了语句：

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 decorator

import 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