Python中装饰器的使用总结

最新推荐文章于 2024-04-11 16:01:36 发布
最新推荐文章于 2024-04-11 16:01:36 发布
阅读量246 收藏
点赞数
分类专栏： Python学习笔记 文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/opencv_fjc/article/details/105557253
版权

本文在书写时，参考了一下几篇博客，在此贴出来，以示尊重:
装饰器必看博客1
装饰器必看博客2
装饰器必看博客3

1、装饰器使用说明。

(1)、Python中的装饰器是一种可以装饰其它对象的工具。
(2)、该工具本质上是一个可调用的对象（callable），所以装饰器一般可以由函数、类来实现。
(3、)装饰器本身需要接受一个被装饰的对象作为参数，该参数通常为函数、方法、类等对象。
(4)、装饰器需要返回一个对象，该对象可以是经过处理的原参数对象、一个包装且类似原参数的对象，或者返回一个不相干内容（通常不建议使用）
（5）闭包是装饰器的核心内容。

2.装饰器的常见使用场景。

2.1、函数装饰器

（1）最简单的函数装饰器
接收一个被装饰的对象，不对该对象做任何的补充

 def test(obj):
   return obj
@test      #=>等价于obj=test(obj)，相当于函数对象的实例化。
 def obj():
     print("hello wurenji ")
 obj()

输出结果：

hello wurenji

（2）函数装饰器

用于模拟对象的装饰器–函数装饰器
在上面例子中的装饰器，是直接修改了传入对象；而装饰器最常用的方式却是模拟一个传入对象。即返回一个和原对象相似的对象（即调用接口完全一样的另一个对象），并且该模拟对象是包装了原对象在内的。具体代码如下：

def test(func):    # 最简单的函数装饰器,以被装饰的函数对象作为参数
     def inner():
         print("This is decorate code")#在装饰器内部加上需要为原函数补充的内容。
         func()
         print("wo ai xiaobao")

     return inner#返回的是添加完修饰后的函数对象。不是被修饰的函数。

@test#@test作用：指明了test函数实际修饰的函数obj,调用test(func)，并且将调用结果赋值给它装饰的函数(obj)。
def obj():
    print("This is obj function")
obj()

结果如下：

This is decorate code
This is obj function
wo ai xiaobao

函数装饰器的实质性探索:将闭包的值赋予了被修饰函数。

def test(func):  # 最简单的函数装饰器,以被装饰的函数对象作为参数
    def inner(x,y,u,v):#闭包中含有参数。
         print("This is decorate code")  # 在装饰器内部加上需要为原函数补充的内容。
         func(u,v)
         print("wo ai xiaobao")
         sum = x+y
         print(sum)
    return inner

@test  # @test作用：将obj函数作为参数传递给了装饰器，并且将test的返回值的引用赋值给了obj。
def obj(a,b):
    print("This is obj function")
    result=a*b
    print("This is obj's result is :{}".format(result))

obj(3,4,5,6)#调用的实质：利用被修饰的函数obj对为obj函数实际添加功能的闭包函数inner中参数（x，y，u，v)的初始化。

obj(3,4,5,6)#调用的实质：利用被修饰的函数obj对为obj函数实际添加功能的闭包函数inner中参数（x，y，u，v)的初始化。并且将闭包inner的值赋予了被修饰的obj（a,b）函数。输出结果如下：

This is decorate code
This is obj function
This is obj's result is :30
wo ai xiaobao
7

（3）含有参数的函数装饰器

def deco(msg):#存放装饰器自己的参数。
    def inner_deco(func):#装饰器的实现函数,()内的参数为func,表明该闭包的作用是为func函数起到修饰作用。
        def new_func(x,y,u,v):#装饰的具体实现.()存放在执行func函数时可能用到的参数以及其他参数，这些参数在调用原func时进行初始化。
            print(f'[log] run function {func.__name__}')
            func(u,v)
            print("This is the deco_func_param_result:{}".format(x*y))
            print(f'[log] {msg}')
        return new_func
    return inner_deco

