Python【修饰器/装饰器】专题,不动已有代码,增加新功能的好方法!

修饰器(装饰器)在Python中也是一个很重要的内容,它可以让其他函数在不需要做任何代码变动的前提下增加额外功能,相当于一个语法糖,可能在新手看来,这是一个难以理解或者不知道有啥用的存在,但后面你多多少少都要碰到或者用到它的。

Python【修饰器/装饰器】专题,不动已有代码,增加新功能的好方法!_第1张图片


一、修饰器的概念和作用

1.什么是修饰器?

修饰器又叫装饰器,本身也是一个函数,是在原有的函数或者是方法上增添一些额外的功能。


2.修饰器的作用

概括的讲,装饰器的作用就是为已经存在的对象添加额外的功能

比如说这个函数是注册的功能,但有时候这个用户在执行这个操作的时候,他是已注册的用户,我这个函数已经写好了,不想动它了,那么我们就可以通过修饰器来给这个函数增加一个登录的功能。

它经常用于有切面需求的场景,比如:插入日志、性能测试、事务处理、缓存、权限校验等场景。装饰器是解决这类问题的绝佳设计,有了装饰器,我们就可以抽离出大量与函数功能本身无关的雷同代码并继续重用。

Python【修饰器/装饰器】专题,不动已有代码,增加新功能的好方法!_第2张图片

修饰器的具体操作,我们来慢慢学习。


二、修饰器的使用

1.使用说明

在使用修饰器之前,我们得记住几个关于修饰器的使用说明:

(1)修饰器的关键字是 @ ,Python代码中只要出现了它,你就可以想到是修饰器了。

(2)修饰器修饰的是函数或者是方法,不能修饰一个类

(3)修饰器必须出现在被修饰函数或者方法的前一行,不能够将修饰器定义在函数的同行

例子:

Python【修饰器/装饰器】专题,不动已有代码,增加新功能的好方法!_第3张图片

虽然修饰器本身是一个函数,但它的出现是有规定的,我上面的修饰器就没有出现在被修饰函数或者方法的前1行,所以连 print(“龙叔”) 这一行代码都执行不了。

(4)修饰器本身是一个函数,将被修饰的函数作为参数,传递给修饰器,执行修饰器中功能,返回传递进来的函数对象,调用返回出来的函数

这几个点很重要,下面我们通过修饰器的多种使用方式来加深理解。

Python【修饰器/装饰器】专题,不动已有代码,增加新功能的好方法!_第4张图片


2.基本使用方式

如果被修饰的函数不调用,则执行@后面的函数,并把被修饰的函数当做参数传递过去了,则修饰器函数的返回值可以是任意值

例子:

def dec(a):		#修饰器函数
    print(a)	#看一下形参传了什么
    print("helloworld")
    return None

@dec	#使用修饰器

def funA():		#被修饰的函数
    pass

运行结果:

<function funA at 0x0000018D849BB670>
helloworld

首先我们可以看出来,这就是很简单的一个修饰器的使用例子,用 @dec 来调用dec()修饰器函数,而被修饰的函数funA()是没有进行什么操作的。

其次我们再看,被修饰的函数funA()不调用什么,但却被当做参数传递给了修饰器函数dec(),所以dec()需要一个形参来接受传递值,我用的是a作为形参,如果你去掉a的话,系统就会报错,因为被修饰的函数funA()返回的值没有东西接受,你可以试试。

最后还有1点,被修饰函数funA()并没有被调用,注意到了吗?所以修饰器函数dec()返回什么都可以,上面返回的是None,你返回一个“有病”也可以的,返回什么都可以的,下面我们再看被修饰函数 funA() 被调用的情况。

Python【修饰器/装饰器】专题,不动已有代码,增加新功能的好方法!_第5张图片

如果被修饰的函数调用了,直接执行修饰器,并把被修饰的函数当做参数专递给修饰器,但是修饰器的返回值必须是当前参数

例子:

def dec(a):
    print(a)
    print("helloworld")
    return "有病"

@dec	#使用修饰器函数

def funA():
    pass

funA()	#调用被修饰函数

运行结果:

<function funA at 0x000001F78A48B670>
helloworld
Traceback (most recent call last):
  File "E:\Python-learn\可迭代对象\修饰器\修饰器_test.py", line 11, in <module>
    funA()
TypeError: 'str' object is not callable

出现错误了,说字符串str不能被迭代,为什么?其实原因就是有修饰器存在并使用的情况下,被修饰函数又被调用了,这个时候返回值就不能是任意值了,此时的修饰器函数只能返回传递值,你可以试试把 return “有病” 改成 return a 就可以正常输出了,又或者你去掉 funA() 这一行代码,不调用被修斯函数,则输出也是正常的。

def dec(a):
    print(a)
    print("helloworld")
    return a

@dec

def funA():
    pass

funA()

运行结果:

<function funA at 0x0000020F5664B670>
helloworld

