2024年最全没看完这11 条，别说你精通 Python 装饰器(1)，阿里web面试题

现在能在网上找到很多很多的学习资源，有免费的也有收费的，当我拿到1套比较全的学习资源之前，我并没着急去看第1节，我而是去审视这套资源是否值得学习，有时候也会去问一些学长的意见，如果可以之后，我会对这套学习资源做1个学习计划，我的学习计划主要包括规划图和学习进度表。

分享给大家这份我薅到的免费视频资料，质量还不错，大家可以跟着学习

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

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

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

03. 入门：时间计时器

---

再来看看 时间计时器

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

这是装饰函数

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秒

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

---

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

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

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

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

比如我们要实现一个可以定时发送邮件的任务（一分钟发送一封），定时进行时间同步的任务（一天同步一次），就可以自己实现一个 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.

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

---

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

基于类装饰器的实现，必须实现 __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!

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

---

上面不带参数的例子，你发现没有，只能打印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!

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

---

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

事实上，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>

08. 如何写能装饰类的装饰器？

---

用 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 这个类。装饰器用在类上，并不是很常见，但只要熟悉装饰器的实现过程，就不难以实现对类的装饰。在上面这个例子中，装饰器就只是实现对类实例的生成的控制而已。

其实例化的过程，你可以参考我这里的调试过程，加以理解。

09. 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

删除属性

del xiaoming.age

但是稍有经验的开发人员，一下就可以看出，这样直接把属性暴露出去，虽然写起来很简单，但是并不能对属性的值做合法性限制。为了实现这个功能，我们可以这样写。

class Student(object):

def init(self, name):

self.name = name

self.name = None

def set_age(self, age):

if not isinstance(age, int):

raise ValueError(‘输入不合法：年龄必须为数值!’)

if not 0 < age < 100:

raise ValueError(‘输入不合法：年龄范围必须0-100’)

self._age=age

def get_age(self):

return self._age

def del_age(self):

self._age = None

xiaoming = Student(“小明”)

添加属性

xiaoming.set_age(25)

最后

Python崛起并且风靡，因为优点多、应用领域广、被大牛们认可。学习 Python 门槛很低，但它的晋级路线很多，通过它你能进入机器学习、数据挖掘、大数据，CS等更加高级的领域。Python可以做网络应用，可以做科学计算，数据分析，可以做网络爬虫，可以做机器学习、自然语言处理、可以写游戏、可以做桌面应用…Python可以做的很多，你需要学好基础，再选择明确的方向。这里给大家分享一份全套的 Python 学习资料，给那些想学习 Python 的小伙伴们一点帮助！

👉Python所有方向的学习路线👈

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

👉Python必备开发工具👈

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

👉Python全套学习视频👈

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

👉实战案例👈

学python就与学数学一样，是不能只看书不做题的，直接看步骤和答案会让人误以为自己全都掌握了，但是碰到生题的时候还是会一筹莫展。

因此在学习python的过程中一定要记得多动手写代码，教程只需要看一两遍即可。

👉大厂面试真题👈

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

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

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