醉了,面个功能测试,还问我Python装饰器

 

Python 装饰器是个强大的工具,可帮你生成整洁、可重用和可维护的代码。某种意义上说,会不会用装饰器是区分新手和老鸟的重要标志。如果你不熟悉装饰器,你可以将它们视为将函数作为输入并在不改变其主要用途的情况下扩展其功能的函数。装饰器可以有效提高你的工作效率并避免重复代码。本文我整理了项目中经常用到的 12 个装饰器,值得每一个Python开发者掌握。

01 @logger

我们从最简单的装饰器开始,手动实现一个可以记录函数开始和结束的装饰器。

被修饰函数的输出结果如下所示:

  1. some_function(args)

  2. # ----- some_function: start -----

  3. # some_function executing

  4. # ----- some_function: end -----

要实现一个装饰器,首先要给装饰器起一个合适的名称:这里我们给装饰器起名为logger。

装饰器本质上是一个函数,它将一个函数作为输入并返回一个函数作为输出。 输出函数通常是输入的扩展版。在我们的例子中,我们希望输出函数用start和end语句包围输入函数的调用。

由于我们不知道输入函数都带有什么参数,我们可以使用 *args 和 **kwargs 从包装函数传递它们。*args 和 **kwargs 允许传递任意数量的位置参数和关键字参数。

下面是logger装饰器的示例代码:

  1. def logger(function):

  2.     def wrapper(*args, **kwargs):

  3.         print(f"----- {function.__name__}: start -----")

  4.         output = function(*args, **kwargs)

  5.         print(f"----- {function.__name__}: end -----")

  6.         return output

  7.     return wrapper

logger函数可以应用于任意函数,比如:

decorated_function = logger(some_function)

上面的语句是正确的,但Python 提供了更 Pythonic 的语法——使用 @ 修饰符。

因此更通常的写法是:

  1. @logger

  2. def some_function(text):

  3.     print(text)

  4. some_function("first test")

  5. # ----- some_function: start -----

  6. # first test

  7. # ----- some_function: end -----

  8. some_function("second test")

  9. # ----- some_function: start -----

  10. # second test

  11. # ----- some_function: end -----

02 @wraps

要了解 @wraps 的作用以及为什么需要它,让我们将前面写的logger装饰器应用到一个将两个数字相加的简单函数中。

下面的代码是未使用@wraps装饰器的版本

  1. def logger(function):

  2.     def wrapper(*args, **kwargs):

  3.         """wrapper documentation"""

  4.         print(f"----- {function.__name__}: start -----")

  5.         output = function(*args, **kwargs)

  6.         print(f"----- {function.__name__}: end -----")

  7.         return output

  8.     return wrapper

  9. @logger

  10. def add_two_numbers(a, b):

  11.     """this function adds two numbers"""

  12.     return a + b

如果我们用__name__ 和 __doc__来查看被装饰函数add_two_numbers的名称和文档,会得到如下结果

  1. add_two_numbers.__name__

  2. 'wrapper'

  3. add_two_numbers.__doc__

  4. 'wrapper documentation'

输出的是wrapper函数的名称和文档。这是我们预期想要的结果,我们希望保留原始函数的名称和文档。这时@wraps装饰器就派上用场了。

我们唯一需要做的就是给wrapper函数加上@wraps装饰器。

  1. from functools import wraps

  2. def logger(function):

  3.     @wraps(function)

  4.     def wrapper(*args, **kwargs):

  5.         """wrapper documentation"""

  6.         print(f"----- {function.__name__}: start -----")

  7.         output = function(*args, **kwargs)

  8.         print(f"----- {function.__name__}: end -----")

  9.         return output

  10.     return wrapper

  11. @logger

  12. def add_two_numbers(a, b):

  13.     """this function adds two numbers"""

  14.     return a + b

再此检查add_two_numbers函数的名称和文档,我们可以看到该函数的元数据。

  1. add_two_numbers.__name__

  2. # 'add_two_numbers'

  3. add_two_numbers.__doc__

  4. # 'this function adds two numbers'

03 @lru_cache

