print('主人，我准备开始执行：{} 函数了:'.format(func.__name__))

    # 真正执行的是这行。
    func(*args, **kw)

    print('主人，我执行完啦。')
return wrapper


假如，我的业务函数是，计算两个数之和。写好后，直接给它带上帽子。

@logger
def add(x, y):
print(‘{} + {} = {}’.format(x, y, x+y))


然后执行一下 add 函数。

add(200, 50)


来看看输出了什么？

主人，我准备开始执行：add 函数了:
200 + 50 = 250
主人，我执行完啦。


### 3. 入门：时间计时器


再来看看 时间计时器 实现功能：顾名思义，就是计算一个函数的执行时长。

这是装饰函数

def timer(func):
def wrapper(*args, **kw):
t1=time.time()
# 这是函数真正执行的地方
func(*args, **kw)
t2=time.time()

    # 计算下时长
    cost_time = t2-t1 
    print("花费时间：{}秒".format(cost_time))
return wrapper


假如，我们的函数是要睡眠10秒。这样也能更好的看出这个计算时长到底靠不靠谱。

import time

@timer
def want_sleep(sleep_time):
time.sleep(sleep_time)

want_sleep(10)


来看看输出，如预期一样，输出10秒。

花费时间：10.0073800086975098秒


**在学习python中有任何困难不懂的可以微信扫描下方CSDN官方认证二维码加入python交流学习  
 多多交流问题，互帮互助，这里有不错的学习教程和开发工具。**



