我是靠谱客的博主 干净白云,这篇文章主要介绍归纳总结Python中的装饰器知识点,现在分享给大家,希望可以做个参考。

本篇文章给大家带来了关于python的相关知识,其中主要介绍了关于装饰器的相关问题,包括了闭包、装饰器、使用多个装饰器、带参数的装饰器等等内容,下面一起来看一下,希望对大家有帮助。

推荐学习:python视频教程

一、闭包

要了解什么是装饰器(decorator),我们首先需要知道闭包(closure)的概念。

闭包,又称闭包函数或者闭合函数,通俗一点来讲,当某个函数被当成对象返回时还夹带了外部变量,就形成了一个闭包。

以打印Hello World为例,我们先来看一下嵌套函数的结构应该是什么样的:

复制代码
1
2
3
4
5
6
def print_msg(msg): def printer(): print(msg) printer()print_msg('Hello World')# Hello World
登录后复制

执行 print_msg('Hello World') 相当于执行了 printer(),也就是执行 print(msg),所以将输出 Hello World

我们再来看一下如果是闭包,该是什么样的结构:

复制代码
1
2
3
4
5
6
7
8
9
def print_msg(msg): def printer(): print(msg) return printer my_msg = print_msg('Hello World')my_msg()# Hello World
登录后复制

执行 print_msg('Hello World') 实际上是返回了如下这样一个函数,它夹带了外部变量 'Hello World'

复制代码
1
2
def printer(): print('Hello World')
登录后复制

于是调用 my_msg 就相当于执行 printer()


那么如何判断一个函数是否是闭包函数呢?闭包函数的 __closure__ 属性里面定义了一个元组用于存放所有的cell对象,每个cell对象保存了这个闭包中所有的外部变量。而普通函数的 __closure__ 属性为 None

复制代码
1
2
3
4
5
6
7
8
def outer(content): def inner(): print(content) return innerprint(outer.__closure__) # Noneinner = outer('Hello World')print(inner.__closure__) # (<cell at 0x0000023FB1FD0B80: str object at 0x0000023FB1DC84F0>,)
登录后复制

由此可见 outer 函数不是闭包,而 inner 函数是闭包。

我们还可以查看闭包所携带的外部变量:

复制代码
1
print(inner.__closure__[0].cell_contents)# Hello World
登录后复制

说了那么多,那么闭包究竟有什么用呢?闭包存在的意义就是它夹带了外部变量(私货),如果它不夹带私货,那么就和普通的函数没有任何区别。

闭包的优点如下:

  • 局部变量无法共享和长久的保存,而全局变量可能造成变量污染,闭包既可以长久的保存变量又不会造成全局污染。
  • 闭包使得函数内局部变量的值始终保持在内存中,不会在外部函数调用后被自动清除。

二、装饰器

我们先考虑这样一个场景,假设先前编写的一个函数已经实现了4个功能,为简便起见,我们用 print 语句来代表每一个具体的功能:

复制代码
1
2
3
4
5
def module(): print('功能1') print('功能2') print('功能3') print('功能4')
登录后复制

现在,由于某种原因,你需要为 module 这个函数新增一个 功能5,你完全可以这样修改:

复制代码
1
2
3
4
5
6
def module(): print('功能1') print('功能2') print('功能3') print('功能4') print('功能5')
登录后复制

但在现实业务中,直接做出这样的修改往往是比较危险的(会变得不易于维护)。那么如何在不修改原函数的基础上去为它新添一个功能呢?

你可能已经想到了使用之前的闭包知识:

复制代码
1
2
3
4
5
6
7
def func_5(original_module): def wrapper(): original_module() print('功能5') return wrapper
登录后复制

func_5 代表该函数主要用于实现 功能5,我们接下来将 module 传入进去来观察效果:

复制代码
1
new_module = func_5(module)new_module()# 功能1# 功能2# 功能3# 功能4# 功能5
登录后复制

可以看出,我们的新模块:new_module 已经实现了 功能5

当然,Python有更简洁的写法(称之为语法糖),我们可以将@符号与装饰器函数的名称一起使用,并将其放置在要装饰的函数的定义上方:

复制代码
1
2
3
4
5
6
7
8
9
10
11
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
登录后复制

基于此,我们可以在不修改原函数的基础上完成计时任务(计算原函数的运行时间),如下:

复制代码
1
2
3
4
5
6
7
8
9
10
11
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 函数:

复制代码
1
2
3
4
5
6
7
def wrapper(): import time tic = time.time() a = func() toc = time.time() print('程序用时: {}s'.format(toc - tic)) return a
登录后复制