@lru_cache是Python内置装饰器,可以通过from functools import lru_cache引入。@lru_cache的作用是缓存函数的返回值,当缓存装满时,使用least-recently-used(LRU)算法丢弃最少使用的值。

@lru_cache装饰器适合用于输入输出不变且运行时间较长的任务,例如查询数据库、请求静态页面或一些繁重的处理。

在下面的示例中,我使用@lru_cache来修饰一个模拟某些处理的函数。然后连续多次对同一输入应用该函数。

  1. import random

  2. import time

  3. from functools import lru_cache

  4. @lru_cache(maxsize=None)

  5. def heavy_processing(n):

  6.     sleep_time = n + random.random()

  7.     time.sleep(sleep_time)

  8. # 初次调用

  9. %%time

  10. heavy_processing(0)

  11. # CPU times: user 363 µs, sys: 727 µs, total: 1.09 ms

  12. # Wall time: 694 ms

  13. # 第二次调用

  14. %%time

  15. heavy_processing(0)

  16. # CPU times: user 4 µs, sys: 0 ns, total: 4 µs

  17. # Wall time: 8.11 µs

  18. # 第三次调用

  19. %%time

  20. heavy_processing(0)

  21. # CPU times: user 5 µs, sys: 1 µs, total: 6 µs

  22. # Wall time: 7.15 µs

从上面的输出可以看到,第一次调用花费了694ms,因为执行了time.sleep()函数。后面两次调用由于参数相同,直接返回缓存值,因此并没有实际执行函数内容,因此非常快地得到函数返回。

04 @repeat

该装饰器的所用是多次调用被修饰函数。这对于调试、压力测试或自动化多个重复任务非常有用。

跟前面的装饰器不同,@repeat接受一个输入参数,

  1. def repeat(number_of_times):

  2.     def decorate(func):

  3.         @wraps(func)

  4.         def wrapper(*args, **kwargs):

  5.             for _ in range(number_of_times):

  6.                 func(*args, **kwargs)

  7.         return wrapper

  8.     return decorate

上面的代码定义了一个名为repeat的装饰器,有一个输入参数number_of_times。与前面的案例不同,这里需要decorate函数来传递被修饰函数。然后,装饰器定义一个名为wrapper的函数来扩展被修饰函数。

  1. @repeat(5)

  2. def hello_world():

  3.     print("hello world")

  4. hello_world()

  5. # hello world

  6. # hello world

  7. # hello world

  8. # hello world

  9. # hello world

05 @timeit

该装饰器用来测量函数的执行时间并打印出来。这对调试和监控非常有用。

在下面的代码片段中,@timeit装饰器测量process_data函数的执行时间,并以秒为单位打印所用的时间。

  1. import time

  2. from functools import wraps

  3. def timeit(func):

  4.     @wraps(func)

  5.     def wrapper(*args, **kwargs):

  6.         start = time.perf_counter()

  7.         result = func(*args, **kwargs)

  8.         end = time.perf_counter()

  9.         print(f'{func.__name__} took {end - start:.6f} seconds to complete')

  10.         return result

  11.     return wrapper

  12. @timeit

  13. def process_data():

  14.     time.sleep(1)

  15. process_data()

  16. # process_data took 1.000012 seconds to complete

06 @retry

其工作原理如下:

  • wrapper函数启动num_retrys次迭代的for循环。

  • 将被修饰函数放到try/except块中。每次迭代如果调用成功,则中断循环并返回结果。否则,休眠sleep_time秒后继续下一次迭代。

  • 当for循环结束后函数调用依然不成功,则抛出异常。

示例代码如下:

  1. import random

  2. import time

  3. from functools import wraps

  4. def retry(num_retries, exception_to_check, sleep_time=0):

  5.     """

  6.     遇到异常尝试重新执行装饰器

  7.     """

  8.     def decorate(func):

  9.         @wraps(func)

  10.         def wrapper(*args, **kwargs):

  11.             for i in range(1, num_retries+1):

  12.                 try:

  13.                     return func(*args, **kwargs)

  14.                 except exception_to_check as e:

  15.                     print(f"{func.__name__} raised {e.__class__.__name__}. Retrying...")

  16.                     if i < num_retries:

  17.                         time.sleep(sleep_time)

  18.             # 尝试多次后仍不成功则抛出异常

  19.             raise e

  20.         return wrapper

  21.     return decorate

  22. @retry(num_retries=3, exception_to_check=ValueError, sleep_time=1)

  23. def random_value():

  24.     value = random.randint(1, 5)

  25.     if value == 3:

  26.         raise ValueError("Value cannot be 3")

  27.     return value

  28. random_value()

  29. # random_value raised ValueError. Retrying...

  30. # 1

  31. random_value()

  32. # 5

