本篇文章给大家带来了关于python的相关知识，其中主要介绍了关于装饰器的相关问题，包括了闭包、装饰器、使用多个装饰器、带参数的装饰器等等内容，下面一起来看一下，希望对大家有帮助。
推荐学习：python视频教程
要了解什么是装饰器（decorator），我们首先需要知道闭包（closure）的概念。
闭包，又称闭包函数或者闭合函数，通俗一点来讲，当某个函数被当成对象返回时还夹带了外部变量，就形成了一个闭包。
以打印Hello World为例，我们先来看一下嵌套函数的结构应该是什么样的：
def print_msg(msg): def printer(): print(msg) printer()print_msg('Hello World')# Hello World
执行print_msg('Hello World')相当于执行了printer()，也就是执行print(msg)，所以将输出Hello World。
我们再来看一下如果是闭包，该是什么样的结构：
def print_msg(msg): def printer(): print(msg) return printer my_msg = print_msg('Hello World')my_msg()# Hello World
本例中的
printer函数就是闭包。
执行print_msg('Hello World')实际上是返回了如下这样一个函数，它夹带了外部变量'Hello World'：
def printer(): print('Hello World')
于是调用my_msg就相当于执行printer()。
那么如何判断一个函数是否是闭包函数呢？闭包函数的__closure__属性里面定义了一个元组用于存放所有的cell对象，每个cell对象保存了这个闭包中所有的外部变量。而普通函数的__closure__属性为None。
def outer(content): def inner(): print(content) return innerprint(outer.__closure__) # Noneinner = outer('Hello World')print(inner.__closure__) # (| ,) |
由此可见outer函数不是闭包，而inner函数是闭包。
我们还可以查看闭包所携带的外部变量：
print(inner.__closure__[0].cell_contents)# Hello World
说了那么多，那么闭包究竟有什么用呢？闭包存在的意义就是它夹带了外部变量（私货），如果它不夹带私货，那么就和普通的函数没有任何区别。
闭包的优点如下：
我们先考虑这样一个场景，假设先前编写的一个函数已经实现了4个功能，为简便起见，我们用print语句来代表每一个具体的功能：
def module(): print('功能1') print('功能2') print('功能3') print('功能4')
现在，由于某种原因，你需要为module这个函数新增一个功能5，你完全可以这样修改：
def module(): print('功能1') print('功能2') print('功能3') print('功能4') print('功能5')
但在现实业务中，直接做出这样的修改往往是比较危险的（会变得不易于维护）。那么如何在不修改原函数的基础上去为它新添一个功能呢？
你可能已经想到了使用之前的闭包知识：
def func_5(original_module): def wrapper(): original_module() print('功能5') return wrapper
func_5代表该函数主要用于实现功能5，我们接下来将module传入进去来观察效果：
new_module = func_5(module)new_module()# 功能1# 功能2# 功能3# 功能4# 功能5
可以看出，我们的新模块：new_module已经实现了功能5。
在上面的例子中，函数
func_5就是一个装饰器，它装饰了原来的模块（为它新添了一个功能）。
当然，Python有更简洁的写法（称之为语法糖），我们可以将@符号与装饰器函数的名称一起使用，并将其放置在要装饰的函数的定义上方：
def func_5(original_module): def wrapper(): original_module() print('功能5') return wrapper@func_5def module(): print('功能1') print('功能2') print('功能3') print('功能4')module()# 功能1# 功能2# 功能3# 功能4# 功能5
基于此，我们可以在不修改原函数的基础上完成计时任务（计算原函数的运行时间），如下：
def timer(func): def wrapper(): import time tic = time.time() func() toc = time.time() print('程序用时: {}s'.format(toc - tic)) return wrapper@timerdef make_list(): return [i * i for i in range(10**7)]my_list = make_list()# 程序用时: 0.8369960784912109s
事实上，my_list并不是列表，直接打印会显示None，这是因为我们的wrapper函数没有设置返回值。如果需要获得make_list的返回值，可以这样修改wrapper函数：
def wrapper(): import time tic = time.time() a = func() toc = time.time() print('程序用时: {}s'.format(toc - tic)) return a
假如我们要为module新添功能5和功能6（按数字顺序），那该如何做呢？
好在Python允许同时使用多个装饰器：
def func_5(original_module): def wrapper(): original_module() print('功能5') return wrapperdef func_6(original_module): def wrapper(): original_module() print('功能6') return wrapper@func_6@func_5def module(): print('功能1') print('功能2') print('功能3') print('功能4')module()# 功能1# 功能2# 功能3# 功能4# 功能5# 功能6
上述过程实际上等价于：
def module(): print('功能1') print('功能2') print('功能3') print('功能4')new_module = func_6(func_5(module))new_module()
此外，需要注意的是，在使用多个装饰器时，最靠近函数定义的装饰器会最先装饰该函数，如果我们改变装饰顺序，则输出结果也将改变：
@func_5@func_6def module(): print('功能1') print('功能2') print('功能3') print('功能4')module()# 功能1# 功能2# 功能3# 功能4# 功能6# 功能5
如果被装饰的函数带有参数，那该如何去构造装饰器呢？
考虑这样一个函数：
def pide(a, b): return a / b
当b=0时会出现ZeropisionError。如何在避免修改该函数的基础上给出一个更加人性化的提醒呢？
因为我们的pide函数接收两个参数，所以我们的wrapper函数也应当接收两个参数：
def smart_pide(func): def wrapper(a, b): if b == 0: return '被除数不能为0!' else: return func(a, b) return wrapper
使用该装饰器进行装饰：
@smart_pidedef pide(a, b): return a / bprint(pide(3, 0))# 被除数不能为0!print(pide(3, 1))# 3.0
如果不知道要被装饰的函数有多少个参数，我们可以使用下面更为通用的模板：
def decorator(func): def wrapper(*args, **kwargs): # ... res = func(*args, **kwargs) # ... return res # 也可以不return return wrapper
我们之前提到的装饰器都没有带参数，即语法糖@decorator中没有参数，那么该如何写一个带参数的装饰器呢？
前面实现的装饰器都是两层嵌套函数，而带参数的装饰器是一个三层嵌套函数。
考虑这样一个场景。假如我们在为module添加新功能时，希望能够加上实现该功能的开发人员的花名，则可以这样构造装饰器（以功能5为例）：
def func_5_with_name(name=None): def func_5(original_module): def wrapper(): original_module() print('功能5由{}实现'.format(name)) return wrapper return func_5
效果如下：
@func_5_with_name(name='若水')def module(): print('功能1') print('功能2') print('功能3') print('功能4')module()# 功能1# 功能2# 功能3# 功能4# 功能5由若水实现
对于这种三层嵌套函数，我们可以这样理解：当为func_5_with_name指定了参数后，func_5_with_name(name='若水')实际上返回了一个decorator，于是@func_5_with_name(name='若水')就相当于@decorator。
将类作为装饰器，我们需要实现__init__方法和__call__方法。
以计时器为例，具体实现如下：
class Timer: def __init__(self, func): self.func = func def __call__(self): import time tic = time.time() self.func() toc = time.time() print('用时: {}s'.format(toc - tic))@Timerdef make_list(): return [i**2 for i in range(10**7)]make_list()# 用时: 2.928966999053955s
如果想要自定义生成列表的长度并获得列表（即被装饰的函数带有参数情形），我们就需要在__call__方法中传入相应的参数，具体如下：
class Timer: def __init__(self, func): self.func = func def __call__(self, num): import time tic = time.time() res = self.func(num) toc = time.time() print('用时: {}s'.format(toc - tic)) return res@Timerdef make_list(num): return [i**2 for i in range(num)]my_list = make_list(10**7)# 用时: 2.8219943046569824sprint(len(my_list))# 10000000
如果要构建带参数的类装饰器，则不能把func传入__init__中，而是传入到__call__中，同时__init__用来初始化类装饰器的参数。
接下来我们使用类装饰器来复现第五章节中的效果：
class Func_5: def __init__(self, name=None): self.name = name def __call__(self, func): def wrapper(): func() print('功能5由{}实现'.format(self.name)) return wrapper@Func_5('若水')def module(): print('功能1') print('功能2') print('功能3') print('功能4')module()# 功能1# 功能2# 功能3# 功能4# 功能5由若水实现
Python中有许多内置装饰器，这里仅介绍最常见的三种：@classmethod、@staticmethod和@property。
@classmethod用于装饰类中的函数，使用它装饰的函数不需要进行实例化也可调用。需要注意的是，被装饰的函数不需要self参数，但第一个参数需要是表示自身类的cls参数，它可以来调用类的属性，类的方法，实例化对象等。
cls代表类本身，self代表实例本身。
具体请看下例：
class A: num = 100 def func1(self): print('功能1') @classmethod def func2(cls): print('功能2') print(cls.num) cls().func1()A.func2()# 功能2# 100# 功能1
@staticmethod同样用来修饰类中的方法，使用它装饰的函数的参数没有任何限制（即无需传入self参数），并且可以不用实例化调用该方法。当然，实例化后调用该方法也是允许的。
具体如下：
class A: @staticmethod def add(a, b): return a + bprint(A.add(2, 3))# 5print(A().add(2, 3))# 5
使用@property装饰器，我们可以直接通过方法名来访问类方法，不需要在方法名后添加一对()小括号。
class A: @property def printer(self): print('Hello World')a = A()a.printer# Hello World
除此之外，@property还可以用来防止类的属性被修改。考虑如下场景
class A: def __init__(self): self.name = 'ABC'a = A()print(a.name)# ABCa.name = 1print(a.name)# 1
可以看出类中的属性name可以被随意修改。如果要防止修改，则可以这样做
class A: def __init__(self): self.name_ = 'ABC' @property def name(self): return self.name_ a = A()print(a.name)# ABCa.name = 1print(a.name)# AttributeError: can't set attribute
推荐学习：python视频教程
Atas ialah kandungan terperinci 归纳总结Python中的装饰器知识点. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!
![[Web front-end] Permulaan pantas Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
