Python装饰器详解

Python装饰器详解,第1张

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
  1. 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__()

欢迎分享,转载请注明来源:内存溢出

原文地址: http://outofmemory.cn/langs/866741.html

(0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
上一篇 2022-05-12
下一篇 2022-05-12

发表评论

登录后才能评论

评论列表(0条)

保存