写点什么

Python 中级知识之装饰器,滚雪球学 Python

发布于: 2021 年 03 月 11 日
Python 中级知识之装饰器,滚雪球学 Python

橡皮擦,一个逗趣的互联网高级网虫,新的系列,让我们一起 Be More Pythonic


已完成的文章清单


  1. 滚雪球学 Python 第二轮开启,进阶之路,列表与元组那些事儿

  2. 说完列表说字典,说完字典说集合,滚雪球学 Python

  3. 关于 Python 中的字符串,我在补充两点,滚雪球学 Python

  4. 列表推导式与字典推导式,滚雪球学 Python

  5. 滚雪球学 Python 之 lambda 表达式

  6. 滚雪球学 Python 之内置函数:filter、map、reduce、zip、enumerate


七、函数装饰器


装饰器(Decorators)在 Python 中,主要作用是修改函数的功能,而且修改前提是不变动原函数代码,装饰器会返回一个函数对象,所以有的地方会把装饰器叫做 “函数的函数”。

还存在一种设计模式叫做 “装饰器模式”,这个后续的课程会有所涉及。


装饰器调用的时候,使用 @,它是 Python 提供的一种编程语法糖,使用了之后会让你的代码看起来更加 Pythonic


7.1 装饰器基本使用


在学习装饰器的时候,最常见的一个案例,就是统计某个函数的运行时间,接下来就为你分享一下。

计算函数运行时间:


import time
def fun(): i = 0 while i < 1000: i += 1def fun1(): i = 0 while i < 10000: i += 1s_time = time.perf_counter()fun()e_time = time.perf_counter()print(f"函数{fun.__name__}运行时间是:{e_time-s_time}")
复制代码

如果你希望给每个函授都加上调用时间,那工作量是巨大的,你需要重复的修改函数内部代码,或者修改函数调用位置的代码。在这种需求下,装饰器语法出现了。


先看一下第一种修改方法,这种方法没有增加装饰器,但是编写了一个通用的函数,利用 Python 中函数可以作为参数这一特性,完成了代码的可复用性。


import timedef fun():    i = 0    while i < 1000:        i += 1
def fun1(): i = 0 while i < 10000: i += 1
def go(fun): s_time = time.perf_counter() fun() e_time = time.perf_counter() print(f"函数{fun.__name__}运行时间是:{e_time-s_time}")
if __name__ == "__main__": go(fun1)
复制代码


接下来这种技巧扩展到 Python 中的装饰器语法,具体修改如下:


import time
def go(func): # 这里的 wrapper 函数名可以为任意名称 def wrapper(): s_time = time.perf_counter() func() e_time = time.perf_counter() print(f"函数{func.__name__}运行时间是:{e_time-s_time}") return wrapper
@godef func(): i = 0 while i < 1000: i += 1@godef func1(): i = 0 while i < 10000: i += 1
if __name__ == '__main__': func()
复制代码


在上述代码中,注意看 go 函数部分,它的参数 func 是一个函数,返回值是一个内部函数,执行代码之后相当于给原函数注入了计算时间的代码。在代码调用部分,你没有做任何修改,函数 func 就具备了更多的功能(计算运行时间的功能)。


装饰器函数成功拓展了原函数的功能,又不需要修改原函数代码,这个案例学会之后,你就已经初步了解了装饰器。


7.2 对带参数的函数进行装饰


直接看代码,了解如何对带参数的函数进行装饰:


import time
def go(func): def wrapper(x, y): s_time = time.perf_counter() func(x, y) e_time = time.perf_counter() print(f"函数{func.__name__}运行时间是:{e_time-s_time}") return wrapper
@godef func(x, y): i = 0 while i < 1000: i += 1 print(f"x={x},y={y}")
if __name__ == '__main__': func(33, 55)
复制代码


如果你看着晕乎了,我给你标记一下参数的重点传递过程。


还有一种情况是装饰器本身带有参数,例如下述代码:


def log(text):    def decorator(func):        def wrapper(x):            print('%s %s():' % (text, func.__name__))            func(x)        return wrapper    return decorator
@log('执行')def my_fun(x): print(f"我是 my_fun 函数,我的参数 {x}")
my_fun(123)
复制代码