@deco('wo ai ni ')#装饰器自己的参数必须这样初始化。
def foo(x,y):
    print('This is foo')
    print("This is foo's result:{}".format(x*y))
foo(3,4,5,6)#3,4是对被引用的闭包中new_func（）函数中的x,y的初始化。5,6是对new_func中u v的初始化。

输出结果如下：

[log] run function foo
This is foo
This is foo's result:30
This is the deco_func_param_result:12
[log] wo ai ni

（4）含有不定长参数的装饰器。

[1]、被装饰的函数带有参数。

def deco1(deco_param):#()存放的是装饰器自己的参数
    def inner_deco(func):#()存放的是被修饰的函数对象，本质上是闭包的应用。
         #new_func的()存放的是被修饰的函数的参数以及其他参数（可有可无），其他参数初始化由func（）函数在初始化时一并初始化。
        def new_func(func_param):
            print(f"This is deco_param_value:{deco_param}.")
            func(func_param)
            print("The rest of func")
        return new_func
    return inner_deco
@deco1(90)
def func(param):
    print(f"This is func_param_value:{param}") 
func(10)

输出结果如下：

This is deco_param_value:90.
This is func_param_value:10
The rest of func

[2]、被修饰的函数带有不定长参数。
被装饰的函数带有不定长参数,借助Python中的*args和**kwargs使被装饰的函数可以支持传入任意参数。

def deco2(deco_param):
    def inner(func):
        def new_func(u,v,*args,**kwargs):#（）里面的参数由实际调用被修饰的func函数进行初始化。
            print(f"This is deco_param_value:{u+v}")
            func(*args,**kwargs)
            print(f'[log] run function {func.__name__}')#获取正在运行的函数的名字。
        return new_func
    return inner
@deco2("deco_param_value:10")
def obj1(*args,**kwargs):
     print(f'The tuple params is {args},Dict params is {kwargs}')

obj1(12,13,34,78,23,x=10,y=19)

输出结果如下：

This is deco_param_value:25
The tuple params is (34, 78, 23),Dict params is {'x': 10, 'y': 19}
[log] run function obj1

分析：执行obj1(12,13,34,78,23,x=10,y=19)时，前两个参数12,13传递给new_func函数中的u,v,其余参数作为不定长参数传递给被修饰的fun函数（obj1自身用到的参数。）。
（5）被修饰的函数有返回值

def deco3(deco_param):
    def inner(func):
        def new_func(*args,**kwargs):
             print(f'This is running_function name :{func.__name__}')
             func_value=func(*args,**kwargs)
             print('This is new add function' )
             return func_value#被修饰的函数含有返回值，必须返回。
        return new_func
    return inner
@deco3('wo ai xiaobao')#注意不能丢弃装饰器的参数
def func0(a,b):
    result=a+b
    return result

结果输出如下：

This is running_function name :func0
This is new add function
30

分析： 如果被修饰的函数中有返回值，一定要在装饰器的最内层闭包中将被修饰函数的返回值返回到其外层嵌套函数。等到装饰器的逻辑执行完毕，才返回最终结果。

2.2、类方法装饰器。

类方法装饰器与函数装饰器类似，其作用相同，格式相近。

def outer(obj_func): #obj参数是一个类方法。类方法的装饰器本质上与函数的装饰器一样，就是将待修饰的函数传递给闭包里面的内嵌函数 。
     #类方法装饰器与普通装饰器相比就是多了一个self参数，因为类方法本身就有self参数,其他用到的参数在实际调用被修饰的类方法时进行初始化。
     def inner(self,x,y):
         obj_func(self)#修饰被装饰的类方法，切记self参数和其他参数（如果有的话）不能少。
         print("This is add content")
         sum=x+y
         print(f'This is sum：{sum}')
         print(f'This is running_function name :{obj_func.__name__}')
     return inner