07 @countcall

@countcall用于统计被修饰函数的调用次数。这里的调用次数会缓存在wraps的count属性中。

  1. from functools import wraps

  2. def countcall(func):

  3.     @wraps(func)

  4.     def wrapper(*args, **kwargs):

  5.         wrapper.count += 1

  6.         result = func(*args, **kwargs)

  7.         print(f'{func.__name__} has been called {wrapper.count} times')

  8.         return result

  9.     wrapper.count = 0

  10.     return wrapper

  11. @countcall

  12. def process_data():

  13.     pass

  14. process_data()

  15. process_data has been called 1 times

  16. process_data()

  17. process_data has been called 2 times

  18. process_data()

  19. process_data has been called 3 times

08 @rate_limited

@rate_limited装饰器会在被修饰函数调用太频繁时,休眠一段时间,从而限制函数的调用速度。这在模拟、爬虫、接口调用防过载等场景下非常有用

  1. import time

  2. from functools import wraps

  3. def rate_limited(max_per_second):

  4.     min_interval = 1.0 / float(max_per_second)

  5.     def decorate(func):

  6.         last_time_called = [0.0]

  7.         @wraps(func)

  8.         def rate_limited_function(*args, **kargs):

  9.             elapsed = time.perf_counter() - last_time_called[0]

  10.             left_to_wait = min_interval - elapsed

  11.             if left_to_wait > 0:

  12.                 time.sleep(left_to_wait)

  13.             ret = func(*args, **kargs)

  14.             last_time_called[0] = time.perf_counter()

  15.             return ret

  16.         return rate_limited_function

  17.     return decorate

该装饰器的工作原理是:测量自上次函数调用以来所经过的时间,并在必要时等待适当的时间,以确保不超过速率限制。其中等待时间=min_interval - elapsed,这里min_intervalue是两次函数调用之间的最小时间间隔(以秒为单位),已用时间是自上次调用以来所用的时间。如果经过的时间小于最小间隔,则函数在再次执行之前等待left_to_wait秒。

⚠注意:该函数在调用之间引入了少量的时间开销,但确保不超过速率限制。

如果不想自己手动实现,可以用第三方包,名叫ratelimit。

pip install ratelimit

使用非常简单,只需要装饰被调用函数即可:

  1. from ratelimit import limits

  2. import requests

  3. FIFTEEN_MINUTES = 900

  4. @limits(calls=15, period=FIFTEEN_MINUTES)

  5. def call_api(url):

  6.     response = requests.get(url)

  7.     if response.status_code != 200:

  8.         raise Exception('API response: {}'.format(response.status_code))

  9.     return response

如果被装饰函数的调用次数超过允许次数,则会抛出ratelimit.RateLimitException异常。要处理该异常可以将@sleep_and_retry装饰器与@limits装饰器一起使用。

  1. @sleep_and_retry

  2. @limits(calls=15, period=FIFTEEN_MINUTES)

  3. def call_api(url):

  4.     response = requests.get(url)

  5.     if response.status_code != 200:

  6.         raise Exception('API response: {}'.format(response.status_code))

  7.     return response

这样被装饰函数在再次执行之前会休眠剩余时间。

09 @dataclass

Python 3.7 引入了@dataclass装饰器,将其加入到标准库,用于装饰类。它主要用于存储数据的类自动生成诸如__init__, __repr__, __eq__, __lt__,__str__ 等特殊函数。这样可以减少模板代码,并使类更加可读和可维护。