一切正常。

我们再来看看修饰器的执行逻辑是怎么样的:

def dec(a):
    print(a)
    print("修饰器函数")
    return a

@dec

def funA():
    print("被修饰函数")

funA()

print("龙叔")

运行结果:

<function funA at 0x000001D90E75B670>
修饰器函数
被修饰函数
龙叔

从这个运行结果我们可以看出修饰器的运行逻辑是:被修饰的函数 funA() 被调用了,但却没有被直接执行,而是直接执行修饰器dec,并把被修饰的函数 funA() 当做参数专递给修饰器dec,执行修饰函数dec()里面的代码,返回传递值a后才执行的被修饰函数funA()里面的代码,最后走完了被修饰函数funA() 才执行剩余的代码。

我用个比较草一点的图来表示一下:

Python【修饰器/装饰器】专题,不动已有代码,增加新功能的好方法!_第6张图片


3.其他使用方式:函数嵌套

前面我们讲过了修饰器的基本使用方式,修饰器的使用方式很多,还可以使用函数嵌套的方式。

用个简单例子来演示一下:

def A(x):	#修饰器函数
    def B():	#修饰器函数里面嵌套的函数
        print("B")

    B()
    return x


@A	#使用修饰器
def C():	#被修饰函数
    print("C")


C()	#调用被修饰函数

运行结果:

B
C

从运行结果来看,被修饰函数里面也是可以进行函数嵌套的。


4.其他使用方式:闭包

闭包的也是属于函数里的一种,只是比较特殊,关于闭包的知识我这里就不复述了,在【Python基础】里面我们有讲过关于闭包的知识,忘了的可以去看看或者百度一下,我们来看看修饰器里面的闭包是怎么使用的。

def A(x):
    def B():
        print("B")
        return x()  # C 无差别调用只能一层,这里是无法通过x调用

    return B


@A
def C():
    print("C")


C()

运行结果:

B
C

可以看出在修饰器函数中,闭包也是可以正常使用的。

Python【修饰器/装饰器】专题,不动已有代码,增加新功能的好方法!_第7张图片


5.其他使用方式:被修饰的函数有参数的形式

如果被修饰的函数有参数传递,参数只能传给修饰器函数里面的内嵌函数。

def A(x):	#修饰器函数
    print(x)

    def B(aa, bbb):  # 内嵌函数,接收被修饰函数传递的参数
        print("B")
        print(aa, bbb)
        return x(aa, bbb)  # C

    return B


@A
def C(n, nn):	#被修饰函数
    print("C")


C("10", "20")

运行结果:

<function C at 0x00000206BED6B670>
B
10 20
C

可以看出来,虽然被修饰函数 C()传递了参数给修饰器函数 A() ,但是默认传递的还是C()这个对象,修饰器函数A()接受的还是被修饰函数C(),参数传到了修饰器函数A()里面的函数B()。

就算你在A()里面加两个形参,它也接受不了,只会报错,前面在修饰器的使用说明我们已经说了,“被修饰的函数作为参数,传递给修饰器”,所以修饰器函数接受的只是被修饰函数这个对象,其他如果要传递参数,那么修饰器函数里面就就得有其他函数来接受传递的参数。


6.其他使用方式:有参数的修饰器,无参数的函数,使用内嵌函数收取参数

如果修饰器有参数但被修饰函数却没有参数的情况下,只能使用内嵌函数来收取参数。

def fun(a=20):
    print(a)

    def c(bb):
        print(bb)
        return bb  # 可以无差别调用,因为是在第二层才接收的funB,相当于第一层

    return c


@fun(30)
def funB():
    print("xixixi")


funB()

运行结果:

30
<function funB at 0x0000025DAE4DD0D0>
xixixi

三、Python内置的修饰器

前面我们所讲的都是我们自定义的修饰器,在Python中是有内置的修饰器,我们来学习一下常见的三种Python内置修饰器:staticmethod,classmethod,property

它们的作用就是把类中的方法变为静态方法,包括类的类属性和类方法,具体的使用,我们来简单的看一下。

1.property

property可以将方法变为属性,被修饰的方法名必须和property下方的方法名一样,property只能用于私有属性

我们来做一个对比,我们在不使用property的情况下,创建一个类并使用类里面的方法,是这样的:

class A:
    def __init__(self):
        self.age = 20   #实例属性
    def getattr(self):  #打印实例属性
        print(self.age)
    def setattr(self,newage):	#给实例属性赋值
        self.age = newage

a = A()
a.setattr(30)
a.getattr()

运行结果:

30

没有什么问题,运行结果正常,那我们用内置修饰器property来试试看有何不同。

在使用内置修饰器property之前,我们得补充一个点:私有属性,在函数内部创建的属性是私有属性,在不经过特殊处理之前,无法在函数外部使用,私有属性前面加两个下划线表示,比如类里面的__name就表示私有属性,我们通过一个简单的例子来看看:

