装饰器结构应用与基本使用(611)

已于 2022-06-15 16:42:51 修改
阅读量142 收藏 2
点赞数 1
分类专栏： Python高阶知识 文章标签： python 开发语言
于 2022-06-15 11:36:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40236497/article/details/125291910
版权

一、装饰器的基本语法和使用

  1. 什么是装饰器

    是一种编程的设计模式，python中只要是可调用的对象，都可以当成装饰器来用

  2. 什么是装饰器的开放封闭原则

    官方定义是：软件实体应该是可扩展的，但不可以进行修改，也就是说，对外扩展是开放的，而对修改是封闭的

  3. 装饰器的语法

    被调用函数加上：@装饰器函数，
    例如：
    @pytest.mark
    @classmethod

  4. 装饰器的作用

    在不更改原功能函数内部代码，并且不改变调用方法的情况下，为原代码扩展新的功能

  5. 装饰器装饰的原理

    • 调用装饰器：并且把被装饰的函数，当成参数传入到装饰器中，保存在封闭作用域内
    • 被装饰的函数执行时：执行的是装饰器中的内层函数，在内层函数中可以进行新的功能代码的扩展，然后再调用原功能函数

    例如：
    我现在定义一个函数work1，调用函数会打印原函数功能

    def work1():
    print("----写代码---")

    那我要在他的基础上扩展新功能，扩展的新功能就是装饰器函数

    我在定义一个闭包函数decorator

    • decorator 函数 ：传进来的参数 func 就是被调用函数
    • wrapper 函数 ：执行的是装饰器中的内层函数，在内层函数中对新功能代码的扩展，然后再调用原功能函数
    def decorator(func):
    def wrapper():
    	# 新功能代码的扩展
        print("---开机，打开Pycharm--")
        
        # 调用被装饰的函数
        func()
        
        # 新功能代码的扩展
        print("---关机，提交代码---")

    return wrapper

    最终的实现装饰器的调用：

    # 装饰器函数
def decorator(func):
    def wrapper():
    	# 新功能代码的扩展
        print("---开机，打开Pycharm--")
        
        # 调用被装饰的函数
        func()
        
        # 新功能代码的扩展
        print("---关机，提交代码---")

    return wrapper

# 函数1
@decorator     -----装饰器
def work1():
    print("----写代码---")

work1（） # 调用原函数

    执行结果：
    在这里插入图片描述

二、装饰器的基本结构（无参数和返回结果）

  1. 装饰器的基本结构：

    def decorator(func):
    def wrapper():
        print("在功能函数调用之前扩展的代码1")
        print("在功能函数调用之前扩展的代码2")
        
        # 调用被装饰的函数
        func()
        
        print("在功能函数调用之后扩展的代码1")
        print("在功能函数调用之后扩展的代码2")

    return wrapper     # 外层函数return返回的是 内层函数

  2. 实例：假如实现一个可以统计任意函数执行时间的装饰器

    # 无参数和返回结果的装饰器
def coubnt_time(func):
	def wrap():
	    # 获取函数调用之前的时间
        start_time = time.time()
        # 调用被装饰的函数
        func()
        # 获取函数调用之后的时间
        end_start = time.time()
        print("执行时间：", end_start - start_time)

    return wrap
		
# 被装饰的函数1
@coubnt_time     # ----装饰器
def time_work2():
    print("这是time_work2的---stert-------")
    time.sleep(1)
    print("这是time_work2的---end-------")

# 函数调用
time_work2()

    执行结果：
    在这里插入图片描述