另外,@dataclass还提供了现成的美化方法,可以清晰地表示对象,将其转换为JSON格式,等等。

  1. from dataclasses import dataclass, 

  2. @dataclass

  3. class Person:

  4.     first_name: str

  5.     last_name: str

  6.     age: int

  7.     job: str

  8.     def __eq__(self, other):

  9.         if isinstance(other, Person):

  10.             return self.age == other.age

  11.         return NotImplemented

  12.     def __lt__(self, other):

  13.         if isinstance(other, Person):

  14.             return self.age < other.age

  15.         return NotImplemented

  16. john = Person(first_name="John", 

  17.               last_name="Doe", 

  18.               age=30, 

  19.               job="doctor",)

  20. anne = Person(first_name="Anne", 

  21.               last_name="Smith", 

  22.               age=40, 

  23.               job="software engineer",)

  24. print(john == anne)

  25. # False

  26. print(anne > john)

  27. # True

  28. asdict(anne)

  29. #{'first_name': 'Anne',

  30. # 'last_name': 'Smith',

  31. # 'age': 40,

  32. # 'job': 'software engineer'}

10 @register

如果你的Python脚本意外终止,但你仍想执行一些任务来保存你的工作、执行清理或打印消息,那么@register在这种情况下非常方便。

  1. from atexit import register

  2. @register

  3. def terminate():

  4.     perform_some_cleanup()

  5.     print("Goodbye!")

  6. while True:

  7.     print("Hello")

运行上面的代码会不断在控制台输出"Hello",点击Ctrl + C强制终止脚本运行,你会看到控制台输出"Goodbye",说明程序在中断后执行了@register装饰器装饰的terminate()函数。

11 @property

@property装饰器用于定义类属性,这些属性本质上是类实例属性的getter、setter和deleter方法。

通过使用@property装饰器,可以将方法定义为类属性,并将其作为类属性进行访问,而无需显式调用该方法。

如果您想在获取或设置值时添加一些约束和验证逻辑,使用@property装饰器会非常方便。

下面的示例中,我们在rating属性上定义了一个setter,对输入执行约束(介于0和5之间)。

  1. class Movie:

  2.     def __init__(self, r):

  3.         self._rating = r

  4.     @property

  5.     def rating(self):

  6.         return self._rating

  7.     @rating.setter

  8.     def rating(self, r):

  9.         if 0 <= r <= 5:

  10.             self._rating = r

  11.         else:

  12.             raise ValueError("The movie rating must be between 0 and 5!")

  13. batman = Movie(2.5)

  14. batman.rating

  15. # 2.5

  16. batman.rating = 4

  17. batman.rating

  18. # 4

  19. batman.rating = 10

  20. # ---------------------------------------------------------------------------

  21. # ValueError                                Traceback (most recent call last)

  22. # Input In [16], in <cell line: 1>()

  23. # ----> 1 batman.rating = 10

  24. # Input In [11], in Movie.rating(self, r)

  25. #      12     self._rating = r

  26. #      13 else:

  27. # ---> 14     raise ValueError("The movie rating must be between 0 and 5!")

  28. #

  29. # ValueError: The movie rating must be between 0 and 5!

12 @singledispatch

@singledispatch允许函数对不同类型的参数有不同的实现,有点像Java等面向对象语言中的函数重载。

  1. from functools import singledispatch

  2. @singledispatch

  3. def fun(arg):

  4.     print("Called with a single argument")

  5. @fun.register(int)

  6. def _(arg):

  7.     print("Called with an integer")

  8. @fun.register(list)

  9. def _(arg):

  10.     print("Called with a list")

  11. fun(1)  # Prints "Called with an integer"

  12. fun([1, 2, 3])  # Prints "Called with a list"

结论

装饰器是一个重要的抽象思想,可以在不改变原始代码的情况下扩展代码,如缓存、自动重试、速率限制、日志记录,或将类转换为超级数据容器等。

装饰器的功能远不止于此,本文介绍的12个常用装饰器只是抛砖引玉,当你理解了装饰器思想和用法后,可以发挥创造力,实现各种自定义装饰器来解决具体问题。

总结:

感谢每一个认真阅读我文章的人!!!

作为一位过来人也是希望大家少走一些弯路,如果你不想再体验一次学习时找不到资料,没人解答问题,坚持几天便放弃的感受的话,在这里我给大家分享一些自动化测试的学习资源,希望能给你前进的路上带来帮助。

