python中的装饰器有哪些,总结Python中的装饰器知识点

python中的装饰器有哪些

python中的装饰器有哪些
python中的装饰器有哪些

1、简单举例 Python 标准库中的装饰器

2、说说你用过的 Python 标准库中的装饰器

首先,我们比较熟悉,也是比较常用的 Python 标准库提供的装饰器有:property,classmethod,staticmethod,functools.wraps四个。这四个的可考点比较多,这里将分别说明:

首先先来说明 functools.wraps,这个我们在之前翻译装饰器时已经谈到过。这里我们同样用代码来说明吧。

# 比如一个简单的用来统计代码运行时长的装饰器
import time
def method_spend(func):
def inner(*args, **kwargs):
start = time.time()
result = func(*args, **kwargs)
end = time.time()
print('[%0.8fs] %s --> %s' % ((end-start), func.__name__, result))
return result
return inner
@method_spend
def test():
print("Hello World")
test()
# outputs:
# Hello World
# [0.00001907s] test --> None
test = test
print(test.__name__)  # inner

从代码可以看出,经过装饰之后,被装饰函数的 name__ 属性被修改了,变成了装饰后的函数。(实际上 __doc 属性也一样被修改了)。而functools.wraps 的作用就是保存被装饰函数的属性。

引用《流畅的Python》中的话

functools.wraps 的作用是协助构建行为良好的装饰器。

使用示例:

import time
import functools
def method_spend(func):
@functools.wraps(func)  #  使用 functools.wraps
def inner(*args, **kwargs):
start = time.time()
result = func(*args, **kwargs)
end = time.time()
print('[%0.8fs] %s --> %s' % ((end-start), func.__name__, result))
return result
return inner
@method_spend
def test():
print("Hello World")
test()
# outputs:
# Hello World
# [0.00001907s] test --> None
test = test
print(test.__name__)  # test

接着我们来谈谈 staticmethod 和 classmethod。这个相对考得比较少,但也需要知道。classmethod 可类比于 JAVA 中的类方法,它第一个参数必须是类对象,而不是类的实例对象。而 staticmethod 作用与 classmethod 类似,可不能过实例对象来调用,但它不强制参数,可以是任何参数。

最后,来简单说下 property 。property 比较重要,后面会再开专题介绍。这里只简单说明它的作用,那就是实现类似 JAVA 中的私有变量的封装,并提供一个获取方法,类似于getXxx 和 setXXX 方法。用代码说话:

# 实现一个简单的 人 类,然后对年龄进行私有化
class Person(object):
@property
def age(self):
return self._age
# 这样的好处是,可以自定义赋值的逻辑,比如对数据进行某种验证
@age.setter  # 这里 age 与 @property 包装的函数名一致
def age(self, value):
if value > 18:  # 永远18
value = 18
self._age = value
p = Person()
p.age = 18  # 实际上调用的是 p.set_age(60)
print(p.age)  # 实际上调用的是 p.get_age()

functools.lru_cache 装饰器。从字面来理解,lru 为 “Least Recently Used”即最近最少使用,cache,不用说,缓存的意思。所以我们就大致知道这个装饰器的作用了,就是缓存部分数据,如果缓存的数据超过限制,就通过 最近最少使用 的规则来淘汰数据。来看一个简单的例子:

# 一个简单的缓存用户的示例
import functools
@functools.lru_cache()
def get_user_info(user_id):
# 根据用户 id 从数据库获取用户信息,这里简单的输出 id
print("finding by %s" % user_id)
return user_id
print(get_user_info(1))  # outputs: finding by 1 1
print(get_user_info(1))  # outputs: 1 (可以发现直接拿到了结果)
print(get_user_info(1.0))  # outputs: 1 (可以发现这里没有区分浮点数与整数)
print(get_user_info(2))  # outputs: funding by 2 2
这里需要注意的是, lru_cache 有两个可选的参数配置:
functools.lru_cache(maxsize=128, typed=False)

其中,maxsize 指定可以缓存多少个结果,缓存满了之后,旧的结果被丢弃。一般建议 maxsize 的值是 2 的幂。typed 参数如果设置为 True,会区分不同类型的结果。比如会将 1 和 1.0 区分开。

functools.singledispatch 装饰器。这个也比较好理解,它的作用是用来将if…elif..elif…else 这样的代码进行模块化。有点类似于 JAVA 中重载的意味,但又不全是。它是在 Python 3.4 中新增的。我们来看一个简单的例子:

# 一个简单的根据不同类型的数据来进行不同的展示
import functools
@functools.singledispatch
def my_print(obj):
print("%s -> %s" % (obj, type(obj)))
@my_print.register(str)  # 如果是字符串类型,相当于 if isinstance(str_msg, str)
def _(str_msg):
print("我是str")
print("%s -> %s" % (str_msg, type(str_msg)))
@my_print.register(int)  # 如果是字符串类型,相当于 if isinstance(int_msg, int)
def _(int_msg):
print("我是int")
print("%s -> %s" % (int_msg, type(int_msg)))
my_print("haha")  # outputs: 我是str haha -> 
my_print(1)  # outputs: 我是int 1 -> 
my_print([1]) # outputs: [1] -> 

总结Python中的装饰器知识点

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

一、闭包

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

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

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

def print_msg(msg):
    def printer():
        print(msg)
printer()print_msg('Hello World')# Hello World

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

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

def print_msg(msg):
    def printer():
        print(msg)
    return printer
my_msg = print_msg('Hello World')my_msg()# Hello World

本例中的 printer 函数就是闭包。

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

def printer():
print('Hello World')

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

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

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 函数是闭包。

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

print(inner.__closure__[0].cell_contents)# Hello World

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

闭包的优点如下:

局部变量无法共享和长久的保存,而全局变量可能造成变量污染,闭包既可以长久的保存变量又不会造成全局污染。

闭包使得函数内局部变量的值始终保持在内存中,不会在外部函数调用后被自动清除。

二、装饰器

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

def module():
    print('功能1')
    print('功能2')
    print('功能3')
    print('功能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

版权声明:本文(即:原文链接:https://www.qin1qin.com/catagory/580/)内容由互联网用户自发投稿贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌抄袭侵权/违法违规的内容, 请发送邮件至 630367839@qq.com 举报,一经查实,本站将立刻删除。

(0)
上一篇 2022年 6月 28日 4:17:49
下一篇 2022年 6月 29日 11:22:09

软件定制开发公司

相关阅读

发表回复

登录后才能评论
通知:禁止投稿所有关于虚拟货币,币圈类相关文章,发现立即永久封锁账户ID!