写点什么

24. 装饰器语法与应用

作者:茶桁
  • 2023-08-20
    上海
  • 本文字数:8331 字

    阅读完需:约 27 分钟

24. 装饰器语法与应用

Hi, 大家好。我是茶桁。


在最近几期的课程中,相信小伙伴们都频繁的看到一个词:「装饰器」, 那到底什么是装饰器,又有什么作用呢?我们这节课,就来好好的来了解一下。

装饰器定义

装饰器就是在不改变原有函数代码,且保持原函数调用方法不变的情况下,给原函数增加新的功能(或者给类增加属性和方法)。


**核心思想:**用一个函数(或者类)去装饰一个旧函数(或者类),造出一个新函数(或者新类)。


**应用场景:**引入日子,函数执行时间的统计,执行函数钱的准备工作,执行函数后的处理工作,权限校验,缓存等。


**语法规则:**在原有的函数上加上@符,装饰器会把下面的函数当作参数传递到装饰器中,@符又被称为「语法糖」。

装饰器原型

装饰器其实就是利用闭包,把函数当作参数传递,并在在函数内去调用传递进来的函数,并返回一个函数。


来,我们还是用代码来学习,先让我们定义一个普通函数:


# 定义一个普通函数def old():    print('我是一个普通的函数')
old() # 作为普通函数直接调用
---我是一个普通的函数
复制代码


现在让我们定义一个嵌套函数,分为外函数和内函数两部分:


# 定义外函数,接受一个函数作为参数def outer(f):    # 定义内函数, 并且在内函数中调用了外函数的参数    def inner():        print('我是外函数中的内函数1')        f()        print('我是外函数中的内函数2')    return inner
复制代码


这里面我们在内函数中打印了两句话,在两句话中间执行了一次外函数的参数(传递进来一个函数)。最后讲内函数作为参数返回。


然后我们讲刚才的普通函数old作为参数传进去,然后再用外函数返回的inner内函数重新赋值普通函数old,最后让我们再执行一遍old函数, 这个时候,因为old被重新赋值,其实等同于调用了inner函数。来,我们看看结果:


old = outer(old) # outer返回了inner函数,赋值给了oldold()
---我是外函数中的内函数1我是一个普通的函数我是外函数中的内函数2
复制代码


是不是稍显繁杂?那让我们换个思路,现在我们已经先定义好了outerhe inter,两者关系不变。还是之前那些代码,那么我们如何利用装饰器来进行调用呢?


# 装饰器用法@outer # 此处将outer作为了装饰器def old():    print('我是一个普通的函数')
复制代码


我们在定义old函数的时候,直接加上一个@语法糖,就将outer作为了装饰器。这个装饰器的作用就等同于old = outer(old)。那让我们打印看看结果:


old()
---我是外函数中的内函数1我是一个普通的函数我是外函数中的内函数2
复制代码


那我们现在完成了装饰器的用法,按照定义,我们在不改变old函数的代码,且保持了old函数调用方法不变的情况下,增加了新的方法outer


old函数经过outer装饰器进行了装饰,代码和调用方法不变,但是函数的功能发生了改变。


你是不是这个时候又有疑问了,那装饰器要用在什么地方呢?让我们来实现一个应用:

装饰器应用:统计函数的执行时间

在正式写代码之前,我还是习惯带着大家先思考一遍。我们需要统计函数的执行时间,那我们需要什么关键点?


  1. 开始时间,

  2. 结束时间

  3. 开始时间和结束时间之间,就是程序在运行的过程。


好的,让我们来开始写代码,先来一段简单的需要运行的程序,为了能顺利统计时间,我们给它设定两个东西,一个循环,一个停止运行时长。这样,我们不会因为程序运行过快而看不到结果:


import time
# 定义一个普通函数def func(): for i in range(5): print(i, end=" ") time.sleep(1)
复制代码


函数写完之后,让我们来执行一下看看:


func()
---0 1 2 3 4
复制代码



没问题,确实是一秒打印一次。


现在,再来让我们完成要称为装饰器的统计函数:


# 定义一个统计函数执行时间的装饰器def runtime(f):    def inner():        start = time.perf_counter()        f()        end = time.perf_counter() - start        print(f'\n函数的调用执行时间为:{end}')    return inner
复制代码


在函数inner中,我们最终是打印了最终的时间end, 然后将整个inner函数返回。


