Python中的装饰器、类装饰器（用类的方式写）及用于类的装饰器

装饰器是非常Pythonic的工具之一，由于骑在函数定义语句的身上，看起来非常像Java的标注，其实是一种函数（或者类）的使用方法或称语法糖。之所以想要总结以下的内容，是因为浏览了很多与类装饰器相关的教程并未说清其含义是用类的方式写的装饰器，还是其装饰器创建的目的是使用在类上。那我们开始吧。
我们先来看一个最简单的例子：

def fake_decorator(obj):
    print(obj)

class Being(object):
    pass

def being(object):
    pass

if __name__ == '__main__':
    fake_decorator(Being)
    fake_decorator(being)

运行结果：
接收到的对象是：<class 'main.Being'>
接收到的对象是：<function being at 0x000001ED0B2876A8>

如果你看到了这个假装是装饰器的函数感觉到了不削，那就对了。但是TA不仅仅是假装，TA真的是一款如假包换，低配版的装饰器，请看神奇的一刻：

def fake_decorator(obj):
    print('接收到的对象是：{}'.format(obj))
    return obj

@fake_decorator
class Being(object):
    pass

@fake_decorator
def being():
    pass


if __name__ == '__main__':
    Being()
    being()

运行结果：
接收到的对象是：<class 'main.Being'>
接收到的对象是：<function being at 0x000001A8631376A8>

回想一下前面说的，装饰器实质就是一种函数（或类）的使用方式。当被装饰的函数对象（或类对象）被调用时，该对象会被作为参数（param）传入骑在ta身上的装饰器。

我们经常可以看到的装饰器多是基于函数创建的，长这样：

# 这是基于函数的方式创建的无参数装饰器
def func_based_decorator_without_params(original_func):
    print('"_wrapper"浏览开始...')
    
    @wraps(original_func)
    def _wrapped_func(*_args, **_kwargs):
        """
        装饰作业层，为原始的function添加功能。
        # functools.wraps装饰器的作用是保留传入的original_function的属性，
        #     即经过装饰的函数属性不会改变变为_wrapper返回的_wrapped_func。
        """
        print('开始装饰...')
        print('传入的函数为：{}'.format(original_func))
        print('Function has been wrapped...')
        method = original_func(*_args, **_kwargs)
        print('What？赶紧干活！')
        return method

    print('"_wrapper"浏览结尾...')
    return _wrapped_func


if __name__ == '__main__':
    @func_based_decorator_without_params
    def func_based_decorator_without_params(string):
        print('不干活儿...')

    func_based_decorator_without_params(string='hello_world')

运行结果：
"_wrapper"浏览结尾...
开始装饰...
传入的函数为：<function func_based_decorator_without_params at 0x000001DA58962C80>
Function has been wrapped...
不干活儿...
What？赶紧干活！

本文的主旨之一是介绍装饰器是什么及用来做什么，相信大家都已经看出来，这就是一个把原始对象传入后对其各种骚操作，添加功能或者改变其功能，然后再传出的工具，是的！
用类的方式是否可以写出相同的功能呢？必须可以。但是该压轴内容将会放在稍后介绍，我们紧接着讨论另一种情况，就是该装饰器还需要传参。

# 比如有木有同学想起Flask中注册路由的：
@xxx.route(method=['GET', 'POST'])

请看低配版传参装饰器的使用：

# 用于收集使用过decorator_with_params装饰器的函数对象
collected_functions = []

# 这是基于函数的方式创建的传参装饰器
def func_based_decorator_with_params(*args, **kwargs):
    """
    最外层，用于接收装饰器的参数
    """
    print('"_decorator"浏览开始...')
    print('传入的args有:{}'.format(args))
    print('传入的kargs有:{}'.format(kwargs))

    def _wrapper(original_func):
        """
        中间层，接收传入的原始函数。
        """
        print('"_wrapper"浏览开始...')

        @wraps(original_func)
        def _wrapped_func(*_args, **_kwargs):
            """
            装饰作业层，为原始的function添加功能。
            """
            print('开始装饰...')
            collected_functions.append(original_func)
            print('传入的函数为：{}, 已存入collected_functions'.format(original_func))
            print('传入的参数有：args={}, kwargs={}'.format(_args, _kwargs))
            print('Function has been wrapped...')
            method = original_func(*_args, **_kwargs)
            print('有活儿干了...')
            return method

        print('"_wrapper"浏览结尾...')
        return _wrapped_func

    print('"_decorator"浏览结尾...')
    return _wrapper