三、装饰器装饰带有参数和返回结果的函数实现

  1. 如果被调用的函数有参数和返回结果，而定义的装饰器没有去处理，就会报错 ：

    TypeError: time_work() takes 0 positional arguments but 2 were given：函数有2个参数，但是装饰器没有参数传递

    在这里插入图片描述

  2. 带有参数和返回结果的装饰器怎么处理

    1.在第二层函数的参数传递需要加上被调用函数的参数，有几个参数传几个参数
    2.在第一次函数的参数值，在被调用时也需要传递被调用函数的参数，有几个参数传几个参数，并使用result接收返回值
    3.装饰器中的代码执行完后，将原功能函数的结果返回出去

  3. 带参数和结果处理的基本结构如下

    # 装饰器（带参数和结果处理）
 def decorator(func):  
   
     # 加上被调用函数的参数，有几个参数传几个参数
     def wrapper(a,b):          
         print("在功能函数调用之前扩展的代码1")
         print("在功能函数调用之前扩展的代码2")
         
         # 调用被装饰的函数,并使用result接收返回值
         result = func(a,b)
         
         print("在功能函数调用之后扩展的代码1")
         print("在功能函数调用之后扩展的代码2")
         
         # 装饰器中的代码执行完后，将原功能函数的结果返回出去
         return result     
         
     return wrapper

  4. 实例：还是实现一个可以统计任意函数执行时间的装饰器

    # 无参数和返回结果的装饰器
def coubnt_time(func):

	# 加上被调用函数的参数，有几个参数传几个参数
	def time_work(a,b):
	    # 获取函数调用之前的时间
        start_time = time.time()
        
        # 调用被装饰的函数,并使用result接收返回值
        result = func(a,b)
        
        # 获取函数调用之后的时间
        end_start = time.time()
        print("执行时间：", end_start - start_time)
        
		# 装饰器中的代码执行完后，将原功能函数的结果返回出去
        return result
    
	return time_work
		
# 被装饰的函数1有参数传递
@coubnt_time     # ----装饰器
def work(a,b):
    time.sleep(1)
    return a + b

# 函数调用
print(work(1,2))

    执行结果：
    在这里插入图片描述

四、装饰器的通用结构(无论是否有参数)

  1. 那如果定义的装饰器传递的参数是写死的，被调用的A函数有参数和返回结果需要，而B函数没有参数需要传递，对装饰器没有去做处理，就会报错：

    TypeError: time_work() takes 0 positional arguments but 2 were given：缺少 2 个必需的位置参数传递

  2. 针对这种有不同的函数，有的需要传参数，有的不需要，装饰器应该如何实现：

    解决这种情况：在参数传递这里就不能够写死，需要灵活传参，这就要用到 不定长参数 （*args, **kwargs）去传递。

    1.在第二层函数处需要加上被调用函数的参数，加上 不定长参数（*args, **kwargs）
    2.在第一次函数的参数值，在被调用时也需要加上不定长参数（*args, **kwargs），并使用result接收返回值
    3.装饰器中的代码执行完后，将原功能函数的结果返回出去

  3. 实现通用的装饰器的作用：

    1.可以装饰有参数的函数，也可以装饰没有参数的函数
    2.不管函数有没有返回值都适用

  4. 通用装饰器的基本结构：

    def decorator(func):  
  
    # 传不定长参数（*args, **kwargs）
    def wrapper(*args,**kwargs):        
      
        print("在功能函数调用之前扩展的代码1")
        print("在功能函数调用之前扩展的代码2")
        
        # 传不定长参数（*args, **kwargs），调用被装饰的函数, 并使用result接收返回值
        result = func(*args,**kwargs)
        
        print("在功能函数调用之后扩展的代码1")
        print("在功能函数调用之后扩展的代码2")
        
        # 装饰器中的代码执行完后，将原功能函数的结果返回出去
        return result     
        
    return wrapper

  5. 实例：还是实现一个可以统计任意函数执行时间的装饰器

    # 通用装饰器
def count_time(func):

	# 传不定长参数（*args, **kwargs）
    def time_work(*args,**kwargs):
        # 获取函数调用之前的时间
        start_time = time.time()

        # # 传不定长参数（*args, **kwargs），调用被装饰的函数, 并使用result接收返回值
        result = func(*args,**kwargs)

        # 获取函数调用之后的时间
        end_start = time.time()
        print("执行时间：", end_start - start_time)

        # 装饰器中的代码执行完后，将原功能函数的结果返回出去
        return result
        
    return time_work


# 函数1：有参数，需要返回结果
@count_time
def count_number(a,b):
	time.sleep(1)
	return a * b 


# 函数2：无参数，无返回结果
@count_time
def count_number1():
	for i in range(2):
		time.sleep(1)


# 函数3：很多参数传递，需要返回结果
@count_time
def count_number2(aa,bb,cc,dd,ee,ff,gg=1000):
	print(aa,bb,cc,dd,ee,ff,gg)