三、使用多个装饰器

假如我们要为 module 新添 功能5功能6(按数字顺序),那该如何做呢?

好在Python允许同时使用多个装饰器:

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
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
登录后复制

上述过程实际上等价于:

复制代码
1
2
3
4
5
def module(): print('功能1') print('功能2') print('功能3') print('功能4')new_module = func_6(func_5(module))new_module()
登录后复制

此外,需要注意的是,在使用多个装饰器时,最靠近函数定义的装饰器会最先装饰该函数,如果我们改变装饰顺序,则输出结果也将改变:

复制代码
1
2
3
4
5
@func_5@func_6def module(): print('功能1') print('功能2') print('功能3') print('功能4')module()# 功能1# 功能2# 功能3# 功能4# 功能6# 功能5
登录后复制

四、被装饰的函数带有参数

如果被装饰的函数带有参数,那该如何去构造装饰器呢?

考虑这样一个函数:

复制代码
1
2
def pide(a, b): return a / b
登录后复制

b=0 时会出现 ZeropisionError。如何在避免修改该函数的基础上给出一个更加人性化的提醒呢?

因为我们的 pide 函数接收两个参数,所以我们的 wrapper 函数也应当接收两个参数:

复制代码
1
2
3
4
5
6
7
def smart_pide(func): def wrapper(a, b): if b == 0: return '被除数不能为0!' else: return func(a, b) return wrapper
登录后复制

使用该装饰器进行装饰:

复制代码
1
2
@smart_pidedef pide(a, b): return a / bprint(pide(3, 0))# 被除数不能为0!print(pide(3, 1))# 3.0
登录后复制

如果不知道要被装饰的函数有多少个参数,我们可以使用下面更为通用的模板:

复制代码
1
2
3
4
5
6
7
def decorator(func): def wrapper(*args, **kwargs): # ... res = func(*args, **kwargs) # ... return res # 也可以不return return wrapper
登录后复制

五、带参数的装饰器

我们之前提到的装饰器都没有带参数,即语法糖 @decorator 中没有参数,那么该如何写一个带参数的装饰器呢?

考虑这样一个场景。假如我们在为 module 添加新功能时,希望能够加上实现该功能的开发人员的花名,则可以这样构造装饰器(以 功能5 为例):

复制代码
1
2
3
4
5
6
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
登录后复制

效果如下:

复制代码
1
2
3
4
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__ 方法。

以计时器为例,具体实现如下:

复制代码
1
2
3
4
5
6
7
8
9
10
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__ 方法中传入相应的参数,具体如下:

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
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__ 用来初始化类装饰器的参数。

接下来我们使用类装饰器来复现第五章节中的效果:

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
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

7.1 @classmethod

@classmethod 用于装饰类中的函数,使用它装饰的函数不需要进行实例化也可调用。需要注意的是,被装饰的函数不需要 self 参数,但第一个参数需要是表示自身类的 cls 参数,它可以来调用类的属性,类的方法,实例化对象等。

具体请看下例:

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
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
登录后复制

7.2 @staticmethod

@staticmethod 同样用来修饰类中的方法,使用它装饰的函数的参数没有任何限制(即无需传入 self 参数),并且可以不用实例化调用该方法。当然,实例化后调用该方法也是允许的。

具体如下:

复制代码
1
2
3
4
5
class A: @staticmethod def add(a, b): return a + bprint(A.add(2, 3))# 5print(A().add(2, 3))# 5
登录后复制

7.3 @property

使用 @property 装饰器,我们可以直接通过方法名来访问类方法,不需要在方法名后添加一对 () 小括号。

复制代码
1
2
3
4
5
class A: @property def printer(self): print('Hello World')a = A()a.printer# Hello World
登录后复制

除此之外,@property 还可以用来防止类的属性被修改。考虑如下场景

复制代码
1
2
3
4
class A: def __init__(self): self.name = 'ABC'a = A()print(a.name)# ABCa.name = 1print(a.name)# 1
登录后复制

可以看出类中的属性 name 可以被随意修改。如果要防止修改,则可以这样做

复制代码
1
2
3
4
5
6
7
8
9
10
11
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中的装饰器知识点的详细内容,更多请关注靠谱客其它相关文章!

最后

以上就是干净白云最近收集整理的关于归纳总结Python中的装饰器知识点的全部内容,更多相关归纳总结Python中内容请搜索靠谱客的其他文章。

本图文内容来源于网友提供,作为学习参考使用,或来自网络收集整理,版权属于原作者所有。
点赞(119)

评论列表共有 0 条评论

立即
投稿
返回
顶部