이 글은 클로저, 데코레이터, 다중 데코레이터 사용, 매개변수가 있는 데코레이터 등 데코레이터와 관련된 문제를 주로 소개하는python에 대한 관련 지식을 제공합니다. 함께 살펴보도록 하겠습니다. 도움이 되기를 바랍니다. 모두에게.
추천 학습:python 비디오 튜토리얼
데코레이터(데코레이터)가 무엇인지 이해하려면 먼저클로저(클로저)의 개념을 알아야 합니다.
클로저, 클로저 함수 또는 닫힌 함수라고도 함. 일반인의 용어로 함수가 객체로 반환되고 외부 변수도 포함하면 클로저를 형성합니다.
예를 들어 Hello World를 인쇄해 보겠습니다. 먼저 중첩 함수의 구조가 어떻게 생겼는지 살펴보겠습니다.
def print_msg(msg): def printer(): print(msg) printer()print_msg('Hello World')# Hello World
print_msg('Hello World')를 실행하는 것은 print(), 즉print(msg)가 실행되므로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
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
이 예에서
printer함수는 클로저입니다.
print_msg('Hello World')를 실행하면 실제로 외부 변수
'Hello World'를 포함하는 다음과 같은 함수가 반환됩니다.
def module(): print('功能1') print('功能2') print('功能3') print('功能4')new_module = func_6(func_5(module))new_module()
my_msg를 호출하는 것은printer()를 실행하는 것과 같습니다.
__closure__속성은 모든 셀 객체를 저장하는 튜플을 정의합니다. 각 셀 객체는 클로저에 모든 외부 변수를 저장합니다. 일반 함수의
__closure__속성은
None입니다.
@func_5@func_6def module(): print('功能1') print('功能2') print('功能3') print('功能4')module()# 功能1# 功能2# 功能3# 功能4# 功能6# 功能5
outer함수는 클로저가 아니지만,
inner함수는 클로저임을 알 수 있습니다.
클로저가 전달하는 외부 변수도 볼 수 있습니다:
def pide(a, b): return a / b
print문을 사용하여 각 특정 함수를 나타냅니다.
def smart_pide(func): def wrapper(a, b): if b == 0: return '被除数不能为0!' else: return func(a, b) return wrapper
모듈함수에
함수 5를 추가해야 합니다. 다음과 같이 수정할 수 있습니다.
@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
func_5는 이 함수가 주로
함수 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
new_module이
함수 5를 구현한 것을 볼 수 있습니다.
위의 예에서
func_5함수는 원래 모듈을 장식하는 데코레이터입니다(새 함수를 추가함).
물론 Python에는 더 간결하게 작성하는 방법이 있습니다(구문 설탕이라고 함). 데코레이터 함수 이름과 함께 @ 기호를 사용하고 장식할 함수 정의 위에 배치할 수 있습니다.
@func_5_with_name(name='若水')def module(): print('功能1') print('功能2') print('功能3') print('功能4')module()# 功能1# 功能2# 功能3# 功能4# 功能5由若水实现
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
my_list목록이 아닌 경우 직접 인쇄하면
없음이 표시됩니다. 이는
래퍼함수가 반환 값을 설정하지 않기 때문입니다.
make_list의 반환 값을 가져와야 하는 경우
wrapper함수를 다음과 같이 수정할 수 있습니다.
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
함수 5와
함수 6(번호순)이 추가되었는데 어떻게 해야 하나요? 다행히도 Python에서는 여러 데코레이터를 동시에 사용할 수 있습니다.
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由若水实现
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
class A: @staticmethod def add(a, b): return a + bprint(A.add(2, 3))# 5print(A().add(2, 3))# 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视频教程
위 내용은 Python 데코레이터의 지식 포인트를 요약합니다.의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!
![[웹 프런트엔드] Node.js 빠른 시작](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
