网上很多讲解单个python 装饰器的文章，基础知识我们简单描述。

首先了解装饰器是用来干什么的，装饰器可以增加函数的功能，可以通过函数实现，可以通过类实现，分别介绍两种的简单例子。

装饰者模式（Decorator Pattern），是在不必改变原类文件和使用继承的情况下，动态的扩展一个对象的功能。它是通过创建一个包装对象，也就是装饰来包裹真实的对象。

适用装饰者模式场合：
1．当我们需要为某个现有的对象，动态的增加一个新的功能或职责时，可以考虑使用装饰模式。
2．当某个对象的职责经常发生变化或者经常需要动态的增加职责，避免为了适应这样的变化，而增加继承子类扩展的方式，因为这种方式会造成子类膨胀的速度过快，难以控制。

函数的单个装饰器

使用内嵌包装函数来确保每次新函数都被调用，内嵌包装函数的形参和返回值与原函数相同，装饰函数返回内嵌包装函数对象。

def deco(func):
    def _deco():
        print("before myfunc() called.")
        func()
        print("  after myfunc() called.")
         #不需要返回func，实际上应返回原函数的返回值
    return _deco

@deco
def myfunc():
    print(" myfunc() called.")
    return 'ok'


myfunc()
myfunc()

打印结果为：

before myfunc() called.
myfunc() called.
after myfunc() called.
before myfunc() called.
myfunc() called.
after myfunc() called.

装饰器带类参数

装饰器带类参数:

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()

输出结果为：

before myfunc called [<class 'main.locker'>].
locker.acquire() called.（这是静态方法）
myfunc() called.
locker.release() called.（不需要对象实例）
before myfunc called [<class 'main.locker'>].
locker.acquire() called.（这是静态方法）
myfunc() called.
locker.release() called.（不需要对象实例）

对一个函数应用多个装饰器

def decorator_b(func):
    print ('Get in decorator_b')
    def inner_b(*args, **kwargs):
        print("b %s called." % func.__name__)
        print ('Get in inner_b')
        return func(*args, **kwargs)
    return inner_b

def decorator_a(func):
    print ('Get in decorator_a')
    def inner_a(*args, **kwargs):
        print("a %s called." % func.__name__)
        print ('Get in inner_a')
        return func(*args, **kwargs)
    return inner_a


@decorator_b
@decorator_a
def f(x):
    print ('Get in f')
    return x * 2

f(1)

输出结果：

Get in decorator_a
Get in decorator_b
b inner_a called.
Get in inner_b
a f called.
Get in inner_a
Get in f

运行顺序：
根据自下而上的原则来判断地话，先执行 decorator_a 再执行 decorator_b , 那么会先输出 Get in decotator_a，Get in decorator_b；

上述装饰器实际等价于：

f =decorator_b(decorator_a(f))(1)

decorator_a 函数来说，它返回的是个函数对象 inner_a ，这个函数对象是它内部定义的，所以decorator_b执行的是decorator_b(inner_a)，那么就可以理解为何打印出来“ b inner_a called.”；

在decorator_b中的 return func(*args, **kwargs) 为inner_a(f)，所以再执行decorator_a 中的inner_a(f)，打印出“a f called.”；

最后执行f(1)。

类中对一个函数应用多个装饰器

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):
        print("%s %s called." % (func.__name__,cls))
        def __deco(*args, **kwargs):
            print("before %s called." % func.__name__)
            cls.acquire()
            try:
                return func(*args, **kwargs)
            finally:
                cls.unlock()

        return __deco

    return _deco

test.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()
    #实例化过程：
    # 第一步lockhelper(mylocker)(myfunc) 打印 myfunc <class '__main__.lockerex'> called. 返回方法__deco,
    # 第二步lockhelper(lockerex)(myfunc2) 打印 myfunc2 <class '__main__.lockerex'> called. 返回方法__deco,
    # 第三步lockhelper(mylocker)(__deco) __deco <class '__main__.mylocker'> called. 返回方法__deco。

    a.myfunc()
    print(a.myfunc())
    print(a.myfunc2(1, 2))
    #过程解析：
    #等价于lockhelper(mylocker)(lockhelper(lockerex)(myfunc2))(1,2)
    #第一步 等价于lockhelper(mylocker)(__deco)(1,2) 因为lockerex(myfunc2)返回的是__deco方法
    #lockhelper(mylocker)(lockhelper(lockerex)(myfunc2))(1,2) 执行后打印 before __deco called.
    #传入类为mylocker，执行cls.acquire() 打印 mylocker.acquire() called.
    #func(*args, **kwargs) 中func为lockhelper(lockerex)(myfunc2)
    #执行lockhelper(lockerex)(myfunc2) 打印 before myfunc2 called.
    #传入类为lockerex，执行cls.acquire() 打印 lockerex.acquire() called.
    #传入func(*args, **kwargs) 中func为myfunc2(1,2)
    #执行myfunc2(1,2) 打印 myfunc2() called. 返回 3
    #返回 3 执行lockerex的 cls.unlock() 打印 lockerex.unlock() called.
    #返回 3 执行mylocker的 cls.unlock() 打印 mylocker.unlock() called.
    
    print(a.myfunc2(3, 4))