12个 Python 装饰器让代码cleaner

0 — 引言

装饰器能在在不影响质量的情况下用更少的代码做更多的事情。

Python 装饰器是强大的工具,可帮助你生成干净、可重用和可维护的代码。

我等了很久才想了解这些抽象,现在我已经有了扎实的理解,本篇是为了帮助你也掌握这些对象背后的概念。

今天没有大的介绍或冗长的理论。

这篇文章是经常在项目中使用的 12 个有用的装饰器的文档列表,以使用额外的功能扩展代码。
我们将深入研究每个装饰器,分析代码并尝试一些具体示例。

如果你是 Python 开发人员,这篇文章将使用有用的脚本扩展你的工具箱,以提高你的工作效率并避免重复代码。

1 — @logger(开始)✏️

如果你不熟悉装饰器,你可以将它们视为将函数作为输入并在不改变其主要用途的情况下扩展其功能的特殊函数。

让我们从一个简单装饰器开始,它通过记录函数开始和结束执行的时间来扩展函数。

被装饰的函数的结果如下所示:

some_function(args) 
# ----- some_function: 开始 ----- 
# some_function 执行
# ----- some_function: 结束 -----

要编写这个 decroator,你首先必须选择一个合适的名称:我们称它为logger。

logger是一个函数,它接受一个函数作为输入并返回一个函数作为输出。输出函数通常是输入的扩展版本。start在我们的例子中,我们希望output函数用start 和end语句包围input函数的调用。

由于我们不知道输入函数使用什么参数,我们可以使用*args和**kwargs传递给wrapper函数这些表达式允许传递任意数量的位置参数和keyword 参数。

下面是logger装饰器的一个简单实现:

def logger(function):
    def wrapper(*args, **kwargs):
        print(f"----- {function.__name__}: start -----")
        output = function(*args, **kwargs)
        print(f"----- {function.__name__}: end -----")
        return output
    return wrapper

现在你可以将logger应用到some_function或任何其他函数。

decorated_function = logger(some_function)

Python 为此提供了更 Pythonic 的语法,它使用@符号。

@logger
def some_function(text):
    print(text)

some_function("first test")
# ----- some_function: start -----
# first test
# ----- some_function: end -----

some_function("second test")
# ----- some_function: start -----
# second test
# ----- some_function: end -----

2 — @wraps 🎁

这个装饰器将wrapper包装函数更新为看起来像原始函数,并继承了它的名称和属性。

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

(这个装饰器还没有使用@wraps)

def logger(function):
    def wrapper(*args, **kwargs):
        """wrapper documentation"""
        print(f"----- {function.__name__}: start -----")
        output = function(*args, **kwargs)
        print(f"----- {function.__name__}: end -----")
        return output
    return wrapper

@logger
def add_two_numbers(a, b):
    """this function adds two numbers"""
    return a + b

add_two_numbers如果我们通过调用__name__和属性来检查修饰函数的名称和文档__doc__,我们会得到……不自然(但仍是预期的)结果:

add_two_numbers.__name__
'wrapper'

add_two_numbers.__doc__
'wrapper documentation'

我们取而代之的是装饰函数名称和文档 ⚠️

这是不希望的结果。我们希望保留原始函数的名称和文档。这时候@wraps装饰器 就派上用场了。

你所要做的就是装饰wrapper函数。

from functools import wraps

def logger(function):
    @wraps(function)
    def wrapper(*args, **kwargs):
        """wrapper documentation"""
        print(f"----- {function.__name__}: start -----")
        output = function(*args, **kwargs)
        print(f"----- {function.__name__}: end -----")
        return output
    return wrapper

@logger
def add_two_numbers(a, b):
    """this function adds two numbers"""
    return a + b

通过重新检查名称和文档,我们看到了原始函数的元数据。

add_two_numbers.__name__
# 'add_two_numbers'

add_two_numbers.__doc__
# 'this function adds two numbers'

