Python装饰器详解

Python装饰器可以在不改变函数原实现方式的前提下，为函数添加额外的功能。装饰器的功能并不费解（func = decorator(func) ），但具体实现时有一些细节还是需要搞明白。

一、函数装饰器

为表述方便，下面例子decorator开头的表示装饰器函数，func表示被装饰函数。

1. decorator不带参数

#不带参数的装饰器

def decorator_without_args(func):
    def wrapper(msg):
        print('I got a decorator')
        return func(msg)
    return wrapper

@decorator_without_args
def func(msg):
    print(f'msg is : {msg}')
    
func('hello world')

输出如下：

I got a decorator
msg is : hello world

上面就是最简单的装饰器，值得注意的是：

• 不带参的decorator装饰函数时，勿带括号@decorator_without_args
• 装饰器外层函数的return不加括号，如return wrapper
• func本身传给外层的函数decorator_without_args()，而func的参数msg则传给内层函数wrapper()
• func本身def func(msg)，与def wrapper(msg)以及wrapper中return func(msg)的参数个数必须保持一致，不一致就会报错。这个特性可以理解为装饰器的内层函数（wrapper）有两个使命：首先是添加额外的功能，其次是将被装饰函数（func）的参数msg接收过来，以便最后rerun func(msg)。而第二点其实和装饰器本身想实现的功能是无关的，所以为了有更好的通用性，我们可以将装饰器改造为以下形式，这也是日常所见到的最普遍的形式：

def decorator_without_args(func):
    def wrapper(*args, **kwargs):
        print('I got a decorator')
        return func(*args, **kwargs)
    return wrapper

2. decorator带参数
   实际项目中，除了func本身需要传参外，有时候decorator也需要传入参数，此时写法略有不同：

#带参数的装饰器

def decorator_with_args(flag):
    def decorator(func):
        def wrapper(*agrs, **kwargs):
            if flag:
                print('flag is True')
            else:
                print('flag is False')
            return func(*agrs, **kwargs)
        return wrapper
    return decorator

@decorator_with_args(True)
def func(msg):
    print(f'msg is : {msg}')

func('hello world')

值得注意的是：

• 以上示例相当于func = decorator_with_args(flag)(func)
• 带参的decorator装饰函数时，请加上括号并传入需要的参数 @decorator_with_args(True)
• 一共有三层，最外层用于接收装饰器函数的参数，内层和不带参的装饰器一样。因此可以得出结论：若装饰器函数带参，需要写成三层，最外层用于接收装饰器函数的参数，中间一层接受被装饰函数func，最里面一层用于接收被装饰函数func的参数(*args, **kwargs)

二、类的装饰器

表示在类上使用的装饰器，类是被装饰对象，请区分“类装饰器”，举个最经典的例子—装饰器实现单例模式：

# 类的装饰器

def decorator_singleton(cls):
    def wrapper(*args, **kwargs):
        if not hasattr(cls, '_instance'):
            print('I am created firstly.')
            cls._instance = cls(*args, **kwargs)
        else:
            print('I have been created,so I am just an old instance!!!')
        return cls._instance
    return wrapper

@decorator_singleton
class Register:
    pass

a = Register()
b = Register()
id_a = id(a)
id_b = id(b)

print(f'a id is:{id_a} \nb id is:{id_b}')

输出如下：

I am created firstly.
I have been created,so I am just an old instance!!!
a id is:140077188368368 
b id is:140077188368368

可以看出来，单例装饰器起到了作用，执行过程可以这么表示：

Register = decorator_singleton（Register）

相当于将类本身作为参数传给装饰器，最后装饰器再返回一个实例对象。事实上，把Register视作一个函数就很好理解了，毕竟Register实例化时，也要执行Register()。

三、类装饰器

表示类作为装饰器，此时装饰器是用类实现的，与“类的装饰器”做区分。

# 类装饰器

class Decorator:

    def __init__(self, func):
        print('I am initialing')
        self.func = func

    def __call__(self, *args, **kwargs):
        print('I am called')
        return self.func(*args, **kwargs)
    
@Decorator
def func(msg):
    print(f'msg is {msg}')

func('hello world')

输出：

I am initialing
I am called
msg is hello world

如果明白了装饰器的原理，类装饰器也很好理解。事实上，任何类型装饰器，要起到作用，有两个隐式前提:

• 装饰器本身是一个可调用对象（callable），毕竟本质上绕不开func = decorator(func)

• 必须向装饰器传入两类参数：一是func本身，而是func的参数（*args, **kwargs）

在Python中，对于类对象class，只要实现了__call__()方法，该类实例化后就可以像调用函数一样使用这个实例。上面示例中，类Decorator实例化后可以像函数一样被调用，这就满足了装饰器第一个前提。
对于第二个前提，众所周知，类的初始化变量可以通过__init__()接收，因此，通过init将func传入类中，而func中参数则被传到了__call__()中。类的实例化过程想必大家也都知道，总是先执行init()，因此I am initialing最先被打印出来。此处小伙伴可能有疑问了，可不可以将func和func中参数全都传给__call__()，从而省去__init__()呢？或者说，可不可以将func和func中的参数全都传给__init()__而省去__call__()呢？答案是不可以。事实上，装饰的过程分为两步：

func = decorator(func)
func(args)

两类参数（被装饰函数本身，及其参数）也是分两次传入装饰器的。对于类装饰器，第一步其实是实例化类装饰器，所以func只能传给__init__()。而func的args则必须传给__call__()，至于为什么，请看下面结论。此处有没有似曾相识的感觉？其实跟函数装饰器func要传给外层函数，args传给内层函数一个道理。

三、结论

坚持看完的小伙伴下次一定对装饰器的原理了然于胸了。而且可能还有额外的收获，比如类装饰器的原理其实跟类实现了__call__()就可以像函数那样调用的原理一样，来看例子：

class CallTest:
    def __init__(self):
        pass
    def __call__(self, msg):
        print(msg)

ct = CallTest()
ct('I am called'）

输出：

I am called

这个例子可以明显看出来，类在实例化出对象后，对象的参数其实就是传给了__call__()了。一言以蔽之，Python的()运算符其实就是__call__()，再来看上面类装饰器装饰的过程：

func = decorator(func)
func(args)

第二步func(args)本质上就是func.__call__(agrs)，所以agrs只能传给__call__()。