print(count_number(11,22))
count_number1()
count_number2(1,2,3,4,5,6)

    执行结果：

    在这里插入图片描述

五、装饰器带参数的实现

  1. 之前都是被调用的函数带了参数，那如果装饰器也带了参数，如果装饰器没有去接收，会报错：

    由于在装饰器的参数传的是：字符串类型的参数，就会报 TypeError: ‘str’ object is not callable：“str”对象不可调用

    在这里插入图片描述

  2. 装饰器带了参数，整个装饰器应该如何实现

    当装饰器带有参数去传递，例如:@decorator(‘henry’)

    解决方式是：需要在定义装饰器函数时，需要额外定义一个函数去接收装饰器传进来的参数

  3. 支持参数传递的装饰器结构

    def decorator(name):
----最外层的参数，接收装饰器传进来的值

    def wrapper2(func):
        ----第二层参数func,接收被装饰器的函数

        def wrapper3(*args, **kwargs):
            ----第三层参数，接收被装饰的函数，调用时传进来的参数

            print("装饰器扩展代码1")
            
            result = func(*args,**kwargs)
            
            print("装饰器扩展代码2")
            
            ---返回result 结果
            return result

        ---返回第三层结果
        return wrapper3
        
    ---返回第二层结果
    return wrapper2

  4. 实例：还是实现一个可以统计任意函数执行时间的装饰器

    # 支持参数传递的装饰器实现
def decorator(name):
    """最外层的参数，接收装饰器传进来的值"""

    def wrapper2(func):
        """第二层参数func,接收被装饰器的函数"""

        def wrapper3(*args, **kwargs):
            """第三层参数，接收被装饰的函数，调用时传进来的参数"""
            
            print(name)
            
	        # 获取函数调用之前的时间
	        start_time = time.time()
	
	        # 传不定长参数（*args, **kwargs），并使用result接收
	        result = func(*args,**kwargs)
	
	        # 获取函数调用之后的时间
	        end_start = time.time()
	        print("执行时间：", end_start - start_time)
	        
	        return result

        # 返回第三层结果
        return wrapper3
        
        # 返回第二层结果
    return wrapper2

# 装饰器带参数
@decorator('henry')     
def work():
    time.sleep(1)
    print("python6666")


# 装饰器相当于执行以下代码：
# work = decorator('henry')(work)

work()

    执行结果：
    在这里插入图片描述

六、装饰器如何装饰类

  • 装饰器不仅仅可以装饰函数，还可以装饰类
  • 闭包形式的装饰器装饰类：可以在类实例对象的时候，进行功能扩展

  1. 装饰器装饰类与装饰函数一样，没有区别

    # 通用装饰器
def decorator(item):
    def wrapper(*args, **kwargs):
        print("装饰器扩展代码1")
        result = item(*args,**kwargs)
        
        # 给
        result.name = "henry"
        
        print("装饰器扩展代码2")
        return result

    return wrapper


# 定义一个类
# @decorator       
class Mytest:
    a = 100  # 类属性

# # 装饰器相当于执行以下代码：
# Mytest = decorator(Mytest)

m = Mytest()
print(m.name)

七、装饰器的副作用

  1. 装饰器的副作用

    1.装饰器在装饰之后会出现副作用，无法获取原功能函数的特殊属性
    2.特殊所属性，例如：函数名字，文档注释

  2. 如何消除装饰器的副作用

    1.使用functools库中的 wraps 模块
    2.使用 @wraps(原函数) 消除

  3. 实例，消除装饰器的副作用

    首先定义一个通用装饰器函数：

    def count_time(func):
    def time_work(*args,**kwargs):
        # 获取函数调用之前的时间
        start_time = time.time()
        # 调用原功能函数，并使用result接收返回值
        result = func(*args,**kwargs)
        # 获取函数调用之后的时间
        end_start = time.time()
        print("执行时间：", end_start - start_time)
        # 装饰器中的代码执行完后，将原功能函数的结果返回出去
        return result
    return time_work
    1. 在定义几个函数，不调用装饰器函数，去打印函数1和函数2 的几个特殊属性
    	# 这个函数1：带有参数需要传递
	def work1(a,b):
	    '''这是work1的文档注释'''
	    time.sleep(1)
	    return a + b
				
	# 这个函数2：没有参数需要传递
	def work2():
	    '''这是work2的文档注释'''
	    for i in range(2):
	        time.sleep(1)
	        
	# 打印函数名称和注释文字
	print(work1.__name__, work1.__doc__)
	print(work2.__name__, work2.__doc__)

    打印的结果显示各自获取到对应函数的属性：

    在这里插入图片描述

    1. 这次去调用装饰器函数函数，去打印函数1和函数2 的几个特殊属性看看
    # 这个函数1：带有参数需要传递