class Zoo(object):
      def __init__(self):
         pass

      @outer        # => zoo = outer(zoo)
      def zoo(self):#被装饰的类方法
          print('This class method')

foo = Zoo()
print(foo.zoo.__name__)#返回的是被修饰函数所在闭包的名字，此处zoo实际上是装饰器返回值的引用(闭包的返回值的名字）
foo.zoo(3,4)#执行装饰器的返回值的引用，切记不能漏掉装饰器中的参数。

输出结果如下：

inner
This class method
This is add content
This is sum：7
This is running_function name :zoo

2.3、类装饰器。

装饰器除了可以装饰函数、方法之外，还可以装饰类对象。修饰类对象的装饰器称为类装饰器。

类装饰器通过一个含有返回值为类类型的闭包来实现。

def outer(clss):   # 类装饰器，clss为一个类
    class Inner():#装饰器修饰的是类对象，所以闭包的返回值为类。该类由被修饰的实例对象来初始化（即该类中
        # 需要外传参数时，可通过实例化的对象来完成。）
        def __init__(self,a,b,u,v):
            self.clss = clss(u,v)#执行被修饰的实例对象。
            self.name='zhangsan'
    # a,b参数由被修饰的实例对象实例化时进行传递，若果被修饰的类初始化时需要传递参数，也需要在实例化时一并传递进来。
            self.number=a+b

#__getattr_为内置方法，当使用点号获取实例属性时，如果属性不存在实例对象就自动调用__getattr__方法,
        # 通过该方法来获取被修饰对象中对应的同名属性值。
        def __getattr__(self, attr):
            return getattr(self.clss, attr)#获取类的某个属性值。

# 当下面的say方法在装饰器中不存在时，装饰器就会通过__getattr__函数调用被修饰的类中的say方法,前提是被修饰的实例对象被执行，
#   并且被修饰的类当中存在同名方法。
        def say(self):
            print(self.name)
            print(self.number)

        def abc(self):
            print("This is in deco funtion")

    return Inner#装饰器的返回类型必须和被修饰的函数一致.


@outer          # Zoo = outer(Zoo)
class Zoo():
    def __init__(self,x,y):
        self.Zoo_sum=x*y


    def say(self):
        print('hello world!')
    def Zoo_print(self):
        print(f'This is Zoo_out:{self.Zoo_sum}')

zoo = Zoo(3,5,7,8)#3.5用来初始化装饰器中的类需要的参数.7，8为被修饰的类自己的类初始化时需要的参数。
print(zoo.__class__)    # <class '__main__.outer.<locals>.Inner'>
zoo.say()                  # hello world!
zoo.abc()
zoo.Zoo_print()
print(zoo.name)
print(zoo.number)

输出结果如下：

<class '__main__.outer.<locals>.Inner'>
zhangsan
8
This is in deco funtion
This is Zoo_out:56
zhangsan
8

分析：在被修饰函数执行时，当调用的方法与装饰器中的方法同名时（本例中为say（）方法），会优先调用修饰器中的同名方法。

当在被修饰的类中调用某个方法时，装饰器中不存在该方法时，会通过装饰器中的__getattr__方法来调用被修饰的类中的同名方法，但是，如果被修饰的类在装饰器中未执行时，调用_getarrt_方法会报错。如下所示：

def outer(clss):   # 类装饰器，clss为一个类
    class Inner():#装饰器修饰的是类对象，所以闭包的返回值为类。该类由被修饰的实例对象来初始化（即该类中
        # 需要外传参数时，可通过实例化的对象来完成。）
        def __init__(self,a,b,u,v):
            #self.clss = clss(u,v)#不执行被修饰的实例对象。
            self.name='zhangsan'
    # a,b参数由被修饰的实例对象实例化时进行传递，若果被修饰的类初始化时需要传递参数，也需要在实例化时一并传递进来。
            self.number=a+b

