Python装饰器各种类型详解

最新推荐文章于 2024-09-10 08:00:00 发布
最新推荐文章于 2024-09-10 08:00:00 发布
阅读量8.6k 收藏 126
点赞数 35
分类专栏： linux自动化运维 文章标签： 装饰器 装饰器大全解 装饰器类型 Python Python装饰器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yhy1271927580/article/details/72758577
版权

装饰器

装饰器有很多经典的使用场景，例如插入日志、性能测试、事务处理等等，有了装饰器，就可以提取大量函数中与本身功能无关的类似代码，从而达到代码重用的目的，而且还能将函数和类的功能进行扩充，实现被装饰对象的功能扩展

这里写图片描述

装饰器总结

发现很多Python新手对装饰器以及具有描述器功能的装饰器理解不是很全面，下面通过自我的总结，对Python中的装饰器进行了分类，并且给出分类后的实例代码，希望对大家理解装饰器有帮助。装饰器总而言之：装饰器就是对函数(方法)或者类的功能进行扩充，将扩充之后的函数(方法)或者类再返回。因此，在调用这个函数(方法)或者类的时候，就不会调用元素的函数(方法)或者类了，而是调用返回的新函数(新方法)或者新类

一： 装饰器自身为函数

（一）：被装饰的对象为函数，且不带参数
对以下代码简要说明： @timeit装饰器对sleep函数进行了装饰，这是一个装饰器不带参数的装饰器，当sleep函数调用的时候，调用的并不是我们看到的原始的sleep函数，而是装饰过后的sleep函数。这个装饰的过程会发生在调用sleep函数之前发生。装饰的过程：原生的sleep函数作为参数传递到timeit装饰器函数的fn参数，通过@wraps这个装饰器将fn的属性赋值给底下需要返回的wrap函数，最后返回wrap函数，由此可间，wrap就是装饰过后的sleep函数了。那么在调用新sleep函数的时候，就是调用wrap函数，sleep函数的参数1，被wrap函数的*args、**kwargs这两个可变参数接收。整个装饰的目的就是将原生的sleep函数，扩充了一个print(nowTime() - start)的过程。
from time import sleep as sleeping
from time import time as nowTime
from functools import wraps

# 装饰器为函数
def timeit(fn):
    @wraps(fn)
    def wrap(*args,**kwargs):
        start = nowTime()
        ret = fn(*args,**kwargs)
        print(nowTime() - start)
        return ret
    return wrap

# 装饰的对象为函数
@timeit
def sleep(n):
    sleeping(n)
    print("我睡了{}秒".format(n))
    return n

# 调用装饰后的sleep函数    
sleep(1)
print(sleep.__name__)
（二）：被装饰的对象为函数，且带参数
对以下代码简要说明： @timeit装饰器对sleep函数进行了装饰，这是一个装饰器是带参数的装饰器，这个装饰器由于需要传递参数，因此需要两层装饰，第一层是接受传递的参宿，第二层是接收传递进来的需要装饰的函数当sleep函数调用的时候，调用的并不是我们看到的原始的sleep函数，而是装饰过后的sleep函数。这个装饰的过程会发生在调用sleep函数之前发生。装饰的过程：装饰器第一次接收cpu_time参数，然后返回一个dec装饰器，而这个dec装饰器会被再次调用，传入参数是原生的sleep函数，原生的sleep函数作为参数传递到dec装饰器函数的fn参数，通过@wraps这个装饰器将fn的属性赋值给底下需要返回的wrap函数，最后返回wrap函数，由此可间，wrap就是装饰过后的sleep函数了。那么在调用新sleep函数的时候，就是调用wrap函数，sleep函数的参数1，被wrap函数的*args、**kwargs这两个可变参数接收。整个装饰的目的就是将原生的sleep函数，扩充了一个time_func = time.clock if cpu_time else time.time和print(nowTime() - start)的过程。
from functools import wraps
import time

# 装饰器自身为函数，且装饰器接受参数
def timeit(cpu_time=False):
    time_func = time.clock if cpu_time else time.time
    def dec(fn):
        @wraps(fn)
        def wrap(*args,**kwargs):
            start = time_func()
            ret = fn(*args,**kwargs)
            print(time_func() - start)
            return ret
        return wrap
    return dec

# 装饰对象为函数
@timeit(False)
def sleep(n):
    time.sleep(n)
    return n

