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

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

---

一、修饰器的概念和作用

1.什么是修饰器？

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

---

2.修饰器的作用

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

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

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

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

---

二、修饰器的使用

1.使用说明

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

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

(2）修饰器修饰的是函数或者是方法，不能修饰一个类。

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

例子：

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

(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() 被调用的情况。

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

例子：

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() 才执行剩余的代码。

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

---

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

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

我私藏了很多技术干货，粉丝可白嫖（点这里）

---

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就表示私有属性，我们通过一个简单的例子来看看：

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

回到我们的内置修饰器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下方的方法名一样。

2.staticmethod – 静态方法

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

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

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

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


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

运行结果：

龙叔

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

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

正确的写法应该是：

我们来总结一下这个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（当前类的具体类型），被修饰的方法无法访问实例属性，但是可以访问类属性。

今天的分享就到这里，欢迎大家在评论区留言交流！

我私藏了很多技术干货，粉丝可白嫖（点这里）