24. 装饰器语法与应用

爱被打了一巴掌 2024-03-24 18:49 151阅读 0赞

![在这里插入图片描述][32a5086978314bda972f9e5e080d4622.png]

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函数，赋值给了old
    old()
    
    ---
    我是外函数中的内函数1
    我是一个普通的函数
    我是外函数中的内函数2

是不是稍显繁杂？那让我们换个思路，现在我们已经先定义好了`outer`he `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

![在这里插入图片描述][8fbac76f4f104f65bf055c6d91c06526.gif]

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

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

# 定义一个统计函数执行时间的装饰器
    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`这个函数最后执行的时间，那现在的问题是，统计时间的函数是一个通用函数，我们很多函数中都需要用到它进行统计。但是我们总不能所有的函数都要用这种方法重新赋值之后再调用吧？

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

# 定义一个普通函数
    @runtime
    def 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
        
    @begin
    def 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
    @begin
    def love():
        print('跟妹子畅谈人生和理想... 3')
    
    love()
    
    ---
    和妹子一起吃了个大餐.. 2
    找妹子要微信，成功... 1
    跟妹子畅谈人生和理想... 3
    送妹子回家... 5
    和妹子看了一场夜场电影... 4

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

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

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

1.  先使用离得最近的`begin`装饰器，装饰`love`函数，返回了一个`begin_inner`函数
2.  在使用上面的`evolve`, 装饰了上一次返回的`begin_inner`函数，又返回了一个`evolve_inner`函数。

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

![在这里插入图片描述][542855d4ee664f3eb2d74a0fa9985f4d.png]

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

##### 装饰带有参数的函数 #####

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

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

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

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

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

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

# 定义装饰器
    def outer(f):
        def inner():
            print(f'找到妹子，成功的拿到了微信...')
            f()
            print(f'约妹子去看一场午夜电影...')
        return inner
    
    @outer
    def 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
    
    # 带有参数的函数
    @outer
    def 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
    
    # 定义多参数的函数
    @outer
    def 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")`][login_required_redirect_field_name_my_redirect_field]。

![\{% asset\_img image-20230819183310594.png img %\}][asset_img image-20230819183310594.png img]

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

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

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

@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.newinner
    def 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 ==> Demo
    class 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() ==> obj
    obj.func()
    obj.func2()
    print(obj.name)

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

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

print(obj)
    
    ---
    ???

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

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

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

好，下课。

[32a5086978314bda972f9e5e080d4622.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/8bf3dc9a401d489bac4c6cfb7fec02d1.png
[8fbac76f4f104f65bf055c6d91c06526.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/b80fe29b62374b478e05b5228be1262c.png
[542855d4ee664f3eb2d74a0fa9985f4d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/5772d6cf81e849f28785607aa6022d20.png
[login_required_redirect_field_name_my_redirect_field]: https://docs.djangoproject.com/en/4.2/topics/auth/default/#how-to-log-a-user-in
[asset_img image-20230819183310594.png img]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/47b3333df06d4aa684d94eee92634edf.png