那么,让我们来尝试执行一下看看吧:


func = runtime(func)func()
---0 1 2 3 4 函数的调用执行时间为:5.017943917075172
复制代码


这样,我们就得到了func这个函数最后执行的时间,那现在的问题是,统计时间的函数是一个通用函数,我们很多函数中都需要用到它进行统计。但是我们总不能所有的函数都要用这种方法重新赋值之后再调用吧?


那我们就用装饰器来解决就好了:


# 定义一个普通函数@runtimedef func():  for i in range(5):    print(i, end=" ")    time.sleep(1)    func()
---0 1 2 3 4 函数的调用执行时间为:5.017888417001814
复制代码


当然,最终这种函数的调用执行时间并不会像现在这样打印到前台,而是会写进log变为日志存储起来,便于之后分析使用。

装饰器嵌套语法

在这一段代码中,我们来约个妹子,完成一场约会。从哪开始呢?就从找妹子要微信开始吧:


def begin(f):    def begin_inner():        print('找妹子要微信,成功...')        f()        print('送妹子回家...')    return begin_inner    @begindef love():    print('跟妹子畅谈人生和理想...')
love()
---找妹子要微信,成功...跟妹子畅谈人生和理想...送妹子回家...
复制代码


那这样,我们实现了一段最普通装饰器的定义。现在让我们在下面再定义一个装饰器函数,为什么呢?因为我渐渐不满足于只谈理想和人生了,要有点实际的行动了,顺便,我们写了一个列表,把和妹子要做的事情都列了个顺序,再来看看:


def begin(f):    def begin_inner():        print('找妹子要微信,成功... 1')        f()        print('送妹子回家... 5')    return begin_inner
def evolve(f): def evolve_inner(): print('和妹子一起吃了个大餐.. 2') f() print('和妹子看了一场夜场电影... 4') return evolve_inner
@evolve@begindef love(): print('跟妹子畅谈人生和理想... 3')
love()
---和妹子一起吃了个大餐.. 2找妹子要微信,成功... 1跟妹子畅谈人生和理想... 3送妹子回家... 5和妹子看了一场夜场电影... 4
复制代码


这个...顺序似乎不太对啊。让我们改变一下装饰器的顺序试试:


@begin@evolvedef love():    print('跟妹子畅谈人生和理想... 3')
love()
---找妹子要微信,成功... 1和妹子一起吃了个大餐.. 2跟妹子畅谈人生和理想... 3和妹子看了一场夜场电影... 4送妹子回家... 5
复制代码


这回没错了,我们在最开始要妹子微信和最后送妹子回家中间,又进行了点什么。也算是有些进展了。那么,我们怎么去理解这个程序运行顺序呢?


  1. 先使用离得最近的begin装饰器,装饰love函数,返回了一个begin_inner函数

  2. 在使用上面的evolve, 装饰了上一次返回的begin_inner函数,又返回了一个evolve_inner函数。


在调用完成之后,就是需要顺序执行了,其执行的嵌套关系和顺序如下:



那这,就是我们嵌套装饰器的用法。当然,这种嵌套装饰器的用法并不常见,可是一旦我们遇到了,要理解他的运行机制和顺序,避免不必要的麻烦。

装饰带有参数的函数

上一个部分,我们做了一个约会妹子的函数,并且使用装饰器进行了装饰。使的我们成功的按照进度依次执行了自己的计划。


但是问题来了,我们到目前为止约会了那么多妹子,都不知道谁是谁(海王体质),这可怎么办。这次,我们吸取教训,先要名字,既然之前的流程很成功,我们直接拿来使用就行了。但是繁杂的步骤我们都去掉,直奔主题:


# 带有参数的函数def love(name):    print(f'跟{name}妹子在___畅谈人生...')
复制代码


一个简单的函数,并且是一个填空题,你愿意待谁去哪里畅谈人生,随便。比如我,找「露思」去,去了哪里,恕不奉告了:


love('露思')
---跟露思妹子在___畅谈人生...
复制代码


可是即便如此,该有的流程还是不能丢,总不能凭空变出个妹子吧,还是得把必要的流程加上,原本定义的装饰器函数似乎不能使用了:


# 定义装饰器def outer(f):    def inner():        print(f'找到妹子,成功的拿到了微信...')        f()        print(f'约妹子去看一场午夜电影...')    return inner
@outerdef love(name): print(f'跟{name}妹子在___畅谈人生...')
复制代码