![](https://img-blog.csdnimg.cn/img_convert/cd20315f4de9e7a69d0cb7db8d8c378a.png)



![在这里插入图片描述](https://img-blog.csdnimg.cn/d2115d3df9f44e6e823b08d1c62e07c6.jpeg#pic_center)


### 4. 进阶：带参数的函数装饰器


通过上面两个简单的入门示例，你应该能体会到装饰器的工作原理了。


不过，装饰器的用法还远不止如此，深究下去，还大有文章。今天就一起来把这个知识点学透。


回过头去看看上面的例子，装饰器是不能接收参数的。其用法，只能适用于一些简单的场景。不传参的装饰器，只能对被装饰函数，执行固定逻辑。


装饰器本身是一个函数，做为一个函数，如果不能传参，那这个函数的功能就会很受限，只能执行固定的逻辑。这意味着，如果装饰器的逻辑代码的执行需要根据不同场景进行调整，若不能传参的话，我们就要写两个装饰器，这显然是不合理的。


比如我们要实现一个可以定时发送邮件的任务（一分钟发送一封），定时进行时间同步的任务（一天同步一次），就可以自己实现一个 periodic\_task （定时任务）的装饰器，这个装饰器可以接收一个时间间隔的参数，间隔多长时间执行一次任务。


可以这样像下面这样写，由于这个功能代码比较复杂，不利于学习，这里就不贴了。

@periodic_task(spacing=60)
def send_mail():
pass

@periodic_task(spacing=86400)
def ntp()
pass


那我们来自己创造一个伪场景，可以在装饰器里传入一个参数，指明国籍，并在函数执行前，用自己国家的母语打一个招呼。

小明，中国人

@say_hello(“china”)
def xiaoming():
pass

jack，美国人

@say_hello(“america”)
def jack():
pass


那我们如果实现这个装饰器，让其可以实现 传参 呢？


会比较复杂，需要两层嵌套。

def say_hello(contry):
def wrapper(func):
def deco(*args, **kwargs):
if contry == “china”:
print(“你好!”)
elif contry == “america”:
print(‘hello.’)
else:
return

        # 真正执行函数的地方
        func(*args, **kwargs)
    return deco
return wrapper


来执行一下

xiaoming()
print(“------------”)
jack()


看看输出结果。

你好!

hello.


### 5. 高阶：不带参数的类装饰器


以上都是基于函数实现的装饰器，在阅读别人代码时，还可以时常发现还有基于类实现的装饰器。


基于类装饰器的实现，必须实现 **call** 和 \_\_init\_\_两个内置函数。 **init** ：接收被装饰函数 **call** ：实现装饰逻辑。


还是以日志打印这个简单的例子为例

class logger(object):
def init(self, func):
self.func = func

def __call__(self, *args, **kwargs):
    print("[INFO]: the function {func}() is running..."\
        .format(func=self.func.__name__))
    return self.func(*args, **kwargs)

@logger
def say(something):
print(“say {}!”.format(something))

say(“hello”)


执行一下，看看输出

[INFO]: the function say() is running…
say hello!


### 6. 高阶：带参数的类装饰器


上面不带参数的例子，你发现没有，只能打印INFO级别的日志，正常情况下，我们还需要打印DEBUG WARNING等级别的日志。 这就需要给类装饰器传入参数，给这个函数指定级别了。


带参数和不带参数的类装饰器有很大的不同。


**init** ：不再接收被装饰函数，而是接收传入参数。 **call** ：接收被装饰函数，实现装饰逻辑。

class logger(object):
def init(self, level=‘INFO’):
self.level = level

def __call__(self, func): # 接受函数
    def wrapper(*args, **kwargs):
        print("[{level}]: the function {func}() is running..."\
            .format(level=self.level, func=func.__name__))
        func(*args, **kwargs)
    return wrapper  #返回函数

@logger(level=‘WARNING’)
def say(something):
print(“say {}!”.format(something))

say(“hello”)


我们指定WARNING级别，运行一下，来看看输出。

[WARNING]: the function say() is running…
say hello!


### 7. 使用偏函数与类实现装饰器


绝大多数装饰器都是基于函数和闭包实现的，但这并非制造装饰器的唯一方式。


事实上，Python 对某个对象是否能通过装饰器（ @decorator）形式使用只有一个要求：decorator 必须是一个“可被调用（callable）的对象。


对于这个 callable 对象，我们最熟悉的就是函数了。


除函数之外，类也可以是 callable 对象，只要实现了\_\_call\_\_ 函数（上面几个例子已经接触过了）。


还有容易被人忽略的偏函数其实也是 callable 对象。


接下来就来说说，如何使用 类和偏函数结合实现一个与众不同的装饰器。


如下所示，DelayFunc 是一个实现了 **call** 的类，delay 返回一个偏函数，在这里 delay 就可以做为一个装饰器。（以下代码摘自 Python工匠：使用装饰器的小技巧）

import time
import functools

class DelayFunc:
def init(self, duration, func):
self.duration = duration
self.func = func

def __call__(self, *args, **kwargs):
    print(f'Wait for {self.duration} seconds...')
    time.sleep(self.duration)
    return self.func(*args, **kwargs)

def eager_call(self, *args, **kwargs):
    print('Call without delay')
    return self.func(*args, **kwargs)

def delay(duration):
“”"
装饰器：推迟某个函数的执行。
同时提供 .eager_call 方法立即执行
“”"
# 此处为了避免定义额外函数，
# 直接使用 functools.partial 帮助构造 DelayFunc 实例
return functools.partial(DelayFunc, duration)


我们的业务函数很简单，就是相加

@delay(duration=2)
def add(a, b):
return a+b


来看一下执行过程

add # 可见 add 变成了 Delay 的实例
<main.DelayFunc object at 0x107bd0be0>

add(3,5) # 直接调用实例，进入 call
Wait for 2 seconds…
8

add.func # 实现实例方法
<function add at 0x107bef1e0>


### 8. 如何写能装饰类的装饰器？


用 Python 写单例模式的时候，常用的有三种写法。其中一种，是用装饰器来实现的。


以下便是我自己写的装饰器版的单例写法。

instances = {}

def singleton(cls):
def get_instance(*args, **kw):
cls_name = cls.name
print(‘===== 1 ‘)
if not cls_name in instances:
print(’= 2 ====’)
instance = cls(*args, **kw)
instances[cls_name] = instance
return instances[cls_name]
return get_instance

@singleton
class User:
_instance = None

def __init__(self, name):
    print('===== 3 ====')
    self.name = name


可以看到我们用singleton 这个装饰函数来装饰 User 这个类。装饰器用在类上，并不是很常见，但只要熟悉装饰器的实现过程，就不难以实现对类的装饰。在上面这个例子中，装饰器就只是实现对类实例的生成的控制而已。


其实例化的过程，你可以参考我这里的调试过程，加以理解。  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/9d9b166cb72d4a31bef1548edd406606.png)


### 9. wraps 装饰器有啥用？


在 functools 标准库中有提供一个 wraps 装饰器，你应该也经常见过，那他有啥用呢？


先来看一个例子

def wrapper(func):
def inner_function():
pass
return inner_function

@wrapper
def wrapped():
pass

print(wrapped.name)
#inner_function


为什么会这样子？不是应该返回 func 吗？


这也不难理解，因为上边执行func 和下边 decorator(func) 是等价的，所以上面 func.**name** 是等价于下面decorator(func).**name** 的，那当然名字是 inner\_function

def wrapper(func):
def inner_function():
pass
return inner_function

def wrapped():
pass

print(wrapper(wrapped).name)
#inner_function


那如何避免这种情况的产生？方法是使用 functools .wraps 装饰器，它的作用就是将 被修饰的函数(wrapped) 的一些属性值赋值给 修饰器函数(wrapper) ，最终让属性的显示更符合我们的直觉。

from functools import wraps

def wrapper(func):
@wraps(func)
def inner_function():
pass
return inner_function

@wrapper
def wrapped():
pass

print(wrapped.name)

wrapped


准确点说，wraps 其实是一个偏函数对象（partial），源码如下

def wraps(wrapped,
assigned = WRAPPER_ASSIGNMENTS,
updated = WRAPPER_UPDATES):
return partial(update_wrapper, wrapped=wrapped,
assigned=assigned, updated=updated)


可以看到wraps其实就是调用了一个函数update\_wrapper，知道原理后，我们改写上面的代码，在不使用 wraps的情况下，也可以让 wrapped.**name** 打印出 wrapped，代码如下：

from functools import update_wrapper

WRAPPER_ASSIGNMENTS = (‘module’, ‘name’, ‘qualname’, ‘doc’,
‘annotations’)

def wrapper(func):
def inner_function():
pass

update_wrapper(inner_function, func, assigned=WRAPPER_ASSIGNMENTS)
return inner_function

@wrapper
def wrapped():
pass

print(wrapped.name)


### 10. 内置装饰器：property


以上，我们介绍的都是自定义的装饰器。


其实Python语言本身也有一些装饰器。比如property这个内建装饰器，我们再熟悉不过了。


它通常存在于类中，可以将一个函数定义成一个属性，属性的值就是该函数return的内容。


通常我们给实例绑定属性是这样的

class Student(object):
def init(self, name, age=None):
self.name = name
self.age = age

实例化

xiaoming = Student(“小明”)

添加属性

xiaoming.age=25

查询属性

xiaoming.age
学好 Python 不论是就业还是做副业赚钱都不错，但要学会 Python 还是要有一个学习规划。最后大家分享一份全套的 Python 学习资料，给那些想学习 Python 的小伙伴们一点帮助！

一、Python所有方向的学习路线

Python所有方向路线就是把Python常用的技术点做整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。

二、学习软件

工欲善其事必先利其器。学习Python常用的开发软件都在这里了，给大家节省了很多时间。

三、全套PDF电子书

书籍的好处就在于权威和体系健全，刚开始学习的时候你可以只看视频或者听某个人讲课，但等你学完之后，你觉得你掌握了，这时候建议还是得去看一下书籍，看权威技术书籍也是每个程序员必经之路。

四、入门学习视频

我们在看视频学习的时候，不能光动眼动脑不动手，比较科学的学习方法是在理解之后运用它们，这时候练手项目就很适合了。

五、实战案例

光学理论是没用的，要学会跟着一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。

六、面试资料

我们学习Python必然是为了找到高薪的工作，下面这些面试题是来自阿里、腾讯、字节等一线互联网大厂最新的面试资料，并且有阿里大佬给出了权威的解答，刷完这一套面试资料相信大家都能找到满意的工作。

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里无偿获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

# python # 开发语言
Logo
天启AI社区

GitCode 天启AI是一款由 GitCode 团队打造的智能助手，基于先进的LLM（大语言模型）与多智能体 Agent 技术构建，致力于为用户提供高效、智能、多模态的创作与开发支持。它不仅支持自然语言对话，还具备处理文件、生成 PPT、撰写分析报告、开发 Web 应用等多项能力，真正做到“一句话，让 Al帮你完成复杂任务”。

更多推荐

cover

【感知机】感知机(perceptron)学习算法例题及详解

avatar 天启AI社区
cover

AI云原生：数智化时代AI Agent加速落地的技术基石与实践指南（THS）

avatar 天启AI社区
cover

【AI论文】设计实验室：通过迭代检测与修正来设计幻灯片

avatar 天启AI社区