前言
在 python 中，装饰器由于是 python 语言自带的一个功能，因此，对于其实现以及其用法就会感到比较奇怪，这里我记录一下对它的理解，加深自己的印象。
什么是装饰器
对于什么是装饰器，我们其实应该知道为什么会存在装饰器。
装饰器是 python 引入的一个非常有意思的功能，它主要用于解决想要在原有函数或类的基础上进行功能扩展，但又不会破坏这个函数本身的功能。并且我们可以方便的添加和去除这一部分扩展的功能的需求。
例如：当你在调试代码的时候，你想要给一些功能函数添加打印调试信息。但是，这个功能只在我们调试的时候使用，正式发布的时候是不需要的。如果此时，你在函数内部修改，由于有多个函数都需要添加相同的或类似的信息，那么，你就需要逐一修改，这个就有点麻烦了，此时我们就可以使用装饰器来解决这一问题。
在解释如何使用装饰器之前，我们需要先把和装饰器有关的基本概念给讲一下。
Python 函数的基本特性
函数名的本质：
在 python 中，一切皆是对象，也就是说，我们定义的变量和函数都是一个对象。而是对象就意味着我们可以获得这个对象的属性，例如函数对象有一个 __name__ 的属性：
|
1
2
3
4
5
6
7
8
9
10
11
|
def function(): #定义一个函数
print('this is a function !')
function()
print(function) #打印函数名的地址
print(function.__name__) #打印函数名
a = function #把函数赋给一个变量
a()
print(a) #打印 a 的地址
print(a.__name__) #再次打印函数名
|
打印结果：
this is a function !
<function function at 0x0000029F83C17F70>
function
this is a function !
<function function at 0x0000029F83C17F70>
function
由打印可以看出，我们的函数名在赋给另一个变量的时候，其函数地址和函数属性中的函数名是没有变化的。也就是说，当我们在定义函数的时候，我们的函数名和普通的变量是一样的，唯一的不同就是，我们的函数名会指向一个内存空间，而这片空间内保存的是一个函数体的内容。
但是，当我们把这个函数名赋值给其他变量的时候，这个函数名就会把它执行的内存空间的地址赋值给另一个变量，因此，另一个变量也就成为了一个函数了。
这里我们已经能够注意到了，函数名如果不加 () 那么它和普通的变量一样，而加了 () 之后，它就会去执行我们的函数内容。
这里我们把试着删除我们定义时候使用的函数名：
|
1
2
3
4
5
6
7
8
|
del function #删除 function 函数
a() #执行 a()
print(a) #打印出 a 指向的地址
print(a.__name__) #打印a的函数名
function()
print(function)
print(function.__name__)
|
查看打印：
this is a function !
<function function at 0x000002258DC17F70>
function
NameError: name 'function' is not defined
可以看到，我们的 function() 函数名提示没有定义，但是我们的 a() 函数却可以正常的打印出来。这里的 del 其实就是把我们的 function 这个函数名的指针给指向的函数地址给删去了，此时它变成立一个真正的未定义的变量了。
将函数作为变量使用：
既然函数名和普通的变量可以相互赋值，那就说明，我们也可以像使用普通变量一样使用函数名了。
在函数中定义函数：
我们可以像定义普通变量一样，在一个函数中定义另一个函数：
|
1
2
3
4
5
6
7
8
9
10
|
def function1():
print('this is function 1')
def function2():
print('this is function 2 !')
return 0
function2()
return 0
function1()
function2()
|
打印如下：
this is function 1
this is function 2 !
NameError: name 'function2' is not defined
可以看到，我们在 function1 中定义了一个 function2 函数，而且在 function1 中使用了 function2 这个函数。但是，当我们在外面使用 function2 这个函数的时候，却打印了该函数未定义。这里说明，函数内定义的函数的作用域也仅限于函数内部，和我们的局部变量是一样的。
但是，当我们把函数作为返回值的时候，这个情况就不一样了，这里参考我上一篇文章：Python中的闭包中的变量作用域问题
在函数中返回函数名：
既然我们可以在一个函数中定义另一个函数，那么也就可以在函数中返回另一个函数：
|
1
2
3
4
5
6
7
8
9
10
|
def function1():
print('this is function 1')
def function2():
print('this is function 2 !')
return 0
function2() #在函数内部使用该函数
return function2 #返回该函数的函数名
a = function1() #把函数名返回给一个变量
a()
|
打印如下：
this is function 1
this is function 2 !
this is function 2 !
这里可以看到，我们的这个在函数 function1 中定义并返回了函数 function2 并在外部使用一个变量来接收 funciton1 的返回值。由此可以看出，函数名和变量的使用方式差别不大。
注意: 虽然我们说的时候会说在一个函数中返回另一个函数，但是，实际上，我们返回的只是这个函数的函数名（不带括号'()‘）。
把函数名作为参数使用：
|
1
2
3
4
5
6
7
8
9
10
|
def hello():
print("hello")
def function1(func): #接收一个参数
print('before call hello !')
func()
print('after call hello !')
#function2() #在函数内部使用该函数
function1(hello) #把 hello 作为参数传递进去
|
打印如下：
before call hello !
hello
after call hello !
由打印可以知道，我们在函数 function1 中定义的接收参数 func 我们在定义的时候并没有采用什么特殊的方式，而是和普通参数一样定义。之后，在外部调用 function1 的使用，把函数名 hello 当作参数传递进去了。随后，我们运行 function1 并在 function1 中成功调用了 hello 函数。
进一步实现装饰器
现在，让我们再重新看一下什么是装饰器，我们在上面的把函数名作为参数使用时，已经实现了一个和装饰器功能类似的函数了。假如我们的 hello() 函数是我们的功能函数，而 function1 作为我们的装饰器，那么，我们成功实现了在不改变 hello() 函数的基础上，通过把它作为参数使用而增加了其他的打印内容。
虽然我们上面实现了一个类似装饰器的功能，但是，我们可以看到，使用这个的时候我们需要每次都给 function1 传入一个函数，这样使用就很麻烦了。下面我们改造一下这个函数：
|
1
2
3
4
5
6
7
8
9
10
11
12
|
def decorator(func): #装饰器函数，用于接收一个函数参数
def wrapper(): #定义一个内函数 wrapper
print('before call hello !')
func()
print('after call hello !')
return wrapper #把内函数做未返回值
def hello():
print("hello")
hello = decorator(hello) #重新定义一个函数 hello1
hello() #执行 hello
|
打印如下：
before call hello !
hello
after call hello !
通过上面的打印可以看到，我们新更改的这个函数可以实现和上面的函数一样的功能。但是，我们这里在使用它的时候比之前要简单一些，因为我们可以直接使用旧的函数名来使用新的功能 (这里我们相当于给函数名 hello 赋值了一个新的函数wrapper)，当我们想要使用旧函数时，只需要把 hello=function(hello) 这行内容给注释掉就可以了。
使用Python装饰器语句：
简单装饰器
上面的我们已经实现了一个装饰器的功能，下面我们使用 Python 中自带的装饰器来测试一下：
|
1
2
3
4
5
6
7
8
9
10
11
12
|
def decorator(func): #装饰器函数，用于接收一个函数参数
def wrapper(): #定义一个内函数 wrapper
print('before call hello !')
func()
print('after call hello !')
return wrapper #把内函数做为返回值
@decorator # '@' 是系统自带的装饰器语法糖
def hello():
print('hello')
hello()
|
打印如下：
before call hello !
hello
after call hello !
可以看到，我们使用系统自带得装饰器语法实现了和我们上面得函数一样得功能。
这里我们可以看到，他们两个唯一得不同就是使用了 @decorator这个符号来代替了 hello=decorator(hello) 这个赋值语句。
到这里，其实我们基本上就已经明白了python所谓得装饰器的原理和实际用法了,但是，这里我们还有一个问题，那就是这种方法会改变我们的函数的属性吗？
我们测试一下：
|
1
|
print(hello.__name__)
|
打印如下：
wrapper
很明显，我们的原函数的属性中的函数名被更改了，其实通过上面自己的实现，我们可以发现，我们使用装饰器语法其实就是新建了一个函数名，然后用它去接收装饰器函数的返回函数名，这样，该该函数肯定还是继承了装饰器返回函数的函数名了。
为了解决这个问题，我们可以使用如下方法：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
import functools
def function(func): #接收一个参数
@functools.wraps(func)
def wrapper(): #定义一个内函数 wrapper
print('before call hello !')
func()
print('after call hello !')
return wrapper #把内函数做为返回值
@function # '@' 是系统自带的装饰器语法糖
def hello():
print('hello')
hello()
print(hello.__name__)
|
打印如下：
before call hello !
hello
after call hello !
hello
通过我们使用系统模块，我们解决了这一问题。
带参数装饰器：
上面我们展示了装饰器的基础用法，但是，我们可以发现一个问题，那就是这个装饰器只能用于打印一类的基本操作，有时我们需要在装饰器函数内传参，且需要在多个函数中使用同一个装饰器函数，如果单纯使用上面的方法就不太容易操作了。
下面我们展示一种给装饰器传参的操作方法：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
import functools
def logging(level):#装饰器接收参数函数
def decorator(func): #装饰器函数，用于接收一个函数
@functools.wraps(func)
def wrapper(*args, **kwargs): #定义一个内函数 wrapper
if level == 'warn':
print('warn: before call %s !' %func.__name__)
func()
print('warn: after call %s !' %func.__name__)
if level == 'error':
print('error: before call %s !' %func.__name__)
func()
print('error: after call %s !' %func.__name__)
return wrapper #把内函数做为返回值
return decorator
@logging(level='warn') # '@' 是系统自带的装饰器语法糖
def hello():
print('hello')
@logging(level='error')
def function1():
print('function1')
hello()
function1()
print(hello.__name__)
print(function1.__name__)
|
打印如下：
warn: before call hello !
hello
warn: after call hello !
error: before call function1 !
function1
error: after call function1 !
hello
function1
可以看到，我们在两个函数中使用了一个装饰器语法，而且给这个装饰器分别传了不同的参数，这个才比较符号我们实际可能会用到的情况。
这里第一次看可能感觉有点复杂，而且我们在这里也使用了多层函数嵌套，每层都传不同的参数。这里我来仔细拆分一下这个函数：
首先我们知道:
|
1
2
3
4
5
|
@logging
def hello():
print('hello')
#等价于
logging(hello)
|
因此：
|
1
2
3
4
5
|
@logging(level='warn')
def hello():
print('hello')
#等价于
logging(hello)(level='warn')
|
下面我们继续拆解 logging(hello)(level=‘warn') 这句话：
logging(hello)(level='warn')
由于
logging(hello) 返回 decorator
于是
logging(hello)(level='warn')
等价于
decorator(level='warn')
而
decorator 返回 wrapper
因此
这里其实就到了我们最上面的简单装饰器了
到这里我们就明白了我们的装饰器传参是怎么回事了。
装饰器类：
由于我们在 python 中会经常使用类来对某一功能进行封装，这样，当我们在使用某一功能的时候就更加灵活且方便了。
因此，我们的 python 也给我们提供了实现装饰器类的使用方法：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
class Logging(object):
def __init__(self, func):
self._func = func
def __call__(self):
print('class: before call %s !' %self._func.__name__)
self._func()
print('class: after call %s !' %self._func.__name__)
@Logging
def hello():
print('Hello')
hello()
|
打印如下：
class: before call hello !
Hello
class: after call hello !
可以看到，我们的类装饰器的用法和函数类似，只是在定义装饰器函数的时候，把函数的实现变成了类方法的实现方式。
除了这种最基本的的使用方式，我们其实也可以给类装饰器传参：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
class Logging(object):
def __init__(self, level='INFO'):
self._level = level
def __call__(self, func):
def wrapper(*args, **kwargs):
if self._level == 'WARN':
print('class: warn before call %s !' %func.__name__)
func()
print('class: warn after call %s !' %func.__name__)
return wrapper
@Logging(level='WARN')
def hello():
print('Hello')
hello()
|
打印如下：
class: warn before call hello !
Hello
class: warn after call hello !
这里传参方式和上面直接在类中的 __call__ 中定义函数有些不一样，这里需要记住两点：
__init__：不再接收被装饰函数，而是接收传入参数；
__call__：接收被装饰函数，实现装饰逻辑
这里就不对这个类方法进行深入解析了。
总结
到此这篇关于Python中装饰器的基本功能的文章就介绍到这了,更多相关Python装饰器功能内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！
原文链接：https://blog.csdn.net/qq_25827755/article/details/120891814