流程上现在是没问题了,可是我们执行一下发现,报错了。


love('露思')
---TypeError: outer..inner() takes 0 positional arguments but 1 was given
复制代码


进行不下去了吧?那没办法,谁叫你之前和之后都把人家名字忘了呢,海王也得有点职业道德才行。既然我们在执行的时候有参数,那你整个过程中都得带上才行。不能玩着玩着忘记人家名字,对吧。让我们改进一下,既然我们已经知道,在使用装饰器装饰过后的love()执行实际上是执行装饰器inner, 那我们尝试给inner加上参数进行传递,还有很重要的,我们之前和之后,得把妹子名字记清楚才行,所以执行的时候也记得加上:


# 定义装饰器def outer(f):    def inner(var):        print(f'找到{var}妹子,成功的拿到了微信...')        f(var)        print(f'约{var}妹子去看一场午夜电影...')    return inner
# 带有参数的函数@outerdef love(name): print(f'跟{name}妹子在___畅谈人生...')
love('露思')
---找到露思妹子,成功的拿到了微信...跟露思妹子在___畅谈人生...约露思妹子去看一场午夜电影...
复制代码


嗯,这样一场和「露思」妹子之间完美的从认识到约会流程就完成了。我们总结一下:


如果装饰器带有参数的函数,需要在内函数中定义形参,并传递给调用的函数。因为调用原函数等于调用内函数。

装饰多参数的函数

上一个流程跑完之后呢,我觉得还是不太妥当。主要是其中有两个选择题,一个是谁,一个是去哪里。对吧。再说了,我也得跟妹子自我介绍一下,加强一点印象。


好,我们这次再多设置几个参数,让整个约会过程更完善一些,那我们从最初就要规划一下,需要的参数包括:我,妹子,地点,行为等等。还蛮多的。


# 装饰带有多参数的函数def outer(f):    def inner(man,name,*args,**kwargs):        print(f'{man}要到了{name}妹子的微信...')        f(man, name, *args, **kwargs)        print('天色渐晚...')    return inner
# 定义多参数的函数@outerdef love(man, name, *args, **kwargs): print(f'{man}跟{name}畅谈人生...') print(f'带{name}妹子去吃了很多美食:', args) print(f'和{name}妹子看了夜场电影:', kwargs)
复制代码


这样我们就定义好了,至于*args以及**kwargs是什么,可以翻看之前的教程。


让我们现在来执行一下:


love('茶桁','露思', '火锅', '海鲜', '饭后甜点', mov='封神第一部')
---茶桁要到了露思妹子的微信...茶桁跟露思畅谈人生...带着露思妹子去吃了很多美食: ('火锅', '海鲜', '饭后甜点')和露思妹子看了夜场电影: {'mov': '封神第一部'}天色渐晚...
复制代码


这样,多道选择题就被我们一一的化解了。相信「露思」妹子对我们的整体安排也是相当的满意了。

带有参数的装饰器

在我们平时使用 Python 各种第三方库的时候,不可避免的会遇到带有参数的装饰器。比如说,Django框架中的@login_required(redirect_field_name="my_redirect_field")



这种带有参数的装饰器是干嘛的呢?还是拿我们之前的海王约会流程来举例。之前的流程是都没有什么问题,可是有没有发现,所有事情都是我们自己做主了,似乎妹子一直都没有反对过,也没有说自己想要什么。这是不是不太符合现实?


没错,我们也要给妹子装上一个会思考的大脑,也要学会做判断,好,让我们来实现一下:


既然我们这节是学习带有参数的装饰器,那么必然装饰器上是带参数的。呃,不要认为这句话是废话,我们看代码:


@put(var)def love():    print('畅谈人生...')
复制代码


就像这样,我们给装饰器加上了参数。


那么现在问题就来了,我们来看看我们之前写的装饰器函数:


def outer(f):  def inner():    pass  return inner
复制代码


发现有什么问题了么?虽然我们的外层函数outer是有形参的,但是我们之前的过程中了解到,这个形参f是为了接收当前执行函数的。那还有什么其他地方接收非函数的普通参数嘛?


既然outer中很重要的作用,除了接收函数在内函数内执行,还有一个就是返回inner内函数,那么我们在不改变outer的基础之上,再加一个接收普通参数的函数不就行了。