软件测试面试文档

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

 

          视频文档获取方式:
这份文档和视频资料,对于想从事【软件测试】的朋友来说应该是最全面最完整的备战仓库,这个仓库也陪伴我走过了最艰难的路程,希望也能帮助到你!以上均可以分享,点下方小卡片即可自行领取。

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/diannao/12945.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

dhcp(接口和全局地址池模式)

接口地址池和全局地址池 dhcp应用 1.全部开启dhcp功能 2.ar5 0口接口地址池 1口全局地址池 3.ar6和ar7配置&#xff0c;查看能否自动获取ip 左右不同两个网络&#xff0c;接口和全局地址池的区别 部分截图 ar6 ar7 ar5

(实测验证)【移远EC800M-CN 】TCP 透传

引言 本文章使用自研“超小体积TTL转4GGPS集成模块”进行实测验证&#xff1b; 1、配置移远EC800M-CN TCP 透传 串口助手发送&#xff1a; ATQIOPEN1,0,"TCP","36.137.226.30",39755,0,2 //配置服务器地址和端口号&#xff1b; 4G模组返回…

07-Fortran基础--Fortran指针(Pointer)的使用

07-Fortran基础--Fortran指针Pointer的使用 0 引言1 指针&#xff08;Poionter&#xff09;的有关内容1.1 一般类型指针1.2 数组指针1.3 派生类(type)指针1.4 函数指针 2 可运行code 0 引言 Fortran是一种广泛使用的编程语言&#xff0c;特别适合科学计算和数值分析。Fortran 9…

java代码混淆工具ProGuard混淆插件

java代码混淆工具ProGuard混淆插件 介绍 ProGuard是一个纯java编写的混淆工具&#xff0c;有客户端跟jar包两种使用方式。可以将程序打包为jar&#xff0c;然后用工具进行混淆&#xff0c;也可以在maven中导入ProGuard的插件&#xff0c;对代码进行混淆。 大家都知道 java代…

【华为OD机试-C卷D卷-200分】田忌赛马(C++/Java/Python)

【华为OD机试】-(A卷+B卷+C卷+D卷)-2024真题合集目录 【华为OD机试】-(C卷+D卷)-2024最新真题目录 题目描述 给定两个只包含数字的数组a,b,调整数组 a 里面的数字的顺序,使得尽可能多的a[i] > b[i]。 数组a和b中的数字各不相同。 输出所有可以达到最优结果的a数组的…

SadTalker 自定义容器化部署配置

Docker 环境检查 执行docker info 查看环境种是否有安装docker&#xff0c;否则首先安装好docker 运行环境。在线环境安装执行执行两条指令即可 sudo apt install docker sudo apt-get install docker-ce sudo apt-get install docker-composesudo systemctl restart dockerG…

langchain源码

itemgetter&#xff1a;返回一个函数&#xff0c;函数取输入dict的某个指定key Runnable 的基本方法有 invoke、 batch、 await、 ainvoke、 abatch 同步转异步 Runnable 还具有的方法&#xff1a;bind、 with_config。 input_schema 属性、output_schema 属性 with_retry方…

Uniapp H5开发常见问题解析

引言 在移动应用开发领域&#xff0c;Uniapp已经成为一个备受瞩目的技术框架&#xff0c;其跨平台能力和高效开发特性使得开发者能够更加便捷地构建出功能丰富、性能优越的应用程序。特别是在H5开发中&#xff0c;Uniapp的应用场景日益广泛&#xff0c;然而&#xff0c;随之而…

Vue2之使用provide和inject实现两个不相干组件之间的通信

Vue2之使用provide和inject实现两个不相干组件之间的通信 文章目录 Vue2之使用provide和inject实现两个不相干组件之间的通信1. 祖先组件中使用provide提供数据2.后代组件A中使用inject注入并使用数据3.后代组件B中使用inject注入并使用数据 在Vue 2中以使用provide和inject来实…

[ciscn 2022 东北赛区]math

1.题目 import gmpy2 from Crypto.Util.number import * from flag import flag assert flag.startswith(b"flag{") assert flag.endswith(b"}") messagebytes_to_long(flag) def keygen(nbit, dbit):if 2*dbit < nbit:while True:a1 getRandomNBitIn…