# 调用装饰后的sleep函数 
sleep(1)
print(sleep.__name__)
（三）：被装饰的对象为类，且不带参数
对以下代码简要说明：这是一个基于装饰器的单例设计模式。通过装饰器装饰这个类，使得类在初始化的时候始终将初始化实例赋值给instance，而instance是装饰器的一个实例对象，通过实例赋值，使得instance始终占有同一个内存空间，也就实现了单例设计
from functools import wraps
def singleton(cls):
    # 在装饰器中声明一个变量，用于保存类的实例，那么这个实例对象将始终是通一个实例对象
    instance = None
    @wraps(cls)
    def wrap(*args,**kwargs):
        # 使用nonlocal关键字将作用域扩展到上一级，拿到上一级的instance变量
        nonlocal instance
        # 如果instance非空，那么将instance通过cls类，也就是A进行初始化
        if instance is None:  
            instance = cls(*args,**kwargs)
        return instance
    return wrap

# 装饰的对象是类
@singleton
class A:
    def __init__(self):
        self.name = 'yhy'
# 实例化装饰后的类
a = A()
print(id(a))  # 4321677152
b = A()
print(id(b))  # 4321677152
（四）：被装饰的对象为类，且带参数
对以下代码简要说明：下面代码为带参数的。可以对比看出，装饰器自身为函数，且带参数与不带参数的区别就是：带参数的装饰器比不带参数的装饰器多了一层。为什么？因为第一层装饰用来解释装饰器的参数，第二层才能够接收被装饰的对象
from functools import wraps

# 装饰器自身为函数
def singleton(instance=False):
    name = 'yhy did it' if instance else 'yhy didn\'t it'
    def dec(cls):
        instance = None
        @wraps(cls)
        def wrap(*args,**kwargs):
            nonlocal instance
            print(name)
            if instance is None:
                instance = cls(*args,**kwargs)
            return instance
        return wrap
    return dec

# 装饰的对象是类
@singleton(True)
class A:
    def __init__(self):
        self.name = 'yhy'

# 实例化装饰后的类
a = A()
print(id(a))  # 4321677152
b = A()
print(id(b))  # 4321677152
对以下代码简要说明：通过setattr魔术方法，对Person类进行了修改，这里的name作为类属性，name = TypeCheck(name, required_type)，这样就将Person类进行了改造，使得Person类有了两个类变量，一个是name = TypeCheck(‘name’, required_type), 另一个是age = TypeCheck(‘age’, required_type)，因此，Person(‘yhy’,18) 初始化的时候，self.name 中的name不是实例变量而是类变量，会调用描述器TypeCheck，赋值的时候，就会调用__set__方法，取值的时候会调用__get__方法。这个例子是一个经典的装饰器装饰类，使得被装饰的新类中的类变量绑定了描述器，因此，在给类变量赋值的时候，赋值过程是经过描述器赋值的，取值的时候也是通过描述器赋值的
from functools import wraps

class TypeCheck:
    def __init__(self, srcType, dstType):
        self.srcType = srcType
        self.dstType = dstType
    # instance == a , cls == A
    def __get__(self, instance, cls):
        if instance is None:
            return self
        return instance.__dict__[self.srcType]

    def __set__(self, instance, value):
        if isinstance(value,self.dstType):
            instance.__dict__[self.srcType] = value
        else:
            raise TypeError('{} should be {}'.format(value,self.dstType))


# 装饰器自身是一个函数
def typeassert(**kwargs):
    def dec(cls):
        def wraps(*args):
            for name, required_type in kwargs.items():
                setattr(cls, name, TypeCheck(name, required_type))
            return cls(*args)  # 这里是实例化新的Person类后返回实例对象，也就是p
        return wraps
    return dec

# 装饰对象是一个类，且带参数
@typeassert(name=str, age=int)
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age


# 实例化新的Person类,这里相对于调用的是wraps函数
p = Person('yhy',18)
print(p.name)
print(p.age)


# 装饰器修改后的Person类为下面这个新的Person类，因此实例化Person的时候，调用的是下面这个新的Person类
class Person:
    name = TypeCheck('name',str)
    age = TypeCheck('age',int)
    def __init__(self, name: str, age: int):
        self.name = name
        self.age = age

二：装饰器自身为类

（一）：被装饰的对象为函数
1：对以下代码简要说明：这里是通过装饰器装饰了一个类中的方法，也就是函数。从代码里可以看到，装饰的add方法被传递到装饰器的method参数里，通过wraps函数将method的属性赋值给self。当调用a.add()方法的时候，由于装饰器的功能就是返回一个扩充被装饰对象的函数，那么装饰器内部实现了__get__方法，此时装饰器扮演一个描述器的角色，当调用a.add()方法的时候，装饰器内部调用__get__方法，返回一个装饰后的add方法。这个例子是一个@staticmethod的实现，也是一个经典的装饰器通过描述器的特性装饰函数的例子。虽然装饰器没有扩充函数什么功能，但是Python解释器不会给add()方法传递self参数了，这也算一个扩充吧，如果没有@staticmethod装饰add()方法，add方法定义的时候需要一个add(self)参数，来接受解释器传递的self实例，那add(self)就是一个实例方法，不是静态方法，因为Add调用这个add()方法的时候解释器不会传递self实例。那么使用装饰器装饰后的add方法，解释器将不会传递self，因此Add.add()调用是可以的
from functools import wraps,partial