if __name__ == '__main__':
    @func_based_decorator_with_params('hello', serial_num='001')
    def func_based_decorator_with_params_1(string):
        print('不干活儿...')


    @func_based_decorator_with_params('hello', serial_num='002')
    def func_based_decorator_with_params_2(string):
        print('不干活儿...')

    func_based_decorator_with_params_1(string='hello_world')
    func_based_decorator_with_params_2(string='hello_world')

    print('collected_functions:{}'.format(collected_functions))

运行结果：
"_decorator"浏览开始...
传入的args有:('hello',)
传入的kargs有:{'serial_num': '001'}
"_decorator"浏览结尾...
"_wrapper"浏览开始...
"_wrapper"浏览结尾...
"_decorator"浏览开始...
传入的args有:('hello',)
传入的kargs有:{'serial_num': '002'}
"_decorator"浏览结尾...
"_wrapper"浏览开始...
"_wrapper"浏览结尾...
开始装饰...
传入的函数为：<function func_based_decorator_with_params_1 at 0x000001E80E9A76A8>, 已存入collected_functions
传入的参数有：args=(), kwargs={'string': 'hello_world'}
Function has been wrapped...
不干活儿...
有活儿干了...
开始装饰...
传入的函数为：<function func_based_decorator_with_params_2 at 0x000001E80E9A77B8>, 已存入collected_functions
传入的参数有：args=(), kwargs={'string': 'hello_world'}
Function has been wrapped...
不干活儿...
有活儿干了...
collected_functions:[<function func_based_decorator_with_params_1 at 0x000001E80E9A76A8>, <function func_based_decorator_with_params_2 at 0x000001E80E9A77B8>]

现在我们来聊聊一个大主旨：

用类的方式写装饰器

该部分请各位同学重点关注一下传参装饰器，因为笔者认为严格意义上用类的方式写的传参解释器是阉割版的，嗯，就是不完整的意思。。。 请在运行结果中密切关注是否有传入代码倒数第二行class_based_decorator_with_params函数的参数string='能看到我吗'的出现。。。

# 把Ta们放在一起是为了让大家能更方便地看清无传参装饰和有传参装饰器的比对区别。

collected_functions = []  # 用于收集使用过decorator_with_params装饰器的函数

class ClsBasedDecoratorWithoutParams(object):
    """
    基于类的无传参装饰器。
    """
    def __init__(self, original_func):
        print('在基于类的装饰器中...')
        print('传入的函数为：{}'.format(original_func))
        self._func = original_func

    def __call__(self, *args, **kwargs):
        print('开始装饰...')
        print('传入的参数：args={}, kwargs={}'.format(args, kwargs))
        collected_functions.append(self._func)
        self._func(*args, **kwargs)
        print('有活儿干了...')
        return self._func


class ClsBasedDecoratorWithParams(object):
    """
    基于类的传参装饰器。
    """
    def __init__(self, *_args, **_kwargs):
        print('在基于类的装饰器中...')
        print('装饰器接收到的参数是：args={}, kwargs={}'.format(_args, _kwargs))

    def __call__(self, original_func):
        print('传入的函数为：{}'.format(original_func))
        collected_functions.append(original_func)
        original_func()
        print('有活儿干了...')
        return original_func


if __name__ == '__main__':
    @ClsBasedDecoratorWithoutParams  # 无传参装饰器
    def class_based_decorator_without_params(string):
        print('不干活儿...')

    class_based_decorator_without_params(string='hello_world')


    @ClsBasedDecoratorWithParams('hello')  # 有传参装饰器
    def class_based_decorator_with_params(*args,**kwargs):
        print('不干活儿...')


    class_based_decorator_with_params(string='能看到我吗')

    print('collected_functions:{}'.format(collected_functions))

