
来源:麦叔编程
作者:麦叔
之前发过两篇装饰器的文章,当时为了博取眼球,标题取得虚头巴脑。现在把两篇合并在一起,重新发在『Python终结者』系列中,方便大家学习。
前不久,我面试过一个要求月薪30k+的程序员,还有一个浙大毕业的新人,两个人都自称最熟悉的编程语言是Python,但没有一个人知道装饰器。看完这篇文章,至少你在这方面超越了他们。
看透这篇文章,你至少超过了80%的Python学习者。
就算一周学透一个重要知识点,不久之后,你就会成为很厉害的存在!加油!!
对于Python学习者,一旦过了入门阶段,你几乎一定会用到Python的装饰器。
它经常使用在很多地方,比如Web开发,日志处理,性能搜集,权限控制等。
还有一个极其重要的地方,那就是面试的时候。对,装饰器是面试中最常见的问题之一!
抛出问题
看这段代码:
def step1(): print('step1.......') def step2(): print('step2......') def step3(): print('step3......')
step1()
step2()
step3()
代码中定义了3个函数,然后分别调用这3个函数。假设,我们发现代码运行很慢,我们想知道每个函数运行分别花了多少时间。
我们可以在每个函数中添加计时的代码:
下面的例子只在step1中添加了相关代码作为示例,你可以自行给step2和step3添加相关代码。
import time def step1(): start = time.time()
print('step1.......')
end = time.time()
used = end - start
print(used) def step2(): print('step2......') def step3(): print('step3......')
step1()
step2()
step3()
这个方法可行!但用你的脚指头想想也会觉得,这个方法很繁琐,很笨拙,很危险!
这里只有3个函数,如果有30个函数,那不是要死人啦。万一修改的时候不小心,把原来的函数给改坏了,面子都丢光了,就要被人BS了!
一定有一个更好的解决方法!
更好的解决方法是使用装饰器。
装饰器并没有什么高深的语法,它就是一个实现了给现有函数添加装饰功能的函数,仅此而已!
import time def timer(func): '''统计函数运行时间的装饰器''' def wrapper(): start = time.time()
func()
end = time.time()
used = end - start
print(f'{func.__name__} used {used}') return wrapper def step1(): print('step1.......') def step2(): print('step2......') def step3(): print('step3......')
timed_step1 = timer(step1)
timed_step2 = timer(step2)
timed_step3 = timer(step3)
timed_step1()
timed_step2()
timed_step3()
上面的timer函数就是个装饰器。
简单说就是把原来的函数给包了起来,在不改变原函数代码的情况下,在外面起到了装饰作用,这就是传说中的装饰器。它其实就是个普通的函数。
如果你觉得有点懵逼,需要加强一些对Python函数的理解。函数:
可以作为参数传递
可以作为返回值
也可以定义在函数内部
然后,我们不再直接调用step1, 而是:
timed_step1 = timer(step1) timed_step1()
简洁点,也可以这样写:
timer(step1)() timer(step2)() timer(step3)()
这样可以在不修改原有函数代码的情况下,给函数添加了装饰性的新功能。
但是仍然需要修改调用函数的地方,看起来还不够简洁。有没有更好的办法呢?当然是有的!
我们可以在被装饰的函数前使用@符号指定装饰器。这样就不用修改调用的地方了,这个世界清净了。下面的代码和上一段代码功能一样。在运行程序的时候,Python解释器会根据@标注自动生成装饰器函数,并调用装饰器函数。
import time def timer(func): '''统计函数运行时间的装饰器''' def wrapper(): start = time.time()
func()
end = time.time()
used = end - start
print(f'{func.__name__} used {used}') return wrapper @timer def step1(): print('step1.......') @timer def step2(): print('step2......') @timer def step3(): print('step3......')
step1()
step2()
step3()
到了这里,装饰器的核心概念就讲完了。
剩下的基本都是在不同场合下的应用。如果你是大忙人,不想学的太深,可以搜藏本文章,以后再回来看。
但是记得点在看。据说点了得都变帅了,也找到了好工作,或者升职加薪了。
上面是一个最简单的例子,被装饰的函数既没有参数,也没有返回值。下面来看有参数和返回值的情况。
我们把step1修改一下,传入一个参数,表示要走几步。
import time def timer(func): '''统计函数运行时间的装饰器''' def wrapper(): start = time.time()
func()
end = time.time()
used = end - start
print(f'{func.__name__} used {used}') return wrapper @timer def step1(num): print(f'我走了#{num}步')
step1(5)
再去运行,就报错了:
TypeError: wrapper() takes 0 positional arguments but 1 was given
这是因为,表面上我们写的是step1(5),实际上Python是先调用wrapper()函数。这个函数不接受参数,所以报错了。
为了解决这个问题,我们只要给wrapper加上参数就可以。
import time def timer(func): '''统计函数运行时间的装饰器''' def wrapper(*args, **kwargs): start = time.time()
func(*args, **kwargs)
end = time.time()
used = end - start
print(f'{func.__name__} used {used}') return wrapper
如果对关键词参数和位置参数不明白,可以在B站搜索"麦叔 参数",学习相关视频。
如果被装饰的函数func有返回值,wrapper也只需把func的返回值返回就可以了。
import time def timer(func): '''统计函数运行时间的装饰器''' def wrapper(*args, **kwargs): start = time.time()
ret_value = func(*args, **kwargs)
end = time.time()
used = end - start
print(f'{func.__name__} used {used}') return ret_value return wrapper @timer def add(num1, num2): return num1 + num2
sum = add(5, 8)
print(sum)
这里我新加了一个add函数,计算两个数之和。
在wrapper函数中,我们先保存了func的返回值到ret_value,然后在wrapper的最后返回这个值就可以了。
到这里,你又进了一步,你可以击败88.64%的Python学习者了。但还不够,后面还有:
有位同学看完前面的内容,觉得自己掌握的很好了,就去面试。
结果被面试官一个“如何在Python中实现单例模式”的问题给当场问倒了。
气得他上去就是两个耳刮子,不过不是打面试官,是打自己,恨自己没有等读透整篇再去面试。所以大家都耐心读完。
你一定用过装饰器Decorator
其实Decorator就在我们身边,只是我们可能不知道它们是装饰器。我来说几个:@classmethod @staticmethod @property
有没有一种"我靠"的冲动?!
对,这些很重要的语法,不过是装饰器的应用而已。
来看一个代码例子:
class Circle: #半径用下划线开头,表示私有变量 def __init__(self, radius): self._radius = radius #用property装饰器创建虚拟的半径属性 @property def radius(self): return self._radius #用setter装饰器给半径属性添加赋值操作 @radius.setter def radius(self, value): if value >= 0: self._radius = value else: raise ValueError("Radius must be positive") #用property装饰器创建虚拟的面积属性 @property def area(self): return self.pi() * self.radius**2 def cylinder_volume(self, height): return self.area * height #类方法 @classmethod def unit_circle(cls): return cls(1) #静态方法 @staticmethod def pi(): return 3.1415926535
你不要以为你已经掌握了装饰器,你只是听懂了。
从听懂到能动手写出来,再到被面试的时候,可以流畅的说出来,那还差着二十万八千里呢!
一定得多动手!所以抓紧时间,马上再来创建两个装饰器。
现在我们来创建一个装饰器:它会打印函数的参数,以及返回值。
如果你有实际项目经验,你一定会知道这个很有用。这不就是自动打印日志嘛!是程序员找臭虫的必备良药啊。
来看看代码:
def debug(func): def wrapper_debug(*args, **kwargs): print(f'{func.__name__}:{args}, {kwargs}')
ret_val = func(*args, **kwargs)
print(f'return: {ret_val}') return ret_val return wrapper_debug @debug def add(a, b): return a + b
add(1, 3)
add(2, 3)
add(4, 3)
在wrapper_debug函数中,我们先打印所有的参数,再调用原函数,最后先打印返回值,再返回返回值。这里并没有新的语法知识,就是为了练手。
曾经我还年轻,看到一个大神的代码里面有这么一行:
sleep(random(1,5))
因为有了这行代码,程序运行的时候挺慢的。我就问大神,为什么要这样。大神语重心长的跟我说:
你还年轻!我把这个程序交付给客户,客户会觉得有点慢,但还能忍。
忍不住了,会来找我优化性能。我一个手指头就把性能优化上去了,客户一定对我五体投地。而且我们公司的尾款也给我们了。
年轻人,多学着点!这就是阅历,阅历!
可惜我学了这么多年,也没学会这种阅历。
不过有时候,因为各种原因,我们确实需要让程序变慢一点。装饰器就排上了用场:
import time def slow(func): def wrapper_slow(*args, **kwargs): print(f'{func.__name__} sleeping 1 second')
time.sleep(1)
ret_val = func(*args, **kwargs) return ret_val return wrapper_slow @slow def add(a, b): return a + b
add(1, 3)
运行一下,你就会很有成就感!确实慢!
上面那个真实的段子,我劝大家和我一样,一直都学不会。日久见人心,坑人的事情不能干。
经过前面几个例子,我们可以总结出一个装饰器的模板。
按照这个模板,可以轻松写出装饰器:
def decorator(func): def wrapper_decorator(*args, **kwargs): #调用前操作 ret_val = func(*args, **kwargs) #调用后操作 return ret_val return wrapper_decorator
按照这个模板:
上面那两个都是普通的装饰器的应用,我们不能继续自High下去了。我们得学习新知识了。
上面那个slow的装饰器,如果能够传入到底要sleep几秒就好了,现在是固定的1秒,这个不香。
注意区分,这里的参数是指装饰器的参数。和前面提到的函数自身的参数是不同的。
我想让它多慢就多慢,然后我们再顷刻间扭转乾坤,这样客户就更为我神魂颠倒了。
要让装饰器接受参数,需要在普通装饰器的外面再套上一层:
import time def slow(seconds): def decorator_slow(func): def wrapper_slow(*args, **kwargs): print(f'{func.__name__} sleeping {seconds} second')
time.sleep(seconds)
ret_val = func(*args, **kwargs) return ret_val return wrapper_slow return decorator_slow #添加装饰器的时候可以传入要放慢几秒的参数。@slow(2)def add(a, b): return a + b #执行此行会停顿2秒 add(1, 3)
以前的装饰器,是函数里面有一个内部函数(2层函数),现在这个有了3层函数:
其实后面两层就是和之前一样的,唯一的区别是外面又加了一层。
为什么会这样呢?为什么最外面一层不需要传入func参数呢?
这是因为:
这就是说最外面一层的功能就是为了处理装饰器的参数的。
如果你一下子不能理解,先把代码敲出来,你就理解了。正所谓:熟读唐诗三百首,不会吟诗也会吟!
再来看一个装饰器带参数的例子:
def repeat(nums=3): def decorator_repeat(func): def wrapper_repeat(*args, **kwargs): for _ in range(nums):
func(*args, **kwargs) return wrapper_repeat return decorator_repeat @repeat(3) def run(): print('跑步有利于身体健康,来一圈') #这里会重复执行3次 run()
这个装饰和slow装饰器一样坑人,它会多次重复执行一个方法,并且可以动态指定要重复几次。
细细品味一下这个3层的函数,它是如何实现带参数的装饰器的。这两个例子都懂了,你就走在吊打面试官的路上了。
还记得前面给自己两个耳光的同学吗?如果他现在去面试,还是给自己两个耳光,还是不知道如何实现单例模式。
单例模式,是指一个类只能创建一个实例,是最常见的设计模式之一。
比如网站程序有一个类统计网站的访问人数,这个类只能有一个实例。如果每次访问都创建一个新的实例,那人数就永远是1了。
在Python中可以用装饰器实现单例模式。
前面的装饰器都是用来装饰函数的,或者用来装饰类方法的,比如我们写的slow, debug, timer; Python自带的staticmethod, classmethod等。
那如果把装饰器放到类名前面会怎样呢?来看这段代码:
from slow import slow @slow class Counter(): def __init__(self): self._count = 0 def visit(self): self._count += 1 print(f'visiting: {self._count}')
c1 = Counter()
c1.visit()
c1.visit()
c2 = Counter()
c2.visit()
c2.visit()
这个类名叫Counter(),顾名思义就是用来做计数的。它有一个内部变量叫做_count,每次调用Counter的visit()方法,计数就会加1.
第一行,我们引入了前面写的slow装饰器,是那个普通的不带参数的slow。装饰器就是个函数,当然可以被import进来。
这次@slow放在Counter类名前面,而不是方法的前面,会发生什么呢?运行上面的代码,会发现这样的结果:
Counter sleeping 1 second visiting: 1 visiting: 2 Counter sleeping 1 second visiting: 1 visiting: 2
这说明只有在创建Counter实例的时候,才会sleep一秒,调用visit函数的时候,不会sleep。
所以,类装饰器实际上装饰的是类的初始化方法。只有初始化的时候会装饰一次。
上面的运行结果很让人失望,如果去面试,还是会给自己两个耳刮子的。
作为一个计数器,应该计数是不断叠加的。
可是上面的代码,创建了两个计数器,自己记录自己的。扯淡啊!
我们现在就用类装饰器改造它:
def singleton(cls): '''创建一个单例模式''' def single_wrapper(*args, **kwargs): if not single_wrapper.instance:
single_wrapper.instance = cls(*args, **kwargs) return single_wrapper.instance
single_wrapper.instance = None return single_wrapper @singleton class Counter(): def __init__(self): self._count = 0 def visit(self): self._count += 1 print(f'visiting: {self._count}')
c1 = Counter()
c1.visit()
c1.visit()
c2 = Counter()
c2.visit()
c2.visit()
先来运行一下:
visiting: 1 visiting: 2 visiting: 3 visiting: 4
结果很满意,虽然创建了两个Counter,计数是记录在一起的。这主要得益于这个新的装饰器:
def singleton(cls): '''创建一个单例模式''' def single_wrapper(*args, **kwargs): #如果没有实例,则创建实例 if not single_wrapper.instance:
single_wrapper.instance = cls(*args, **kwargs) #返回原来的实例,或者新的实例 return single_wrapper.instance #给新创建的函数添加一个属性保存实例 single_wrapper.instance = None return single_wrapper
它和其他的装饰器基本一样,它的不同之处在于这一行:
single_wrapper.instance = None
在创建完函数后,又给函数添加了一个属性,用来保存实例,开始为None,就是没有实例。
再来分析一下代码逻辑:
把这个装饰器加到类上的时候,就相当于加到了初始化方法。
当我们创建Counter的时候,被这个装饰器截胡,它会返回一个已经创建好的实例。如果没有实例,它会创建一个。
也就是说,不管调用Counter()多少次,最终就只有一个实例。这就是实现了单例模式。
如果有点不懂,再看一遍,为的是在面试官面前扬眉吐气。
上面的例子中,我们看到装饰器自己保存了一个实例,你要的时候它就给你这一个,所以才实现了单例模式。这种就叫做带状态的装饰器。
我们再来看一个例子。count装饰器会记录一个函数被调用的次数:
def count(func): def wrapper_count(): wrapper_count.count += 1 print(f'{func.__name__}:第{wrapper_count.count}次调用')
func()
wrapper_count.count = 0 return wrapper_count @count def run(): print('跑步有利于身体健康,来一圈')
run()
run()
run()
运行结果:
run:第1次调用 跑步有利于身体健康,来一圈 run:第2次调用 跑步有利于身体健康,来一圈 run:第3次调用 跑步有利于身体健康,来一圈
关键点就在于这一行:
wrapper_count.count = 0
给wrapper_count函数添加了count属性,来记录函数调用的次数,它也是一个有状态的装饰器。
一个函数只能有一个装饰器吗?
装饰器的本质就是先调用装饰器,装饰器再调用函数。既然这样,那么多调用几层也无妨吧。
来看这个例子:
import time from slow import slow def timer(func): def wrapper(): start_time = time.perf_counter()
func()
end_time = time.perf_counter()
used_time = end_time - start_time
print(f'{func.__name__} used {used_time}') return wrapper @slow @timer def run(): print('跑步有利于身体健康,来一圈')
run()
这个例子中,run函数用了两个装饰器,slow和timer。它的执行过程就相当于:
数据分析咨询请扫描二维码
若不方便扫码,搜微信号:CDAshujufenxi
剖析 CDA 数据分析师考试题型:解锁高效备考与答题策略 CDA(Certified Data Analyst)数据分析师考试作为衡量数据专业能力的 ...
2025-07-04SQL Server 字符串截取转日期:解锁数据处理的关键技能 在数据处理与分析工作中,数据格式的规范性是保证后续分析准确性的基础 ...
2025-07-04CDA 数据分析师视角:从数据迷雾中探寻商业真相 在数字化浪潮席卷全球的今天,数据已成为企业决策的核心驱动力,CDA(Certifie ...
2025-07-04CDA 数据分析师:开启数据职业发展新征程 在数据成为核心生产要素的今天,数据分析师的职业价值愈发凸显。CDA(Certified D ...
2025-07-03从招聘要求看数据分析师的能力素养与职业发展 在数字化浪潮席卷全球的当下,数据已成为企业的核心资产,数据分析师岗位也随 ...
2025-07-03Power BI 中如何控制过滤器选择项目数并在超限时报错 引言 在使用 Power BI 进行数据可视化和分析的过程中,对过滤器的有 ...
2025-07-03把握 CDA 考试时间,开启数据分析职业之路 在数字化转型的时代浪潮下,数据已成为企业决策的核心驱动力。CDA(Certified Da ...
2025-07-02CDA 证书:银行招聘中的 “黄金通行证” 在金融科技飞速发展的当下,银行正加速向数字化、智能化转型,海量数据成为银行精准 ...
2025-07-02探索最优回归方程:数据背后的精准预测密码 在数据分析和统计学的广阔领域中,回归分析是揭示变量之间关系的重要工具,而回 ...
2025-07-02CDA 数据分析师报考条件全解析:开启数据洞察之旅 在当今数字化浪潮席卷全球的时代,数据已成为企业乃至整个社会发展的核心驱 ...
2025-07-01深入解析 SQL 中 CASE 语句条件的执行顺序 在 SQL 编程领域,CASE语句是实现条件逻辑判断、数据转换与分类的重要工 ...
2025-07-01SPSS 中计算三个变量交集的详细指南 在数据分析领域,挖掘变量之间的潜在关系是获取有价值信息的关键步骤。当我们需要探究 ...
2025-07-01CDA 数据分析师:就业前景广阔的新兴职业 在当今数字化时代,数据已成为企业和组织决策的重要依据。数据分析师作为负责收集 ...
2025-06-30探秘卷积层:为何一个卷积层需要两个卷积核 在深度学习的世界里,卷积神经网络(CNN)凭借其强大的特征提取能力 ...
2025-06-30探索 CDA 数据分析师在线课程:开启数据洞察之旅 在数字化浪潮席卷全球的当下,数据已成为企业决策、创新与发展的核心驱 ...
2025-06-303D VLA新范式!CVPR冠军方案BridgeVLA,真机性能提升32% 编辑:LRST 【新智元导读】中科院自动化所提出BridgeVLA模型,通过将 ...
2025-06-30LSTM 为何会产生误差?深入剖析其背后的原因 在深度学习领域,LSTM(Long Short-Term Memory)网络凭借其独特的记忆单元设 ...
2025-06-27LLM进入拖拽时代!只靠Prompt几秒定制大模型,效率飙升12000倍 【新智元导读】最近,来自NUS、UT Austin等机构的研究人员创新 ...
2025-06-27探秘 z-score:数据分析中的标准化利器 在数据的海洋中,面对形态各异、尺度不同的数据,如何找到一个通用的标准来衡量数据 ...
2025-06-26Excel 中为不同柱形设置独立背景(按数据分区)的方法详解 在数据分析与可视化呈现过程中,Excel 柱形图是展示数据的常用工 ...
2025-06-26