# 装饰器自身为类
class staticmethod:
    def __init__(self, method):
        wraps(method)(self)
    def __get__(self, instance, cls):
        # 通过partial函数返回一个带有None参数的add函数，因此在调用a.add()就不需要传递参数了
        return partial(self.__wrapped__)



class Add:
    def __init__(self, name, value):
        self.name = name
        self.value = value

    # 这里装饰的是一个函数
    @staticmethod
    def add():
        print('i am static method')


a = Add('yhy', 25)
a.add()

Add.add()
2：对以下代码简要说明：这是一个@Classmethod装饰器的实现，与@staticmethod的实现类似。partial函数将method方法进行了扩充，返回的method方法在原生的add基础之上返回一个带cls的method方法，因此在调用method的时候，由于x参数有默认值’y’，可以给a.method()传递一个参数或传递参数
from functools import wraps, partial


class Classmethod:
    def __init__(self,method):
        wraps(method)(self)

    def __get__(self, instance, cls):
        # 通过partial函数返回一个带cls的method方法，
        return partial(self.__wrapped__, cls)

class C:
    @Classmethod
    def method(cls,x='y'):
        print(cls)
        print(x)

# 调用装饰器返回的新method方法
C.method('yhy')
c = C()
c.method()
c.method('yhy')

输出为：
<class '__main__.C'>
yhy
<class '__main__.C'>
y
<class '__main__.C'>
yhy
（二）：被装饰的对象为函数，且带参数
对以下代码简要说明：@Require({‘root’, ‘admin’})装饰器装饰一个类，并且装饰器带参数。从结构上来说，只要类装饰器带有__call__函数，那么装饰器返回的就是这个__call__函数，但是这个装饰器带有参数，因此，返回的是wrap函数。也就是说，装饰器装饰后的新函数为wrap函数，当reboot（）调用的时候就是调用wrap函数，如果权限认证通过就返回fn()函数（这里的fn()是调用原生的reboot()函数）
from functools import wraps

# 假定权限
def get_permissions():
    return {'root'}

# 装饰器自身是类
class Require:
    def __init__(self,permissions):
        self.permissions = permissions
    # 被装饰的类传递到fn
    def __call__(self, fn):
        @wraps(fn)
        def wrap(*args, **kwargs):
            if len(set(self.permissions).intersection(get_permissions())) <= 0:
                raise Exception('Permissions denied')
            return fn(*args, **kwargs)
        return wrap

# 装饰器装饰的对象是函数
@Require({'root','admin'})
def reboot():
    pass
（三）：被装饰的对象为类，且不带参数
对以下代码简要说明：这里的A通过Singleton类装饰器传递给参数cls，但是这个类装饰器没有__get__方法，无法返回装饰后的类，但是有一个__call__方法。因此A()就相当于调用了装饰器的__call__方法。在__call__方法里面self.__wrapped__就是cls，也就是A类，实例化A类，创建一个实例self.instance，最后返回。因此，调用A().name，就是self.instance.name
from functools import wraps
class Singleton:
    # 这里的初始化函数只会调用一次，当第二次装饰的时候，这一步就滤过了
    # 因此，第二次装饰的时候，不会再执行__init__方法，直接返回一个Singleton实例对象，
    # 使得第二次调用__call__方法，发现self.instance有值，那么就直接返回了
    def __init__(self,cls):
        wraps(cls)(self)
        self.instance = None
    def __call__(self, *args, **kwargs):
        if self.instance is None:
            self.instance = self.__wrapped__(*args,**kwargs)
        return self.instance

# 装饰对象为类
@Singleton
class A:
    def __init__(self):
        self.name = 'yhy'