#__getattr_为内置方法，当使用点号获取实例属性时，如果属性不存在实例对象就自动调用__getattr__方法,
        # 通过该方法来获取被修饰对象中对应的同名属性值。
        def __getattr__(self, attr):
            return getattr(self.clss, attr)#获取类的某个属性值。

# 当下面的say方法在装饰器中不存在时，装饰器就会通过__getattr__函数调用被修饰的类中的say方法,前提是被修饰的实例对象被执行，
#   并且被修饰的类当中存在同名方法。
       # def say(self):
           # print(self.name)
            #print(self.number)

        def abc(self):
            print("This is in deco funtion")

    return Inner#装饰器的返回类型必须和被修饰的函数一致.


@outer          # Zoo = outer(Zoo)
class Zoo():
    def __init__(self,x,y):
        self.Zoo_sum=x*y


    def say(self):
        print('hello world!')
    def Zoo_print(self):
        print(f'This is Zoo_out:{self.Zoo_sum}')

zoo = Zoo(3,5,7,8)#3.5用来初始化装饰器中的类需要的参数.7，8为被修饰的类自己的类初始化时需要的参数。
print(zoo.__class__)    # <class '__main__.outer.<locals>.Inner'>
zoo.say() #装饰器中不存在say()方法，所以会通过__getarrt__方法调用被修饰类中的同名方法。                 
zoo.abc()
zoo.Zoo_print()
print(zoo.name)
print(zoo.number)

结果报错：

RecursionError: maximum recursion depth exceeded while calling a Python object

显示调用类对象失败。未能成功调用被修饰的类中的say()方法。

当装饰器执行了被修饰类且被修饰的类中含有同名方法时，会通过__getarrt_方法调用被修饰的类中的同名方法：

def outer(clss):   # 类装饰器，clss为一个类
    class Inner():#装饰器修饰的是类对象，所以闭包的返回值为类。该类由被修饰的实例对象来初始化（即该类中
        # 需要外传参数时，可通过实例化的对象来完成。）
        def __init__(self,a,b,u,v):
            self.clss = clss(u,v)#执行被修饰的实例对象。
            self.name='zhangsan'
    # a,b参数由被修饰的实例对象实例化时进行传递，若果被修饰的类初始化时需要传递参数，也需要在实例化时一并传递进来。
            self.number=a+b

#__getattr_为内置方法，当使用点号获取实例属性时，如果属性不存在实例对象就自动调用__getattr__方法,
        # 通过该方法来获取被修饰对象中对应的同名属性值。
        def __getattr__(self, attr):
            return getattr(self.clss, attr)#获取类的某个属性值。

# 当下面的say方法在装饰器中不存在时，装饰器就会通过__getattr__函数调用被修饰的类中的say方法,前提是被修饰的实例对象被执行，
#   并且被修饰的类当中存在同名方法。
        #def say(self):
           #print(self.name)
           # print(self.number)

        def abc(self):
            print("This is the add function")

    return Inner#装饰器的返回类型必须和被修饰的函数一致.


@outer          # Zoo = outer(Zoo)
class Zoo():
    def __init__(self,x,y):
        self.Zoo_sum=x*y


    def say(self,u,v):
        print('This is in original class')
    def Zoo_print(self):
        print(f'This is Zoo_out:{self.Zoo_sum}')

zoo = Zoo(3,5,7,8)#3.5用来初始化装饰器中的类需要的参数.7，8为被修饰的类自己的类初始化时需要的参数。
print(zoo.__class__)    # <class '__main__.outer.<locals>.Inner'>
zoo.say()                  # hello world!
zoo.abc()
zoo.Zoo_print()
print(zoo.name)
print(zoo.number)

结果如下：

<class '__main__.outer.<locals>.Inner'>
This is in original class
This is the add function
This is Zoo_out:56
zhangsan
8

2.4、用类作为装饰器。

用来作为装饰器是通过类中的__call__方法来实现的。
用类作为装饰器通常有两种写法：
(1)、通过模拟函数装饰器来实现对被装饰函数的修饰：