3 — @lru_cache 💨

这是一个内置的装饰器,你可以从functools. 导入

它是缓存函数的返回值,使用最近最少使用 (LRU) 算法在缓存已满时丢弃最少使用的值。

我通常将此装饰器用于长时间运行的任务,这些任务不会使用相同的输入更改输出,例如查询数据库、请求静态远程网页或运行一些繁重的处理。

在下面的例子中,我用lru_cache装饰器来模拟一些处理的函数。然后,我连续多次将该函数应用于同一输入。

import random
import time
from functools import lru_cache


@lru_cache(maxsize=None)
def heavy_processing(n):
    sleep_time = n + random.random()
    time.sleep(sleep_time)

# first time
%%time
heavy_processing(0)
# CPU times: user 363 µs, sys: 727 µs, total: 1.09 ms
# Wall time: 694 ms

# second time
%%time
heavy_processing(0)
# CPU times: user 4 µs, sys: 0 ns, total: 4 µs
# Wall time: 8.11 µs

# third time
%%time
heavy_processing(0)
# CPU times: user 5 µs, sys: 1 µs, total: 6 µs
# Wall time: 7.15 µs

如果你想从头开始自己实现一个缓存装饰器,你可以这样做:

  • 你将空字典作为属性添加到包装函数,以存储输入函数先前计算的值

  • 调用输入函数时,首先检查它的参数是否存在于缓存中。如果是这样,返回结果。否则,计算它并将其放入缓存中。

from functools import wraps

def cache(function):
    @wraps(function)
    def wrapper(*args, **kwargs):
        cache_key = args + tuple(kwargs.items())
        if cache_key in wrapper.cache:
            output = wrapper.cache[cache_key]
        else:
            output = function(*args)
            wrapper.cache[cache_key] = output
        return output
    wrapper.cache = dict()
    return wrapper

@cache
def heavy_processing(n):
    sleep_time = n + random.random()
    time.sleep(sleep_time)


%%time
heavy_processing(1)
# CPU times: user 446 µs, sys: 864 µs, total: 1.31 ms
# Wall time: 1.06 s

%%time
heavy_processing(1)
# CPU times: user 11 µs, sys: 0 ns, total: 11 µs
# Wall time: 13.1 µs

4 — @repeat 🔁

这个装饰器导致一个函数被连续多次调用。

这对于调试目的、压力测试或自动重复多项任务很有用。

与之前的装饰器不同,这个装饰器需要一个输入参数。