上述代码在编写装饰器函数的时候,在装饰器函数外层又嵌套了一层函数,最终代码的运行顺序如下所示:


my_fun = log('执行')(my_fun)
复制代码


此时如果我们总结一下,就能得到结论了:使用带有参数的装饰器,是在装饰器外面又包裹了一个函数,使用该函数接收参数,并且返回一个装饰器函数。

还有一点要注意的是装饰器只能接收一个参数,而且必须是函数类型。


7.3 多个装饰器


先临摹一下下述代码,再进行学习与研究。


import time
def go(func): def wrapper(x, y): s_time = time.perf_counter() func(x, y) e_time = time.perf_counter() print(f"函数{func.__name__}运行时间是:{e_time-s_time}") return wrapper
def gogo(func): def wrapper(x, y): print("我是第二个装饰器") return wrapper
@go@gogodef func(x, y): i = 0 while i < 1000: i += 1 print(f"x={x},y={y}")
if __name__ == '__main__': func(33, 55)
复制代码


代码运行之后,输出结果为:


我是第二个装饰器函数wrapper运行时间是:0.0034401339999999975
复制代码


虽说多个装饰器使用起来非常简单,但是问题也出现了,print(f"x={x},y={y}") 这段代码运行结果丢失了,这里就涉及多个装饰器执行顺序问题了。


先解释一下装饰器的装饰顺序。


import timedef d1(func):    def wrapper1():        print("装饰器1开始装饰")        func()        print("装饰器1结束装饰")    return wrapper1
def d2(func): def wrapper2(): print("装饰器2开始装饰") func() print("装饰器2结束装饰") return wrapper2
@d1@d2def func(): print("被装饰的函数")
if __name__ == '__main__': func()
复制代码


上述代码运行的结果为:


装饰器1开始装饰装饰器2开始装饰被装饰的函数装饰器2结束装饰装饰器1结束装饰
复制代码


可以看到非常对称的输出,同时证明被装饰的函数在最内层,转换成函数调用的代码如下:


d1(d2(func))
复制代码


你在这部分需要注意的是,装饰器的外函数和*内函数*之间的语句,是没有装饰到目标函数上的,而是在装载装饰器时的附加操作。

在对函数进行装饰的时候,外函数与内函数之间的代码会被运行。


测试效果如下:


import time
def d1(func): print("我是 d1 内外函数之间的代码") def wrapper1(): print("装饰器1开始装饰") func() print("装饰器1结束装饰") return wrapper1
def d2(func): print("我是 d2 内外函数之间的代码") def wrapper2(): print("装饰器2开始装饰") func() print("装饰器2结束装饰") return wrapper2
@d1@d2def func(): print("被装饰的函数")
复制代码


运行之后,你就能发现输出结果如下:


我是 d2 内外函数之间的代码我是 d1 内外函数之间的代码
复制代码


d2 函数早于 d1 函数运行。


接下来在回顾一下装饰器的概念:

被装饰的函数的名字会被当作参数传递给装饰函数。

装饰函数执行它自己内部的代码后,会将它的返回值赋值给被装饰的函数。


这样看上文中的代码运行过程是这样的,d1(d2(func)) 执行 d2(func) 之后,原来的 func 这个函数名会指向 wrapper2 函数,执行 d1(wrapper2) 函数之后,wrapper2 这个函数名又会指向 wrapper1。因此最后的 func 被调用的时候,相当于代码已经切换成如下内容了。


# 第一步def wrapper2():     print("装饰器2开始装饰")     print("被装饰的函数")     print("装饰器2结束装饰")
# 第二步print("装饰器1开始装饰")wrapper2()print("装饰器1结束装饰")
# 第三步def wrapper1(): print("装饰器1开始装饰") print("装饰器2开始装饰") print("被装饰的函数") print("装饰器2结束装饰") print("装饰器1结束装饰")
复制代码


上述第三步运行之后的代码,恰好与我们的代码输出一致。


那现在再回到本小节一开始的案例,为何输出数据丢失掉了。


import time
def go(func): def wrapper(x, y): s_time = time.perf_counter() func(x, y) e_time = time.perf_counter() print(f"函数{func.__name__}运行时间是:{e_time-s_time}") return wrapper
def gogo(func): def wrapper(x, y): print("我是第二个装饰器") return wrapper
@go@gogodef func(x, y): i = 0 while i < 1000: i += 1 print(f"x={x},y={y}")
if __name__ == '__main__': func(33, 55)
复制代码