print(A().name)
# a和b是同一个实例
a = A()
b = A()
小总结：以上总结过程是本人在写Python代码的心得，将装饰器的应用形式进行了一个简单的分类。装饰器在Python中应用非常广泛，需要灵活应用。希望以上总结对小伙伴们有帮助，也希望大神批评指正
尹欢一
关注
专栏目录
python装饰器实例大详解
09-21
Python装饰器是一种强大的工具，它允许我们修改或增强已有函数的功能，而不必改变函数的源代码。装饰器本质上是接收一个函数作为参数并返回新函数的高阶函数。在这个实例大详解中，我们将深入探讨装饰器的作用域、...
python装饰器详解
热门推荐
weixin_44992737的博客
07-19 8万+
python装饰器
Python装饰器详解
千山暮彩
06-20 9092
详细介绍了Python装饰器语法的有关内容与使用技巧，希望对大家有所帮助。
python 装饰器
最新发布
lz146的博客
09-10 534
装饰器是 Python 中的一种设计模式，用于在不修改函数或类的源代码的情况下，动态地增加或扩展其功能。装饰器本质上是一个高阶函数，它接收一个函数或类作为参数，并返回一个新的函数或类。
Python中的四种类方法装饰器@abstractmethod、@classmethod、@property、@staticmethod
qq_44088823的博客
11-24 3515
四种类方法的装饰器简介
Python的四种装饰器
hdyebd的博客
02-21 481
什么是装饰器 装饰器是一个函数，它需要接收一个参数，该参数表示被修饰的函数。 装饰器需要满足的条件 装饰器是一个嵌套函数 内部函数是一个闭包 外部函数接收的是被修饰的函数 四种装饰器 不带参数装饰器 def wrapper(func): print(func) def new_func(*new_argument): print('before') ...
python装饰器使用实例详解
09-18
Python装饰器是Python语言中的一个强大特性，它允许我们在不修改原有函数代码的基础上，为函数添加额外的功能。装饰器本质上是一种闭包，它捕获并修改一个函数的行为。在这个实例中，我们将深入探讨如何使用装饰器...
python 自定义装饰器实例详解
09-19
### Python 自定义装饰器详解 #### 一、装饰器简介 在Python中，装饰器是一种特殊类型的函数，它可以修改其他函数的行为或者增加额外的功能。装饰器的基本语法是使用`@`符号来标记需要被装饰的函数。装饰器非常...
Python中的各种装饰器详解
09-22
Python中的装饰器是一种强大的工具，用于在不修改原始函数代码的情况下扩展或修改其功能。装饰器本质上是一个接收函数作为输入并返回新函数的函数。在Python中，它们主要用于处理类和函数的元编程。 1. **函数式...
Python装饰器的使用详解
逆鳞_Kevin的博客
12-11 4405
详解介绍python装饰器的使用方式，以及组建装饰器的多种形式
Python装饰器使用方法详解
Hello Word
01-25 4034
当涉及到处理有返回值的函数时，对于内部函数我们应该使用一个变量将函数的运行结果保存起来，并放在内层函数的return中。装饰器可以改变被装饰函数的行为，或者在调用被装饰函数之前和之后增加额外的操作。装饰器的语法是使用 @ 语法符，在函数定义之前增加装饰器函数的名称。函数中，我们增加了形参的输入，因此，在装饰器中，也要为之做出更改。权限控制：装饰器可以用来实现函数级别的权限控制，只允许特定的用户访问特定的函数。装饰器可以让你在函数或类的定义中添加额外的逻辑，而不更改它们的实现。在代码中，我们建立了一个名为。
5分钟掌握 Python 中的装饰器
Python中文社区
02-02 1487
python中的装饰器用于修饰函数，以增强函数的行为：记录函数执行时间，建立和撤销环境，记录日志等。装饰器可以在不修改函数内部代码的前提下实现以上增强行为。如下代码建立一个计时装饰器，随...
Python学习之——装饰器
selfsongs
12-13 5923
Python学习之——装饰器
python 装饰器详解
12-28 1167
python装饰器本质上就是一个函数，它可以让其他函数在不需要做任何代码变动的前提下增加额外的功能，装饰器的返回值也是一个函数对象。装饰器函数的外部函数传入我要装饰的函数名字，返回经过修饰后函数的名字；内层函数（闭包）负责修饰被修饰函数。从上面这段描述中我们需要记住装饰器的几点属性，以便后面能更好的理解：实质： 是一个函数参数：是你要装饰的函数名（并非函数调用）返回：是装饰完的函数名（也非函数调用）作用：为已经存在的对象添加额外的功能特点：不需要对对象做任何的代码上的变动。
Python-装饰器详解
qq_51010919的博客
06-29 2505
在Python中，装饰器是一种特殊的语法，用于修改或增强函数的功能。装饰器是Python的高级特性之一，它允许我们通过在不修改原函数代码的情况下，添加额外的功能或行为。装饰器是一个函数，它接受一个函数作为参数，并返回一个新的函数。装饰器函数通常使用符号放在要修饰的函数定义之前python中的装饰器(decorator)一般采用语法糖的形式，是一种语法格式。比如：@classmethod，@staticmethod，@property，@wraps()，等都是python中的装饰器。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值