@count_time
def work1(a,b):
    '''这是work1的文档注释'''
    res = a + b
    time.sleep(1)
    return res


# 这个函数2：没有参数需要传递
@count_time
def work2():
    '''这是work2的文档注释'''
    for i in range(2):
        time.sleep(1)

# 装饰器装饰之后会出现副作用，无法获取原功能函数的特殊属性
print(work1.__name__, work1.__doc__)
print(work2.__name__, work2.__doc__)

    打印的结果显示注释为空，函数名是同一个：

    在这里插入图片描述

  4. 怎么解决

    只需要增加一行代码，使用 @wraps(原函数) 消除即可，获取到

    在这里插入图片描述

henry_rhy
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
pytest小白学习笔记(一）：pytest框架结构和fixture/mark装饰器的基本原理和应用
01-20
记录笔记的原因是，我太浮躁了，这知识它不进脑子啊。本身pytest测试框架概念又多，自己静不下心，之前看了点视频就想上手练了，结果发现在编写实际用例时，问题很多，用fixture带参数传递的时候总有...基本概念和应用
Python装饰器的应用场景
weixin_30539625的博客
09-03 155
装饰器的应用场景 附加功能 数据的清理或添加: 函数参数类型验证 @require_ints 类似请求前拦截 数据格式转换 将函数返回字典改为 JSON/YAML 类似响应后篡改 为函数提供额外的数据 mock.patch 函数注册 在任务中心注册一个任务 注册一个带信号处理器的函数 不同应用场景下装饰器实现 函数注册表 简单注册表 funcs = [] def regi...
装饰器的应用
weixin_30467087的博客
11-05 52
简单版认证登录 # def wrapper(f): # def inner(*args, **kwargs): # ret = f(*args, **kwargs) # return ret # return inner # 登录认证 login_status = { 'username': None, ...
python类装饰器装饰方法通用编码模型分析.pdf
07-08
python装饰器是一个用于封装函数、...本文首先探讨了实现装饰方法的类装饰器应具有的基本结构，接着对通用的两种编码模型进行了语法和流程的深入分析，并总结了各自的特点，为编写类装饰器装饰方法提供扎实的理论基础。
python程序设计基础与应用.docx
最新发布
06-12
python程序设计基础与应用 Python程序设计基础与应用是学习Python编程的基础，它涵盖了Python语言的基本语法、控制结构、数据类型、函数、文件处理以及更高级的主题，如面向对象编程和标准库。因此，学习Python编程...
.NET中的设计模式——一步步发现装饰模式
02-27
前言过去我的一个朋友常说，学习...装饰器模式允许我们动态为对象添加行为。下面我们先介绍一个场景，然后寻找替代方法。这会帮助我们认清该模式的真实用途，尤其在灵活性这方面。思考过程今天我们参考的不是一个实际的
装饰器的具体应用
边缘拼命划水的小陈
08-25 235
接上一篇继续说装饰器的具体应用： 首先看例子： impor time def get_time(func): def inner(): agin=time.time() func() agin2=time.time() print('运行函数一共耗时%f'%(agin2-agin)) return inner @ge...
装饰器结构
weixin_47145688的博客
05-25 123
# #装饰器 - 用一个函数去装饰另外一个函数或类为其提供额外的功能 # import random # import time # # from functools import wraps # # # def record_time(func): # # # @wraps(func) # def wrapper(*args, **kwargs): # start = time.time() (执行函数之前需要执行的语句） # result = func
装饰器应用demo
内容主要为前端技术
01-19 120
log 为一个方法添加 log 函数，检查输入的参数： class Math { @log add(a, b) { return a + b; } } function log(target, name, descriptor) { var oldValue = descriptor.value; descriptor.value = function(...args) { console.log(`Calling ${name} with`, args); .
装饰器应用解析
游青的博客
05-22 78
简言之，python装饰器就是用于拓展原来函数功能的一种函数，这个函数的特殊之处在于它的返回值也是一个函数，使用python装饰器的好处就是在不用更改原函数的代码前提下给函数增加新的功能。 一般而言，我们要想拓展原来函数代码，最直接的办法就是侵入代码里面修改，例如： import time def func(): print(“hello”) time.sleep(1) print(“world”) 这是我们最原始的的一个函数，然后我们试图记录下这个函数执行的总时间，那最简单的做法就是： #原始侵入，篡改原
装饰器原理及应用场景
daiyu000的博客
07-24 695
装饰器原理及应用场景
装饰器及其在实际项目中的应用（日志模块，代码计时器，内存跟踪器，超时警告）
未知性别程序员的博客
11-02 278
1.什么是装饰器 顾名思义，装饰器是通过装饰供能来丰富函数或类的实现功能，并且减少了代码的耦合性，使得代码看起来更加简洁。 简单示例： 2.装饰器的类型 2.1函数装饰器 函数装饰器是针对于函数进行装饰，使得函数的供能进行丰富。它通过闭包来实现，将要装饰的函数作为外层函数的参数传入，将该函数在内层函数中进行执行并增加附加功能，然后将内层函数作为结果返回。如下示例： 不需要传参数的函数装饰器： from time import sleep,time def decorator(func): def
装饰器（语法糖）的应用
xy_best_的博客
08-16 260
＃装饰器==高阶函数+嵌套函数 在不改变函数调用方式的基础上在函数的前，后添加功能，这就是装饰器的作用!!!! import time from functools import wraps #functools.wraps 的作用是将原函数对象的指定属性复制给包装函数对象, 默认有 module、name、doc,或者通过参数选择 # kill函数包含kerr函数，这个就是嵌套函数；ke...
十、结构型 装饰器模式（Decorator Pattern）
逆流者的博客
06-26 99
装饰器模式（Decorator Pattern）允许向一个现有的对象添加新的功能，同时又不改变其结构。这种类型的设计模式属于结构型模式，它是作为现有的类的一个包装。 一个接口 接口实现类 装饰器抽象类也实现形状接口 装饰器实现类 使用 RedShapeDecorator 来装饰 Shape 对象 结果： 参考： https://www.runoob.com/design-pattern/design-pattern-intro.html...
8-20---装饰器及应用（附实例）
CoDe_Dyy的博客
08-20 348
 什么是装饰器： 装饰器他人的器具，本身可以是任意可调用对象，被装饰者也可以是任意可调用对象。 强调装饰器的原则 1 不修改被装饰对象的源代码。 2 不修改被装饰对象的调用方式 装饰器的目标：在遵循1和2的前提下，为被装饰对象添加上新功能  装饰器需要的知识储备为：高阶函数+函数嵌套+闭包 装饰器的框架（函数内加上了统计时间的功能）： 下图为无...
九、装饰器模式Decorator（结构型）
teaandnoodle的专栏
07-29 399
装饰器模式可以动态地给一个对象添加一些额外的职责。就添加功能来说，既可以通过生成子类的方式添加，也可以使用装饰器模式添加，但是使用装饰器模式时更加灵活。通过装饰器模式，可以将组件嵌入另外一个对象，然后使用这个对象增强原对象的功能，从而达到装饰的目的。
flask应用的基本结构和主要的函数
05-22
Flask应用的基本结构通常包括以下文件和文件夹： - app.py: Flask应用的入口文件。 - templates文件夹：存放HTML模板文件。 - static文件夹：存放静态文件，如CSS、JavaScript等。 - requirements.txt：用于记录应用所需的Python包及其版本信息，方便其他开发者安装依赖。 主要的函数包括： - Flask(): 创建Flask应用实例对象。 - @app.route(): 路由装饰器，用于指定URL地址和HTTP请求方法。 - request: 请求对象，可以获取请求参数、请求头等信息。 - render_template(): 渲染HTML模板文件，并将结果返回给浏览器。 - redirect(): 重定向到指定的URL地址。 - url_for(): 生成指定路由函数的URL地址。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值