Python【修饰器/装饰器】专题,不动已有代码,增加新功能的好方法!_第8张图片

可以看出来,私有属性在类内部是可以进行访问的,在外部是不行的(做了一些处理之后是可以访问的,这里就不介绍了,可以网上查一下)。

回到我们的内置修饰器property,在前面不使用property的例子中,我们做一下修改,加入内置修饰器property。

class A:
    def __init__(self):
        self.__age = 20

    @property
    def age(self):	#被修饰的方法
        return self.__age

    @age.getter
    def age(self):	#被修饰的方法
        return self.__age

    @age.setter
    def age(self, newage):	#被修饰的方法
        self.__age = newage


a = A()
a.age = 200
print(a.age)

运行结果:

200

从这个例子我们可以看出,内置修饰器property是可以用于私有属性,并且可以将方法变为属性,比如a.age就是在调用属性而不是方法了,在类中虽然多次出现了age()这个方法但却没有因为方法覆盖而报错,也是因为property的存在,property规定了被修饰的方法名必须和property下方的方法名一样。

Python【修饰器/装饰器】专题,不动已有代码,增加新功能的好方法!_第9张图片

2.staticmethod – 静态方法

内置修饰器staticmethod是一个静态方法,功能是将被修饰的方法从类中抽离出来,成为独立的函数,该函数不能访问类的属性

我们先写一个简单的类,通过使用与不使用staticmethod来做一个对比,不使用的情况下

class B:
    def __init__(self, name):
        self.name = name

    def eat(self):  # 打印传递的值
        print(self.name)


b = B("龙叔")
b.eat()

运行结果:

龙叔

这个没有什么问题,再来看看使用了staticmethod,直接加上看看:

Python【修饰器/装饰器】专题,不动已有代码,增加新功能的好方法!_第10张图片

报错了,原因就是加上了@staticmethod 后,eat()这个方法就变成了一个普通的函数,它的位置虽然在类里面,但实际上却相当于一个普通的函数,并不是类的方法了,所以你得给它传递一个值,不然形参self就没有值传递从而报错了。

正确的写法应该是:

Python【修饰器/装饰器】专题,不动已有代码,增加新功能的好方法!_第11张图片

我们来总结一下这个staticmethod 静态方法:

1. 这个函数是一个普通函数,只有这个类能用
2. 静态方法可以设置参数,也可以不需要参数了(self)
3. 该函数不能访问类的属性

3.classmethod

被classmethod修饰的方法,与实例方法的区别是接收的第一个参数不是self,而是cls(当前类的具体类型),被修饰的方法无法访问实例属性,但是可以访问类属性。

class B:
    age = 10

    def __init__(self, name):
        self.name = name

    def sleep(self):    #打印
        print(self)

    @classmethod
    def eat(cls):  # 被修饰的函数
        print(cls)  #看看传递的是类还是值
        print(cls.age)  #访问类的属性
        print(self.name)	#访问实例对象的属性


b = B("龙叔")
b.sleep()
b.eat()

运行结果:

<__main__.B object at 0x0000024FD7B3CFA0>
<class '__main__.B'>
10
Traceback (most recent call last):
  File "D:\pythonProject1\专题2.py", line 21, in <module>
    b.eat()
  File "D:\pythonProject1\专题2.py", line 14, in eat
    print(self.name)
NameError: name 'self' is not defined

通过结果可以看出,从sleep()和eat() 打印的对象来看,sleep()传递的对象是创建的实例对象b,而被修饰器修饰的函数eat()传递的是类;从eat()访问类的属性和实例属性来看,访问类的属性是没有问题的,但访问实例对象的属性时就报错了。

所以验证了前面讲的:被classmethod修饰的方法,与实例方法的区别是接收的第一个参数不是self,而是cls(当前类的具体类型),被修饰的方法无法访问实例属性,但是可以访问类属性。

~

运行结果:

<__main__.B object at 0x0000024FD7B3CFA0>
<class '__main__.B'>
10
Traceback (most recent call last):
  File "D:\pythonProject1\专题2.py", line 21, in <module>
    b.eat()
  File "D:\pythonProject1\专题2.py", line 14, in eat
    print(self.name)
NameError: name 'self' is not defined

通过结果可以看出,从sleep()和eat() 打印的对象来看,sleep()传递的对象是创建的实例对象b,而被修饰器修饰的函数eat()传递的是类;从eat()访问类的属性和实例属性来看,访问类的属性是没有问题的,但访问实例对象的属性时就报错了。

所以验证了前面讲的:被classmethod修饰的方法,与实例方法的区别是接收的第一个参数不是self,而是cls(当前类的具体类型),被修饰的方法无法访问实例属性,但是可以访问类属性。

今天的分享就到这里,欢迎大家在评论区留言交流!
Python【修饰器/装饰器】专题,不动已有代码,增加新功能的好方法!_第12张图片

你可能感兴趣的