class Deco1():

     def __call__(self,func):
             def new_func(x,y,u,v):
                 print(f'The running functiong is: {func.__name__}')
                 print(f'The sum of x and y is:{x+y}')
                 func(u,v)
             return new_func

@Deco1()#将__call__方法返回的引用传递给了foo（）函数。
def foo(u,v):
    print('This is in original function')
    print('The sum of u and v is:{}'.format(u+v))

foo(1,2,3,4)#初始化__call__方法中的参数。

输出结果如下：

The running functiong is: foo
The sum of x and y is:3
This is in original function
The sum of u and v is:7

(2)、直接实现对被装饰的函数的修饰

class Warp(object):
    #def __init__(self):
       # pass
 
    def __call__(self, obj):
        obj.name = 'warp'
        print('This is in {} function'.format(obj.__name__))
        return obj
@Warp()
def foo():
    print('this is foo')
 
#print(foo.name)    # => warp

foo() 
print(foo.name)

输出结果如下：

This is in foo function
this is foo
warp

在本例中直接为foo()函数添加了name属性以及额外的print（）函数。

white-poplar
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python-类内函数的全局装饰器
Rainy Chan
05-21 3488
有时，比如写RF的测试库的时候，很多方法都写在一个类里。我们又可能需要一个通用的装饰器，比如，要给某个底层类的方法打桩，查看入参和出参，用以理解业务；或者要hold住所有的执行错误，打印堆栈又不想程序退出或用例直接失败 比如捕捉错误的装饰器 import traceback from functools import wraps def trier(soft=False): ''' ...
python中装饰器的应用
qq_42732013的博客
09-06 426
1.装饰器： "在不改变原函数的基础上，给函数增加功能" 把一个函数当作参数，返回一个替代版的函数 本质上：返回函数的函数 # 装饰器的概念 - 装饰器的实现是函数里面嵌套函数; - 装饰器的本质是一个函数， 它可以让其他函数在不需要做任何代码改动的前提下增加额外的功能; - 装饰器需要传递一个函数， 返回值也是一个函数对象. # 装饰器的应用场景 - 计时器 - 记录日志 - 用户登录验证...
92. Python中多个装饰器的应用示例
qq_43687755的博客
09-09 312
Lesson 92 Python中多个装饰器的应用示例 文章目录1. 示例1：多个装饰器调用顺序2. 多个装饰器的应用示例：判断用户是不是root用户，root用户可以添加和删除 1. 示例1：多个装饰器调用顺序 通过下面这个例子来研究多个装饰器的调用顺序 def decorator_a(fun): def inner_a(*args,**kwargs): print('...
python中装饰器的简单应用
weixin_43035074的博客
09-23 114
python中装饰器的简单应用 import time # 函数装饰器小示例 计算程序耗时时间 # 装饰器 def time_des(fun): name = 'kobe' def inner(): start_time = time.time() print(name) fun() end_time = time.time() print('函数运行时间为{}'.format(end_time - start
Python - 装饰器的应用
weixin_46417042的博客
03-09 169
函数装饰器 (无参) ★要点说明： 装饰器符号为@ 在定义函数的上方带有装饰器意味着，调用函数时候，先执行装饰器里面内容 使用装饰器可以让其他函数在不需要做任何代码变动的前提下增加其他功能 装饰器一般用于插入日志、性能测试、事务处理、缓存、权限校验 # 函数装饰器 (无参) def test(func): def execute(): print(func.__name__,"函数性能测试成功") return execute @test def run():
简单上手Python中装饰器的使用
09-21
### Python装饰器详解 #### 一、装饰器概念与作用 在Python中，装饰器是一种高级功能，允许我们在不修改原有函数代码的情况下增强或修改函数的功能。它通过将一个函数作为参数并返回一个新的函数来实现这一点。...
python中装饰器级连的使用方法示例
09-21
总结起来，Python中的装饰器级联允许我们在不改变函数代码的情况下，通过叠加多个装饰器来增强函数的功能。这在实际开发中非常有用，可以提高代码的可维护性和可读性。通过学习和熟练掌握装饰器的使用，你可以更高效...
Python中的装饰器详解及实际应用
一键难忘的博客
03-09 3353
在Python编程中，装饰器（Decorator）是一种强大而灵活的工具，用于修改函数或方法的行为。它们广泛应用于许多Python框架和库，如Flask、Django等。本文将深入探讨装饰器的概念、使用方法，并提供实际应用的代码示例和详细解析。
Python装饰器的理解和应用
随心写写
08-17 406
Decorator 装饰器 文章目录Decorator 装饰器装饰器的作用无参数decorator有参数decorator装饰器的优化类装饰器（不带参数）类装饰器（带参数）偏函数偏函数与类实现装饰器装饰类的装饰器wraps再理解python内置装饰器：property 装饰器的作用 打印日志: @log 检测性能：@performance 数据库事务： @transaction URL路由：@...
90. Python中装饰器的应用示例
qq_43687755的博客
09-09 161
Lesson 90 Python中装饰器的应用示例 文章目录1. 装饰器的定义 1. 装饰器的定义
python装饰器（Decorator）
棠越的博客
03-04 3704
python装饰器（Decorator）
Python装饰器的使用详解
lIujunXHU的博客
02-29 1937
在函数嵌套的前提下，内部函数使用外部函数的变量，并且外部函数返回内部函数我们把这个使用外部函数变量的内部函数称为闭包。
Python装饰器的10个应用场景
最新发布
CSDN_224022的博客
04-11 1079
装饰器本质上是一个函数，它接受一个函数作为参数并返回一个新函数。通过使用`@`符号，我们可以将装饰器应用于任何函数。
《零基础看得懂的C语言入门教程 》——（十一）C语言自定义函数真的很简单
热门推荐
1_bit 的博客
10-31 1万+
一、学习目标 了解C语言的基本数据类型 注意：本篇内容知识大多为理论知识，如觉得生涩难懂也没关系，下一节将会以实际示例出发学习这些理论知识。 二、了解C语言程序的基本数据类型 五、总结 通过以上描述与讲解，我们了解了以下几点内容： 初学者开始写代码先从main之后的花括号内编写代码 了解了函数的概念为一个功能的实现 了解了printf函数的使用方法，在函数内传入值即可在程序运行时显示 知道了头文件的位置及函数存放于头文件内 了解了stystem函数是调用DOS系统命令的函数 了解了main的作用是表示
python 类装饰器和函数装饰器区别_Python装饰器最佳实践，使用类与函数
weixin_39596975的博客
11-23 161
说每种方法是否有“优点”是相当主观的。然而，对引擎盖下的东西有一个很好的理解会使它变得自然为每个场合挑选最佳选择。decorator（指函数decorators）只是一个以函数作为输入参数的可调用对象。Python有一个相当有趣的设计，它允许一个用于创建除函数之外的其他类型的可调用对象，另一个用于有时创建更易于维护或更短的代码。在Python2.3中，Decorators作为def a(x):.....
python property描述符_python的描述符(descriptor)、装饰器（property）造成的一个无限递归问题分享...
weixin_31414515的博客
02-03 117
分享一下刚遇到的一个小问题，我有一段类似于这样的python代码：复制代码 代码如下:# coding: utf-8class A(object):@propertydef _value(self):# raise AttributeError("test")return {"v": "This is a test."}def __getattr__(self, key):print...
二十四种场景全方位解读Python装饰器的用法
redrose2100的博客
07-19 629
详细列举了24中装饰器使用场景，并应用实例进行详细的解说，掌握装饰器是阅读源码的一个重要基础
Python中的多重装饰器实现解析
总结来说，Python中的多重装饰器允许我们组合多个装饰器，以实现更复杂的功能，同时保持代码的简洁性和可读性。装饰器可以用于日志记录、性能测试、权限控制等多种场景，是Python语言的一个重要特性。理解并熟练运用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值