编辑器目录树的设计,一点也不简单

朋友们好&#xff0c;我是优秀的大鹏 今天花了很长时间思考一个网页文档编辑器&#xff0c;云端目录树要怎么设计 这个看似简单的需求&#xff0c;技术上和产品上的思考却非常复杂 下面以几种编辑器为例&#xff0c;讲一下各种编辑器在技术上和产品的思考 1、以Vscode为代表的本…

Delphi DataSet转JSon (使用SuperObject)

Delphi中将TDataSet转换为JSon字符串。 with ATM.LoadDataSet() dobeginif IsEmpty thenbeginLogObj.WriteLog(未查询到该视图名称下该时间段内的上传数据&#xff0c;视图名称&#xff1a; AViewname 开始时间&#xff1a; AStartdate 结束时间&#xff1a; AEnddate);exit…

【神经网络与深度学习】Transformer原理

transformer ENCODER 输入部分 对拆分后的语句x [batch_size, seq_len]进行以下操作 Embedding 将离散的输入&#xff08;如单词索引或其他类别特征&#xff09;转换为稠密的实数向量&#xff0c;以便可以在神经网络中使用。位置编码 与RNN相比&#xff0c;RNN是一个字一个字…

Django Rest Framework 全局异常处理

在Django Rest Framework&#xff08;DRF&#xff09;中&#xff0c;全局异常处理是一种重要的机制&#xff0c;它可以帮助我们更好地管理API中的异常情况&#xff0c;并返回统一的错误响应。本文将详细介绍两种全局异常处理的方法&#xff1a;使用中间件&#xff08;Middlewar…

机器学习(3)

目录 3-1线性回归 3-2最小二乘解 3-3多元线性回归 3-4广义线性模型 3-5对率回归 3-6对率回归求解 3-7线性判别分析 3-8LDA的多类推广 3-9多分类学习基本思路 3-10类别不平衡 3-1线性回归 线性模型为什么重要&#xff1f; 人类在考虑问题时&#xff0c;通常…

用python写一个自动生成android开机动画的工具

要创建一个自动生成Android开机动画的工具&#xff0c;你需要一些基本的知识&#xff0c;比如Python编程、图像处理和Android开机动画的格式。以下是一个简单的Python脚本示例&#xff0c;它可以生成一个基本的Android开机动画&#xff0c;具体效果可能需要更多的调整和优化。 …

记录glide加载图片,设置圆角

支持所有角的圆角&#xff0c;自动计算合适的半径&#xff0c;不用担心图片比预定值小导致的圆角过大的问题 修改自&#xff1a;https://blog.csdn.net/qq_15059163/article/details/97613790 增加了指定图片尺寸、解决了图片某些情况下圆角过大的问题 public class GlideRou…

先有JVM还是先有垃圾回收器?很多人弄混淆了

是先有垃圾回收器再有JVM呢&#xff0c;还是先有JVM再有垃圾回收器呢&#xff1f;或者是先有垃圾回收再有JVM呢&#xff1f;历史上还真是垃圾回收更早面世&#xff0c;垃圾回收最早起源于1960年诞生的LISP语言&#xff0c;Java只是支持垃圾回收的其中一种。下面我们就来刨析刨析…

外卖系统的JWT实现登录

1、什么是JWT jwt可以生成一个加密的token&#xff0c;作为用户登录的令牌&#xff0c;当用户登陆成功之后&#xff0c;发放给客户端。请求需要登录的资源或者接口的时候&#xff0c;将token携带&#xff0c;后端验证token是否合法。jwt有三部分组成&#xff1a; A&#xff1a;…

【特大喜讯】国内前33位持有PMI-RMP风险管理专业认证的学员分享~!

【学员背景】 沈阳某信息科技有限公司&#xff0c;从事企业采购供应链数字化转型方向&#xff1b; 为企业提供有效的降本增效解决方案。 【学员顺利拿证后期访问】 问&#xff1a;学员您好&#xff0c;首先恭喜您顺利拿到RMP证书&#xff0c;请问您在此次备考过程中&#xf…