运行结果：
在基于类的装饰器中...
传入的函数为：<function class_based_decorator_without_params at 0x00000272DEAF2C80>
开始装饰...
传入的参数：args=(), kwargs={'string': 'hello_world'}
不干活儿...
有活儿干了...
在基于类的装饰器中...
装饰器接收到的参数是：args=('hello',), kwargs={}
传入的函数为：<function class_based_decorator_with_params at 0x00000272DEB476A8>
不干活儿...
有活儿干了...
不干活儿...
collected_functions:[<function class_based_decorator_without_params at 0x0000012FAD332C80>, <function class_based_decorator_with_params at 0x0000012FAD3876A8>]

'能看到我吗'？我反正是没看到，CPython解释器中是否有机制可以让我获取这个参数(param)呢？如果你知道怎么使Ta不被阉割，感谢留言。

最后一个主题就是：

写使用于类的装饰器

其实本小文的开头，咱们已经实现了这个功能，请看最开始的代码示例。简单地说，只要能骑上哪个object，就能传ta进自己肚子里。。。 由于类经常使用Mixin抽象类的多继承来实现功能扩展，在实际开发中笔者个人并无用到这种方式来扩展或者改变类中的方法。
接下来，我就用类的方式来实现一个简单的用于类的装饰器吧。

class ClsUsingDecoratorWithoutParams(object):
    """
    使用于类的无传参装饰器。
    """
    def __init__(self, original_cls):
        print('在适用于类的装饰器中...')
        self._cls = original_cls
        print(self._cls)

    def __call__(self, *args, **kwargs):
        print('在适用于类的装饰器的__call__中...')
        print('接收到的参数：args={}, kwargs={}'.format(args, kwargs))
        return self._cls(*args, **kwargs)


class ClsUsingDecoratorWithParams(object):
    """
    使用于类的传参装饰器。
    """
    def __init__(self, *_args, **_kwargs):
        print('在基于类的装饰器中...')
        print('装饰器接收到的参数是：args={}, kwargs={}'.format(_args, _kwargs))

    def __call__(self, original_cls):
        print('传入的类为：{}'.format(original_cls))
        print('有活儿干了...')
        return original_cls


if __name__ == '__main__':
    @ClsUsingDecoratorWithoutParams
    class ClsUsingTestingI(object):
        def __init__(self, *args, **kwargs):
            print('ClsUsingTestingI接收到的参数：args={}, kwargs={}'.format(args, kwargs))


    cls_using_obj_i = ClsUsingTestingI(string='HelloWorld')
    print(cls_using_obj_i)


    @ClsUsingDecoratorWithParams('Hi')
    class ClsUsingTestingII(object):
        def __init__(self, *args, **kwargs):
            self.kwargs = kwargs
            print('ClsUsingTestingII接收到的参数：args={}, kwargs={}'.format(args, kwargs))


    cls_using_obj_ii = ClsUsingTestingII(string='HelloWorld')

    print('cls_using_obj_ii:{}'.format(cls_using_obj_ii))
    print('cls_using_obj_ii.kwargs:{}'.format(cls_using_obj_ii.kwargs))

运行结果：
在适用于类的装饰器中...
<class 'main.ClsUsingTestingI'>
在适用于类的装饰器的call中...
接收到的参数：args=(), kwargs={'string': 'HelloWorld'}
ClsUsingTestingI接收到的参数：args=(), kwargs={'string': 'HelloWorld'}
<main.ClsUsingTestingI object at 0x000002337298D748>
在基于类的装饰器中...
装饰器接收到的参数是：args=('Hi',), kwargs={}
传入的类为：<class 'main.ClsUsingTestingII'>
有活儿干了...
ClsUsingTestingII接收到的参数：args=(), kwargs={'string': 'HelloWorld'}
cls_using_obj_ii:<main.ClsUsingTestingII object at 0x000002337298D780>
cls_using_obj_ii.kwargs:{'string': 'HelloWorld'}

感谢您的支持和打赏 (=￣ω￣=) --> BuyMeACoffee(Paypal)

如果喜欢这篇文章，记得收藏和点 ❤ 噢 ~ ~