def put(var):    def outer(f):        def inner1():            print('妹子给了你微信')        def inner2():            print('妹子给了你她闺蜜的微信')        def inner3():            print('妹子送了你一句感人肺腑的话:滚...')
# 装饰器壳的参数,可以用于在函数内去做流程控制。 if var == 1: return inner1 elif var == 2: return inner2 else: return inner3 return outer
@put(2)def love(): print('畅谈人生...')
复制代码


定义完成之后,我们来执行一下看看:


love()
---妹子给了你她闺蜜的微信
复制代码


家人们谁懂啊,妹子真把我当海王了嘛?最后,我还是老老实实的接受了妹子的好意。


从整段代码中我们可以看出来,如果装饰器中有参数,需要有一个外壳函数来接收参数,传参之后就会进入到下一层函数中,并且传递当前对象。再然后才会再进入下一层中去。当然,我们在这里,利用传递的参数写了一段if判断,用于确定妹子的决定是什么。然后我们就返回哪个决定的函数。最后别忘记,在外壳函数中,我们还需要讲outer函数返回出去。此时虽然love函数是outer函数,但是在之前,put装饰器已经将参数传递给了外壳函数put(var)。在装饰器函数的争端代码中,我们都没有再执行过传进来的参数,也就是函数love(), 所以此段代码中love函数中的打印方法并未执行。


其执行步骤为:


put(var) => outer() => outer(love) => inner2()
复制代码

用类装饰器装饰函数

之前我们所有的代码中,装饰器一直使用的都是函数装饰器。那我们能否用类来当装饰器装饰函数呢?


试试不就知道了。


# 类装饰器装饰函数class Outer():    def __call__(self, func):        self.func = func        return self.inner        def inner(self, who):        print('拿到妹子的微信...')        self.func(who)        print('看一场午夜电影...')@Outer()def love(who):    print(f'{who}和妹子谈理想与人生...')
复制代码


写完了,这下我们省略了那么多杂七杂八的流程,因为我发现,那么多流程下来,最终感动的人只有自己。妹子愿意,怎么都愿意,不愿意的,无论做多少都不愿意。


来,让我们跑一下程序试试:


love('茶桁')
---拿到妹子的微信...茶桁和妹子谈理想与人生...看一场午夜电影...
复制代码


没问题,正确的执行。那这个时候的love函数到底是什么呢?我们来打印出来看看:


print(love)
---<bound method Outer.inner of <__main__.Outer object at 0x106646c80>>
复制代码


可以看到,此时的love函数就是Outer类中的inner函数。那我们怎么理解整个代码呢?


我们在love函数上使用了装饰器Outer, 那么这个时候Outer就会实例化出来一个对象obj,然后这个@obj就等同于obj(love)


然后我们实例化对象进入Outer()内部,进入之后遇到了魔术方法__call__, 它会把该类的对象当作函数调用时自动触发。也就是obj()触发。


还记得类的实例化么?会传入一个参数,也就是实例化对象本身:obj。并且,第二个参数func用来接收了传递进来的函数love, 设置了self.func = func, 把传进来的函数作为对象的成员方法。最后返回了一个函数inner, 这个返回的函数是类中定义好的,于是作为实例化对象也将这个成员方法继承了下来,所以self.inner可以直接被返回出去。


这个定义好的inner接收了两个形参,一个是实例化对象本身,一个就是传递进来的函数love的参数who。然后,中间执行了一下魔术方法__call__内定义好的self.func(who),实际上也就是obj.love(who)


看着迷糊?这样,我写一个注释过的完整版本。


# 类装饰器装饰函数class Outer():
# 魔术方法:当把该类的对象当作函数调用时,自动触发obj() def __call__(self, func): # 把传进来的函数作为对象的成员方法 self.func = func # 返回一个函数 return self.inner # 在定义的需要返回的新方法中,去进行装饰和处理 def inner(self, who): print('拿到妹子的微信...') self.func(who) print('看一场午夜电影...')'''Outer() 实例化对象 => obj@obj 就等于 obj(love)进入类后 => __call__(love)接收返回参数`inner()`'''@Outer()def love(who): print(f'{who}和妹子谈理想与人生...')
# inner('茶桁')love('茶桁')# 此时的love就是属于`Outer`类这个对象中的inner方法print(love)
复制代码