在执行装饰器代码装饰之后,调用 func(33,55) 已经切换为 go(gogo(func)),运行 gogo(func) 代码转换为下述内容:


def wrapper(x, y):	print("我是第二个装饰器")
复制代码


在运行 go(wrapper),代码转换为:


s_time = time.perf_counter()print("我是第二个装饰器")e_time = time.perf_counter()print(f"函数{func.__name__}运行时间是:{e_time-s_time}")
复制代码


此时,你会发现参数在运行过程被丢掉了。


7.4 functools.wraps


使用装饰器可以大幅度提高代码的复用性,但是缺点就是原函数的元信息丢失了,比如函数的 __doc____name__


# 装饰器def logged(func):    def logging(*args, **kwargs):        print(func.__name__)        print(func.__doc__)        func(*args, **kwargs)    return logging
# 函数@loggeddef f(x): """函数文档,说明""" return x * x
print(f.__name__) # 输出 loggingprint(f.__doc__) # 输出 None
复制代码


解决办法非常简单,导入 from functools import wraps ,修改代码为下述内容:


from functools import wraps# 装饰器def logged(func):    @wraps(func)    def logging(*args, **kwargs):        print(func.__name__)        print(func.__doc__)        func(*args, **kwargs)    return logging
# 函数@loggeddef f(x): """函数文档,说明""" return x * x
print(f.__name__) # 输出 fprint(f.__doc__) # 输出 函数文档,说明
复制代码


7.5 基于类的装饰器


在实际编码中 一般 “函数装饰器” 最为常见,“类装饰器” 出现的频率要少很多。


基于类的装饰器与基于函数的基本用法一致,先看一段代码:


class H1(object):    def __init__(self, func):        self.func = func
def __call__(self, *args, **kwargs): return '<h1>' + self.func(*args, **kwargs) + '</h1>'
@H1def text(name): return f'text {name}'
s = text('class')print(s)
复制代码


H1 有两个方法:


  • __init__:接收一个函数作为参数,就是待被装饰的函数;

  • __call__:让类对象可以调用,类似函数调用,触发点是被装饰的函数调用时触发。


最后在附录一篇写的不错的 博客,可以去学习。


在这里类装饰器的细节就不在展开了,等到后面滚雪球相关项目实操环节再说。


装饰器为类和类的装饰器在细节上是不同的,上文提及的是装饰器为类,你可以在思考一下如何给类添加装饰器。


7.6 内置装饰器


常见的内置装饰器有 @property@staticmethod@classmethod。该部分内容在细化面向对象部分进行说明,本文只做简单的备注。


7.6.1 @property

把类内方法当成属性来使用,必须要有返回值,相当于 getter,如果没有定义 @func.setter 修饰方法,是只读属性。


7.6.2 @staticmethod

静态方法,不需要表示自身对象的 self 和自身类的 cls 参数,就跟使用函数一样。


7.6.3 @classmethod

类方法,不需要 self 参数,但第一个参数需要是表示自身类的 cls 参数。


7.7 这篇博客的总结

关于 Python 装饰器,网上的文章实在太太多了,学习起来并不是很难,真正难的是恰到好处的应用在项目中,希望本篇博客能对你理解装饰器有所帮助。

其他内容也可以查阅 官方手册


相关阅读


  1. Python 爬虫 100 例教程,超棒的爬虫教程,立即订阅吧

  2. Python 爬虫小课,精彩 9 讲




博主 ID:梦想橡皮擦,希望大家<font color="red">点赞</font>、<font color="red">评论</font>、<font color="red">收藏</font>。


发布于: 2021 年 03 月 11 日阅读数: 28
用户头像

爬虫 100 例作者,蓝桥签约作者,博客专家 2021.02.06 加入

6 年产品经理+教学经验,3 年互联网项目管理经验; 互联网资深爱好者; 沉迷各种技术无法自拔,导致年龄被困在 25 岁; CSDN 爬虫 100 例作者。 个人公众号“梦想橡皮擦”。

评论

发布
暂无评论
Python 中级知识之装饰器,滚雪球学 Python