装饰器python作用,python装饰器原理详解

2022-08-25 03:27:03 分类：python 阅读()

　　装饰器python作用,python装饰器原理详解

　　这篇文章给大家带来了一些关于python的知识，主要介绍了一些关于decorator的相关问题，包括闭包、decorator、使用多个decorator、带参数的decorator等等。下面就让我们一起来看看，希望对你有所帮助。

　　推荐：python视频教程

　　00-1010要了解什么是装饰器，我们首先需要知道闭包.的概念

　　闭包，又称闭包函数或封闭函数，一般来说，当一个函数作为一个带有外部变量的对象返回时，就形成了一个闭包。

　　以打印Hello World为例，我们先来看看嵌套函数的结构应该是什么样子的：

　　def print_msg(消息):

　　def打印机():

　　打印(邮件)

　　Printer()print_msg(Hello World )# Hello World执行print _ msg( Hello World )相当于执行printer()，也就是执行print(msg)，所以会输出Hello World。

　　我们来看看如果是闭包应该是什么样的结构：

　　def print_msg(消息):

　　def打印机():

　　打印(邮件)

　　返回打印机

　　my _ msg=print _ msg( hello world )my _ msg()# hello world这个例子中的打印机函数是一个闭包。

　　执行print_msg(Hello World )实际上会返回以下带有外部变量 Hello World 的函数：

　　def打印机():

　　Print(Hello World )然后调用my_msg相当于执行printer()。

　　那么如何判断一个函数是不是闭包函数呢？在闭包函数的__closure__属性中定义了一个元组来存储所有的cell对象，每个cell对象存储闭包中所有的外部变量。而普通函数的__closure__属性是None。

　　定义外部(内容):

　　内部定义():

　　打印(内容)

　　返回innerprint(外部。__closure__)

　　# none inner=outer(“Hello World”)print(inner。__closure__)

　　#(0x 000023 FB 1 FD 0 b 803360 strobject at0x 000023 FB 1 DC 84 f 0的单元格)可以看出，外层函数不是闭包，而内层函数是闭包。

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

　　打印(内部。_ _ closure _ _ [0]。cell _ contents) # helloworld说了这么多，那么闭包有什么用呢？封闭的意义在于它包含了外部变量(盗录)。如果不含盗录，和普通功能没什么区别。

　　闭包的优点如下：

　　局部变量不能长期共享和存储，而全局变量可能造成变量污染。封闭可以长期保存变量，不会造成全球污染。闭包将函数中局部变量的值一直保存在内存中，不会在外部函数被调用后自动清除。00-1010我们先考虑这样一个场景，假设之前写的一个函数已经实现了四个函数。为简单起见，我们使用print语句来表示每个特定的函数：

　　定义模块():

　　打印(“功能1”)

　　打印(“功能2”)

　　打印(“功能3”)

　　现在打印(“函数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。

　　

7.1 @classmethod

@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

7.2 @staticmethod

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

　　具体如下：

　　

class A:
　　 @staticmethod
　　 def add(a, b):
　　 return a + bprint(A.add(2, 3))# 5print(A().add(2, 3))# 5

7.3 @property

使用 @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中的装饰器知识点的详细内容，更多请关注盛行IT软件开发工作室其它相关文章！

　　

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。

标签： python

相关文章阅读

  • python装饰器--原来如此简单,Python 类装饰器
  • python装饰器--原来如此简单,python中什么是装饰器
  • python 内置装饰器,python装饰器--原来如此简单
  • 通俗解释python装饰器,python中的装饰器是干嘛的
  • python 装饰器作用,python装饰器--原来如此简单
  • python 类的装饰器,python装饰器--原来如此简单
  • python装饰器简单例子,python装饰器例子
  • 装饰器python的通俗理解,python装饰器--原来如此简单
  • python装饰器原理详解,python装饰器有哪些
  • 通俗解释python装饰器,python中的装饰器的作用
  • python装饰器原理详解,python lambda菜鸟教程
  • python装饰器详解 带参数,python装饰器详解@static_1
  • python装饰器详解 带参数,python装饰器详解@static
  • python装饰器简单例子,python 类装饰器和函数装饰器区别
  • python装饰器--原来如此简单,什么是装饰器 python
    • 留言与评论（共有 条评论）
       
    验证码：