def repeat(number_of_times):
    def decorate(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            for _ in range(number_of_times):
                func(*args, **kwargs)
        return wrapper
    return decorate

下面的示例定义了一个装饰器,调用repeat它以多次作为参数。装饰器然后定义一个函数调用wrapper,它包裹在被装饰的函数周围。该wrapper函数调用装饰函数的次数等于指定的次数。

@repeat(5)
def dummy():
    print("hello")

dummy()
# hello
# hello
# hello
# hello
# hello

5 — @timeit ⏲️

这个装饰器测量函数的执行时间并打印结果:这用作调试或监视。

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

import time
from functools import wraps

def timeit(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = func(*args, **kwargs)
        end = time.perf_counter()
        print(f'{func.__name__} took {end - start:.6f} seconds to complete')
        return result
    return wrapper

@timeit
def process_data():
    time.sleep(1)

process_data()
# process_data took 1.000012 seconds to complete

6 — @retry 🔁

这个装饰器强制函数在遇到异常时重试多次。

它需要三个参数:重试次数、捕获和重试的异常以及重试之间的休眠时间。

它是这样工作的:

  • 包装函数启动迭代的 for 循环num_retries

  • 在每次迭代中,它都会调用 try/except 块中的输入函数。当调用成功时,它会打破循环并返回结果。否则,它会休眠sleep_time秒并继续下一次迭代。

  • 当 for 循环结束后函数调用不成功时,包装函数将引发异常。

import random
import time
from functools import wraps

def retry(num_retries, exception_to_check, sleep_time=0):
    """
    Decorator that retries the execution of a function if it raises a specific exception.
    """
    def decorate(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            for i in range(1, num_retries+1):
                try:
                    return func(*args, **kwargs)
                except exception_to_check as e:
                    print(f"{func.__name__} raised {e.__class__.__name__}. Retrying...")
                    if i < num_retries:
                        time.sleep(sleep_time)
            # Raise the exception if the function was not successful after the specified number of retries
            raise e
        return wrapper
    return decorate

@retry(num_retries=3, exception_to_check=ValueError, sleep_time=1)
def random_value():
    value = random.randint(1, 5)
    if value == 3:
        raise ValueError("Value cannot be 3")
    return value

random_value()
# random_value raised ValueError. Retrying...
# 1

random_value()
# 5

7 — @countcall 🔢

这个装饰器计算一个函数被调用的次数。

这个数字存储在包装器属性中count

from functools import wraps

def countcall(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        wrapper.count += 1
        result = func(*args, **kwargs)
        print(f'{func.__name__} has been called {wrapper.count} times')
        return result
    wrapper.count = 0
    return wrapper

@countcall
def process_data():
    pass

process_data()
process_data has been called 1 times
process_data()
process_data has been called 2 times
process_data()
process_data has been called 3 times

8 — @rate_limited 🚧

这是一个装饰器,它通过在函数调用过于频繁时休眠一段时间来限制调用函数的速率。

import time
from functools import wraps

def rate_limited(max_per_second):
    min_interval = 1.0 / float(max_per_second)
    def decorate(func):
        last_time_called = 0.0
        @wraps(func)
        def rate_limited_function(*args, **kargs):
            elapsed = time.perf_counter() - last_time_called
            left_to_wait = min_interval - elapsed
            if left_to_wait > 0:
                time.sleep(left_to_wait)
            ret = func(*args, **kargs)
            last_time_called = time.perf_counter()
            return ret
        return rate_limited_function
    return decorate

装饰器的工作方式是测量自上次调用该函数以来经过的时间,并在必要时等待适当的时间以确保不超过速率限制。等待时间计算为min_interval - elapsed,其中min_interval是两次函数调用之间的最小时间间隔(以秒为单位),elapsed是自上次调用以来经过的时间。

如果经过的时间小于最小间隔,该函数将等待几left_to_wait秒钟,然后再次执行。

因此,此函数在调用之间引入了轻微的时间开销,但确保不超过速率限制。

还有一个实现 API 速率限制的第三方包ratelimit:它称为ratelimit

pip install ratelimit

要使用这个包,只需装饰任何进行 API 调用的函数:

from ratelimit import limits

import requests

FIFTEEN_MINUTES = 900

@limits(calls=15, period=FIFTEEN_MINUTES)
def call_api(url):
    response = requests.get(url)

    if response.status_code != 200:
        raise Exception('API response: {}'.format(response.status_code))
    return response

如果装饰函数被调用的次数超过允许的次数,ratelimit.RateLimitException则引发 a 。

为了能够处理这个异常,可以sleep_and_retry结合装饰器使用装饰器ratelimit

@sleep_and_retry
@limits(calls=15, period=FIFTEEN_MINUTES)
def call_api(url):
    response = requests.get(url)

    if response.status_code != 200:
        raise Exception('API response: {}'.format(response.status_code))
    return response

这会导致函数在再次执行之前休眠剩余的时间。

9 — @dataclass 🗂️

Python中的装饰@dataclass器是用来装饰类的。

它自动为主要存储数据的类生成特殊方法,例如__init____repr____eq____lt__和。__str__这可以减少样板代码并使类更具可读性和可维护性。

它还提供了现成的漂亮方法来很好地表示对象,将它们转换为 JSON 格式,使它们不可变等。

装饰@dataclass器是在 Python 3.7 中引入的,并且在标准库中可用。

from dataclasses import dataclass, 

@dataclass
class Person:
    first_name: str
    last_name: str
    age: int
    job: str

    def __eq__(self, other):
        if isinstance(other, Person):
            return self.age == other.age
        return NotImplemented

    def __lt__(self, other):
        if isinstance(other, Person):
            return self.age < other.age
        return NotImplemented


john = Person(first_name="John", 
              last_name="Doe", 
              age=30, 
              job="doctor",)

anne = Person(first_name="Anne", 
              last_name="Smith", 
              age=40, 
              job="software engineer",)

print(john == anne)
# False

print(anne > john)
# True

asdict(anne)
#{'first_name': 'Anne',
# 'last_name': 'Smith',
# 'age': 40,
# 'job': 'software engineer'}

如果你对数据类感兴趣,可以查看我之前的一篇文章。

10 — @register 🛑

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

from atexit import register

@register
def terminate():
    perform_some_cleanup()
    print("Goodbye!")

while True:
    print("Hello")

运行此脚本并按下 CTRL+C 时,

我们看到了函数的输出terminate

11 — @property 🏠

属性装饰器用于定义类属性,这些属性本质上是类实例属性的gettersetterdeleter方法。

通过使用属性装饰器,你可以将方法定义为类属性并像访问类属性一样访问它,而无需显式调用该方法。

如果你想围绕获取和设置值添加一些约束和验证逻辑,这将很有用。

在下面的示例中,我们在 rating 属性上定义了一个 setter 以对输入(0 到 5 之间)施加约束。

class Movie:
    def __init__(self, r):
        self._rating = r

    @property
    def rating(self):
        return self._rating

    @rating.setter
    def rating(self, r):
        if 0 <= r <= 5:
            self._rating = r
        else:
            raise ValueError("The movie rating must be between 0 and 5!")

batman = Movie(2.5)
batman.rating
# 2.5
batman.rating = 4
batman.rating
# 4
batman.rating = 10

# ---------------------------------------------------------------------------
# ValueError                                Traceback (most recent call last)
# Input In [16], in <cell line: 1>()
# ----> 1 batman.rating = 10
# Input In [11], in Movie.rating(self, r)
#      12     self._rating = r
#      13 else:
# ---> 14     raise ValueError("The movie rating must be between 0 and 5!")
#
# ValueError: The movie rating must be between 0 and 5!

12 — @singledispatch

这个装饰器允许一个函数对不同类型的参数有不同的实现。

from functools import singledispatch

@singledispatch
def fun(arg):
    print("Called with a single argument")

@fun.register(int)
def _(arg):
    print("Called with an integer")

@fun.register(list)
def _(arg):
    print("Called with a list")

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

结论

装饰器是有用的抽象,可以使用额外的功能扩展你的代码,例如缓存、自动重试、速率限制、日志记录,或将你的类变成超级数据容器。

它并不止于此,因为你可以更有创意并实施你的自定义装饰器来解决非常具体的问题。

这里有一个很棒的装饰器列表,可以从中获得灵感,在适当的时候予以借鉴。

参考

12-python-decorators

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

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

uni-app+uView如何轮播图滑动时改变背景颜色和导航栏颜色

今儿的创作欲很高涨哈 &#x1f604; 这也是在群里看到的&#xff0c;群友问如何在滑动&#xff08;或者自动滑动&#xff09;的时候背景颜色能跟着变 正好之前做过这个需求&#xff0c;也分享一下 首先&#xff0c;页面的组成分为三部分&#xff1a; 自定义navbar 页面背景轮…

JavaSE进阶之(十六)枚举

十六、枚举16.1 背景16.2 枚举类型16.3 EnumSet 和 EnumMap01、EnumSet02、EnumMap16.1 背景 在 Java 语言中还没有引入枚举类型之前&#xff0c;表示枚举类型的常用模式是声明一组 int 类型的常量&#xff0c;常常用的就是&#xff1a; public static final int SPRING 1; …

ElementUI学习笔记

目录 一、简单介绍 二、安装 1、下载 2、引入 三、布局 1、简介 2、使用 3、好处 四、布局容器 1、常见排布 2、调整样式 五、按钮 1、简单引用 2、改变样式 3、加载中效果 六、表格 1、简单使用 2、样式修改 七、对话框 1、简单使用 2、添加自定义内容 3、…

7个最受瞩目的 Python 库,提升你的开发效率

当今时代&#xff0c;数据分析和处理已经成为了各行各业中不可或缺的一环。Python作为一种非常流行的编程语言&#xff0c;为我们提供了许多强大的工具和库来处理不同类型的数据。 在这篇文章中&#xff0c;我将向您介绍七个非常有用的Python库&#xff0c;这些库各自有着独特…

js调用gpt3.5

参考链接&#xff1a;直接在前端调用 GPT-3 API 效果图&#xff1a; <!DOCTYPE html> <html><head><meta charset"UTF-8" /><title>ChatGPT Web Example</title><style>body {font-family: "Helvetica Neue"…

TimeQuest时序路径详解

&#x1f4a1; 基于TimeQuest软件来查看时序报告和分析时序路径 分析最坏传输路径 根据[FPGA典型时序路径的分析可知&#xff0c;最坏传输路径对应的建立时间&#xff08;setup time&#xff09;余量最小。所以&#xff0c;查看最坏传输路径也就是查看建立时间余量最小的路径。…

【Linux】安装DHCP服务器

1、先检测网络是否通 get dhcp.txt rpm -qa //查看软件包 rpm -qa |grep dhcp //确定是否安装 yum install dhcp //进行安装 安装完成后 查询 rpm -ql dhcp 进行配置 cd /etc/dhcp 查看是否有遗留dhcpd.conf.rpmsave 删除该文件 cp /usr/share/doc/dhcp-4.1.1/dhcpd.conf.sampl…

ChatGPT能代替Oracle DBA吗?用Oracle OCP(1z0-083)的真题测试一下。

让我们来看看ChatGPT不能通过Oracle OCP的考试&#xff1f; 文章目录引言测试过程总结和分析关于博主&#xff0c;姚远&#xff1a;Oracle ACE&#xff08;Oracle和MySQL数据库方向&#xff09;。Oracle MAA 大师。华为云MVP。《MySQL 8.0运维与优化》的作者。拥有 Oracle 10g和…

mysql和mysql2模块的区别!!(nodejs中的模块)

mysql 和 mysql2 都是 Node.js 中常用的操作 MySQL 数据库的模块&#xff0c;它们的主要区别是在实现方式上略有不同。 mysql&#xff1a;是 Node.js 中比较早期的 MySQL 操作模块&#xff0c;该模块底层使用的是回调函数&#xff08;callback&#xff09;来实现异步操作。在处…

ESP32设备驱动-DHT12温湿度传感器驱动

DHT12温湿度传感器驱动 文章目录DHT12温湿度传感器驱动1、DHT12介绍2、硬件准备3、软件准备4、驱动实现1、DHT12介绍 DHt12是经典DHT11温湿度传感器的升级版&#xff0c;完全向下兼容&#xff0c;精度更高&#xff0c;增加了I2C接口。 DHT12 具有单总线和标准 I 2C 两种通讯&…

一文7个步骤从0到1教你搭建Selenium 自动化测试环境

【导语】Selenium是一个用于Web应用程序测试的工具。Selenium测试直接运行在浏览器中&#xff0c;就像真正的用户在操作一样。支持自动录制动作和自动生成 .Net、Java、Perl等不同语言的测试脚本。本文详细介绍了搭建自动化测试环境所需的工具&#xff0c;让你学习自动化测试不…

不用科学上网,免费的GPT-4 IDE工具Cursor保姆级使用教程

大家好&#xff0c;我是可乐。 过去的一周&#xff0c;真是疯狂的一周。 GPT-4 震撼发布&#xff0c;拥有了多模态能力&#xff0c;不仅能和GPT3一样进行文字对话&#xff0c;还能读懂图片&#xff1b; 然后斯坦福大学发布 Alpaca 7 B&#xff0c;性能匹敌 GPT-3.5&#xff…

[图像识别]关于cv2库无法安装的故障问题解决,全网最全解决方案!本人亲身测试,参考了stackoverflow、51CTO等博客文章总结而成

本文范畴&#xff1a;故障排查 cv2 技术 库安装 Linux/Unix 笔记本系统&#xff1a;win10 python版本&#xff1a;3.10 故障问题&#xff1a;无法安装cv2库 适应对象&#xff1a;程序员新手、运维程序员、大学生、青少年对系统感兴趣的爱好者等等 文章目录前言一、cv2库是什么&…

【C语言】栈区与堆区

目录分配管理方式申请大小限制不同申请效率不同总结&#xff1a;栈区、堆区 是内存模型 对比起来看 分配管理方式 栈区由编译器自动管理&#xff0c; 函数运行时分配&#xff0c;函数结束时释放。存放为运行函数而分配的局部变量&#xff08;函数结束时&#xff0c;其内临时…

超级实用,解密云原生监控技术,使用prometheus轻松搞定redis监控

前言 大家好&#xff0c;我是沐风晓月&#xff0c;本文收录于《 prometheus监控系列》 &#xff0c;截止目前prometheus专栏已经更新到第8篇文章。 本文中的是prometheus已经安装好&#xff0c;如果你还未安装&#xff0c;可以参考 prometheus安装及使用入门 若你想监控其他…

现代数据栈MDS应用落地介绍—Vero营销自动化平台

Dazdata MDS现代数据栈MDS的出现使得中小企业低成本获得大数据处理能力成为可能&#xff0c;技术的进步使得各种基于MDS的大数据应用如雨后春笋般涌现&#xff0c;不同于国内的数据中台更多强调数据处理技术&#xff0c;MDS注重落地和最后一公里的大数据应用。Vero是一款现代数…

1630.等差子数组

1630. 等差子数组 难度中等 如果一个数列由至少两个元素组成&#xff0c;且每两个连续元素之间的差值都相同&#xff0c;那么这个序列就是 等差数列 。更正式地&#xff0c;数列 s 是等差数列&#xff0c;只需要满足&#xff1a;对于每个有效的 i &#xff0c; s[i1] - s[i] …

(五)大数据实战——使用模板虚拟机实现hadoop集群虚拟机克隆及网络相关配置

前言 本节内容我们实现虚拟机的克隆&#xff0c;主要根据模板虚拟机克隆三台hadoop虚拟机&#xff0c;用于hadoop集群的搭建&#xff0c;同时根据上一小节的内容&#xff0c;配置hadoop虚拟机的主机名、ip网络等&#xff0c;最终完成hadoop虚拟机的实例化。 正文 虚拟机克隆…

MATLAB | 全网最详细网络图(图论图)绘制教程

一篇超超超长&#xff0c;超超超全面网络图绘制教程&#xff0c;本篇基本能讲清楚所有绘制要点&#xff0c;当然图论与网络优化的算法一篇不可能完全讲清楚&#xff0c;未来如果看的人多可以适当更新&#xff0c;同时做部分网络图绘图复刻。 以下是本篇绘图实验效果&#xff1…

Java中的String类

String类1.String类1.1 特性1.2 面试题1.3 常用方法1.4 String与其他类型之间的转换2. StringBuilder类、StringBuffer类&#xff1a;可变字符序列1.String类 1.1 特性 String类为final类&#xff0c;不可被继承&#xff0c;代表不可变的字符序列&#xff1b; 实现了Serializ…
最新文章