不知道这段注释代码加上刚才的解说,大家能否看懂?有没有发现,用类做装饰器比起函数装饰器反而更清晰一点?不需要写那么多外层函数和内层函数。


让我们继续...

类方法装饰函数

刚才我们将整个类都用作了一个装饰器,那我们思考一下,是不是我们还可以用类中的方法来做装饰器呢?


说干就干,直接上代码测试:


# 用类方法装饰函数class Outer():    def newinner(f):        # 把传递进来的函数定义为类方法        Outer.func = f        # 同时返回一个新的类方法        return Outer.inner        def inner():        print('拿到妹子微信...')        Outer.func()        print('看一场午夜电影...')
'''Outer.newinner(love) 接收返回参数:Outer.inner'''
@Outer.newinnerdef love(): print('和妹子谈谈人生喝喝茶...')# love() 等于 Outer.inner()love()
---拿到妹子微信...和妹子谈谈人生喝喝茶...看一场午夜电影...
复制代码


在经历了几场约会之后,我们的耐心也渐渐没了。连是谁都不管,也没耐心去谈理想了。喝点茶聊聊天就直奔主题了都是。


到目前为止以上所有形式的装饰器,包括「函数装饰器」、「类装饰器」、「类方法装饰器」,都有一个共同特点:都是在给函数去进行装饰,增加功能


那我们这个时候就不满足了,既然能装饰函数,那是否也能装饰类呢?

用装饰器装饰类

还真有一种装饰器是专门装饰类的,也就是在类的定义的前面使用@装饰器这种语法。和装饰函数并无什么区别,只是放在了类前面而已:


@装饰器class Demo():    pass
复制代码


装饰器给函数进行装饰,目的是不改变函数调用和代码的情况下给原函数增加新的功能。


装饰器给类进行装饰,目的是不改变类的定义和调用的情况下给类增加新的成员(属性或者方法)。


来,让我们具体的看看:

函数装饰器装饰类

# 定义函数,接收一个类。返回修改后的类def expand(cls):    def func2():        print('我是在装饰器中追加的新方法,func2')    cls.func2 = func2 # 把刚才定义的方法赋值给 类    cls.name = '我是在装饰器中追加的新属性 name'
# 返回时,把追加类新成员的类返回去 return cls

@expand # expand(Demo) ==> cls ==> Democlass Demo(): def func(): print('我是Demo类中定义的func方法')
Demo.func() # 此时在调用的Demo类是通过装饰器,更新过的Demo类Demo.func2()print(Demo.name)
---我是Demo类中定义的func方法我是在装饰器中追加的新方法,func2我是在装饰器中追加的新属性 name
复制代码


这样,我们在原来的Demo这个类中,使用装饰器增加了一个成员方法func2,并且增加了一个成员属性name, 并最终返回到原始类中。从而扩展了这个原始类Demo中的方法和属性。

类装饰器装饰类

# 使用类装饰器装饰类class expand():    def __call__(self, cls):        # 把接收的类,赋值给当前对象,作为一个属性        self.cls = cls        # 返回一个函数        return self.newfunc
def newfunc(self): self.cls.name = '我是在类装饰器中追加的新属性 name' self.cls.func2 = self.func2 # 返回传递进来的类的实例化结果,obj return self.cls()
def func2(self): print('我是在类装饰器中追加的新方法 func2')

'''expand() ==> obj ==> @obj(Demo) ==> __call__(Demo) ==> newfunc'''@expand() class Demo(): def func(self): print('我是Demo类中定义的func方法')
obj = Demo() # Demo() ==> newfunc() ==> objobj.func()obj.func2()print(obj.name)
复制代码


在之前那么多案例过后,相信大家这一段代码应该能看的出来吧。


那我这个地方要处一个思考题了,请问:此时的 obj这个对象,是哪个类的对象。Demo还是expand?


print(obj)
---???
复制代码


这个问题的答案,我放在源码中了,大家要记得思考之后再去看答案。


那么,本节课的内容到这里也就结束了。


课程进行到这里,我们 Python 本身的所有内容就已经介绍完了。下节课开始,我们就要考试讲第三方库。


好,下课。

发布于: 刚刚阅读数: 5
用户头像

茶桁

关注

还未添加个人签名 2020-10-20 加入

还未添加个人简介

评论

发布
暂无评论
24. 装饰器语法与应用_Python_茶桁_InfoQ写作社区