Python之装饰器(decorator)、@functools.wraps、@staticmethod、@classmethod使用例子

装饰器

1、要了解装饰器，就需要知道什么是高阶函数，高阶函数就是将函数作为参数赋值给另一个函数 
2、Python的 decorator 本质上就是一个高阶函数，它接收一个函数作为参数，然后，返回一个新函数 
3、decorator是在被装饰的函数前加@函数名的函数来修饰下面的函数

#被装饰函数
def now():
    print(‘2015-3-3’)

• 想要对被装饰函数添加（修饰）什么功能，就可以写一个特定的函数，然后在被装饰的函数前加@函数名

• 不带参数装饰器-2层

• 这个2层嵌套的decorator用法如下：

#需要装饰其它函数时的新功能函数
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()函数。 
++++++++++++++++++++++++++++++++++++++ 

带参数的装饰器-3层

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()函数中，否则，有些依赖函数签名的代码执行就会出错。 

•  @functools.wraps(func)

不需要编写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