Python的重试装饰器，手把手教你实现它_python 重试装饰器

最新推荐文章于 2024-05-18 09:52:42 发布
最新推荐文章于 2024-05-18 09:52:42 发布
阅读量738 收藏 19
点赞数 17
分类专栏： 程序员 文章标签： python 开发语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84584628/article/details/138279607
版权

复制代码


可以看到 **user\_place\_order** 函数执行了三遍，都发生了除零异常，最后超过最大执行次数，返回了 **None** 值，我们可以在主逻辑中来判断返回值是否为 **None** 来进行超过最大重试次数失败的业务逻辑处理

ret = user_place_order()
print(“user place order ret”, ret)

if not ret:
print(“user place order failed”)
…
复制代码


#### 重试装饰器-改进版


现在只能配置 最大重试次数 没有最大超时时间，有时候我们想不但有重试，还得在规定时间内完成，不想浪费太多试错时间。所以增加一个 最大超时时间配置选项默认为None，有值时超过最大超时时间退出重试。

def task_retry(max_retry_count: int = 5, time_interval: int = 2, max_timeout: int = None):
“”"
任务重试装饰器
Args:
max_retry_count: 最大重试次数 默认 5 次
time_interval: 每次重试间隔 默认 2s
max_timeout: 最大超时时间，单位s 默认为 None,
“”"

def _task_retry(task_func):

    @wraps(task_func)
    def wrapper(*args, **kwargs):
        # 函数循环重试
        start_time = time.time()
        for retry_count in range(max_retry_count):
            print(f"execute count {retry_count + 1}")
            use_time = time.time() - start_time
            if max_timeout and use_time > max_timeout:
                # 超出最大超时时间
                print(f"execute timeout, use time {use_time}s, max timeout {max_timeout}")
                return

            try:
                return task_func(*args, **kwargs)
            except Exception as e:
                print(f"fail {str(e)}")
                time.sleep(time_interval)

    return wrapper

return _task_retry

复制代码


看看效果

超时

@task_retry(max_retry_count=3, time_interval=1, max_timeout=2)
def user_place_order():
a = 1 / 0
print(“user place order success”)
return {“code”: 0, “msg”: “ok”}

out
execute count 1
fail division by zero
execute count 2
fail division by zero
execute count 3
execute timeout, use time 2.010528802871704s, max timeout 2
user place order ret None

超过最大重试次数

@task_retry(max_retry_count=3, time_interval=1)
def user_place_order():
a = 1 / 0
print(“user place order success”)
return {“code”: 0, “msg”: “ok”}

out
execute count 1
fail division by zero
execute count 2
fail division by zero
execute count 3
fail division by zero
user place order ret None

正常

@task_retry(max_retry_count=3, time_interval=1, max_timeout=2)
def user_place_order():
# a = 1 / 0
print(“user place order success”)
return {“code”: 0, “msg”: “ok”}

out
execute count 1
user place order success
user place order ret {‘code’: 0, ‘msg’: ‘ok’}
复制代码


#### 重试装饰器-加强版


到这重试装饰器基本功能就实现了，但还可以加强，Python现在支持 async 异步方式写法，因此要是可以兼容异步写法那就更好了。先看看装饰异步函数会是什么样的效果

import time
import asyncio
import functools

def task_retry(max_retry_count: int = 5, time_interval: int = 2, max_timeout: int = None):
“”"
任务重试装饰器
Args:
max_retry_count: 最大重试次数 默认 5 次
time_interval: 每次重试间隔 默认 2s
max_timeout: 最大超时时间，单位s 默认为 None,
“”"

def _task_retry(task_func):

    @wraps(task_func)
    def wrapper(*args, **kwargs):
        # 函数循环重试
        start_time = time.time()
        for retry_count in range(max_retry_count):
            print(f"execute count {retry_count + 1}")
            use_time = time.time() - start_time
            if max_timeout and use_time > max_timeout:
                # 超出最大超时时间
                print(f"execute timeout, use time {use_time}s, max timeout {max_timeout}")
                return

            try:
                return task_func(*args, **kwargs)
            except Exception as e:
                print(f"fail {str(e)}")
                time.sleep(time_interval)

    return wrapper

return _task_retry

@task_retry(max_retry_count=3, time_interval=1, max_timeout=2)
def user_place_order():
# a = 1 / 0
print(“user place order success”)
return {“code”: 0, “msg”: “ok”}

@task_retry(max_retry_count=3, time_interval=2, max_timeout=5)
async def user_place_order_async():
“”“异步函数重试案例”“”
a = 1 / 0
print(“user place order success”)
return {“code”: 0, “msg”: “ok”}

async def main():

# 同步案例
# ret = user_place_order()
# print(f"user place order ret {ret}")

# 异步案例
ret = await user_place_order_async()
print(f"user place order ret {ret}")

if name == ‘main’:
asyncio.run(main())

正常时候

execute count 1
user place order success
user place order ret {‘code’: 0, ‘msg’: ‘ok’}

异常时候

out
execute count 1
Traceback (most recent call last):
File “G:/code/python/py-tools/decorator/base.py”, line 138, in
asyncio.run(main())
File “G:\softs\DevEnv\python-3.7.9\lib\asyncio\runners.py”, line 43, in run
return loop.run_until_complete(main)
File “G:\softs\DevEnv\python-3.7.9\lib\asyncio\base_events.py”, line 587, in run_until_complete
return future.result()
File “G:/code/python/py-tools/decorator/base.py”, line 133, in main
ret = await user_place_order_async()
File “G:/code/python/py-tools/decorator/base.py”, line 121, in user_place_order_async
a = 1 / 0
ZeroDivisionError: division by zero

Process finished with exit code 1
复制代码


发现发生异常的时候并没有重试，为什么呢？其实在执行 **task\_func()** 它并没有真正的执行内部逻辑，而是返回一个 **coroutine** 协程对象，并不会报异常，所以再装饰器中执行一遍就成功就出来了，外面 **ret = await user\_place\_order\_async()，** 后才真正的等待执行，然后执行函数内的逻辑再报异常就没有捕获到。我们可以打断点验证下


![](https://img-blog.csdnimg.cn/img_convert/0c69006c29dc910fa6870a8059e832ae.webp?x-oss-process=image/format,png)


这样装饰器就不支持异步函数的重试，需要加强它，可以使用 **asyncio.iscoroutinefunction() 来进行异步函数的判断，** 然后再加一个异步函数的闭包就可以实现异步、同步函数都兼容的重试装饰器。

def task_retry(max_retry_count: int = 5, time_interval: int = 2, max_timeout: int = None):
“”"
任务重试装饰器
Args:
max_retry_count: 最大重试次数 默认 5 次
time_interval: 每次重试间隔 默认 2s
max_timeout: 最大超时时间，单位s 默认为 None,
“”"

def _task_retry(task_func):

    @functools.wraps(task_func)
    def sync_wrapper(*args, **kwargs):
        # 同步循环重试
        start_time = time.time()
        for retry_count in range(max_retry_count):
            print(f"execute count {retry_count + 1}")
            use_time = time.time() - start_time
            if max_timeout and use_time > max_timeout:
                # 超出最大超时时间
                print(f"execute timeout, use time {use_time}s, max timeout {max_timeout}")
                return

            try:
                task_ret = task_func(*args, **kwargs)
                return task_ret
            except Exception as e:
                print(f"fail {str(e)}")
                time.sleep(time_interval)

    @functools.wraps(task_func)
    async def async_wrapper(*args, **kwargs):
        # 异步循环重试
        start_time = time.time()
        for retry_count in range(max_retry_count):
            print(f"execute count {retry_count + 1}")
            use_time = time.time() - start_time
            if max_timeout and use_time > max_timeout:
                # 超出最大超时时间
                print(f"execute timeout, use time {use_time}s, max timeout {max_timeout}")
                return

            try:
                return await task_func(*args, **kwargs)
            except Exception as e:
                print(f"fail {str(e)}")
                await asyncio.sleep(time_interval)

    # 异步函数判断
    wrapper_func = async_wrapper if asyncio.iscoroutinefunction(task_func) else sync_wrapper
    return wrapper_func

return _task_retry

复制代码


**注意时间等待** **await asyncio.sleep(time\_interval) 会导致函数挂起，程序不会在这里等待，而是去事件循环loop中执行其他的已经就绪的任务，如果其他函数运行时间太久了才切换回来，会导致时间超时，换成 time.sleep()的话其实也没有用，如果函数内部还有异步函数执行还是会切换出去，因此异步的时候感觉超时参数意义不大。**


模拟测试下

@task_retry(max_retry_count=5, time_interval=2, max_timeout=5)
async def user_place_order_async():
“”“异步函数重试案例”“”
a = 1 / 0
print(“user place order success”)
return {“code”: 0, “msg”: “ok”}

async def io_test():
“”“模拟io阻塞”“”
print(“io test start”)
time.sleep(3)
print(“io test end”)
return “io test end”

async def main():
# 同步案例
# ret = user_place_order()
# print(f"user place order ret {ret}")

# 异步案例
# ret = await user_place_order_async()
# print(f"user place order ret {ret}")

# 并发异步
order_ret, io_ret = await asyncio.gather(
    user_place_order_async(),
    io_test(),
)
print(f"io ret {io_ret}")
print(f"user place order ret {order_ret}")

if name == ‘main’:
asyncio.run(main())

out
execute count 1
fail division by zero
io test start
io test end
execute count 2
fail division by zero
execute count 3
execute timeout, use time 5.015768527984619s, max timeout 5
io ret io test end
user place order ret None
复制代码


可以看出执行一遍后自动切换到了 io\_test 中执行由于 io test 中的 **time.sleep(3) 会导致整个线程阻塞，一定要等到io\_test执行完后才会切换回去，然后再执行两遍就超时了，你可能会说都用异步的库，是的异步的库是可以加速，但我想表达就是这时候统计的耗时是整个程序的而不是单独一个函数的。大家可以在评论区帮我想想有没有其他的方法，要么就不要用这个超时参数。**


可以兼容异步函数、然后超时参数可以不配置，影响不大，O(∩\_∩)O~


#### 重试装饰器-最终版


最终版就是利用抛异常的方式来结束超过最大重试次数、最大超时，而不是直接返回None，然后再添加一个可配置捕获指定异常的参数，当发生特定异常的时候才重试。

import time
import asyncio
import functools
from typing import Type

class MaxRetryException(Exception):
“”“最大重试次数异常”“”
pass

class MaxTimeoutException(Exception):
“”“最大超时异常”“”
pass

def task_retry(
max_retry_count: int = 5,
time_interval: int = 2,
max_timeout: int = None,
catch_exc: Type[BaseException] = Exception
):
“”"
任务重试装饰器
Args:
max_retry_count: 最大重试次数 默认 5 次
time_interval: 每次重试间隔 默认 2s
max_timeout: 最大超时时间，单位s 默认为 None,
catch_exc: 指定捕获的异常类用于特定的异常重试 默认捕获 Exception
“”"

def _task_retry(task_func):

    @functools.wraps(task_func)
    def sync_wrapper(*args, **kwargs):
        # 函数循环重试
        start_time = time.time()
        for retry_count in range(max_retry_count):
            print(f"execute count {retry_count + 1}")
            use_time = time.time() - start_time
            if max_timeout and use_time > max_timeout:
                # 超出最大超时时间
                raise MaxTimeoutException(f"execute timeout, use time {use_time}s, max timeout {max_timeout}")

            try:
                task_ret = task_func(*args, **kwargs)
                return task_ret
            except catch_exc as e:
                print(f"fail {str(e)}")
                time.sleep(time_interval)
        else:
            # 超过最大重试次数, 抛异常终止

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

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

img
img

二、Python必备开发工具

工具都帮大家整理好了，安装就可直接上手！img

三、最新Python学习笔记

当我学到一定基础，有自己的理解能力的时候，会去阅读一些前辈整理的书籍或者手写的笔记资料，这些笔记详细记载了他们对一些技术点的理解，这些理解是比较独到，可以学到不一样的思路。

img

四、Python视频合集

观看全面零基础学习视频，看视频学习是最快捷也是最有效果的方式，跟着视频中老师的思路，从基础到深入，还是很容易入门的。

img

五、实战案例

纸上得来终觉浅，要学会跟着视频一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。img

六、面试宝典

在这里插入图片描述

在这里插入图片描述

简历模板在这里插入图片描述

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

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

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

2401_84584628
关注
  • 17
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
retry:易于使用的python重试装饰器
05-14
重试 易于使用的重试装饰器。 特征 没有外部依赖性（仅stdlib）。 （可选）保留功能签名（pip安装修饰符）。 原始回溯，易于调试。 安装 $ pip install retry 原料药 重试装饰器 def retry ( exceptions = Exception , tries = - 1 , delay = 0 , max_delay = None , backoff = 1 , jitter = 0 , logger = logging_logger ): """Return a retry decorator. :param exceptions: an exception or a tuple of exceptions to catch. default: Exception. :param tries: the maximum numb
python——retry装饰器
高压锅博客
11-24 950
1. 手写代码 import functools import logging import time def retry(tries=3, interval=1): # 装饰器，任务函数调用时，进行重试三次 def decorate(func): @functools.wraps def wrapper(*args, **kwargs): count = 0 while True:
Python的重试装饰器，手把手教你实现它_python 重试装饰器(1)
sfdsfgdgd的博客
04-30 299
看看效果。
Python @retry装饰器
qq_42997214的博客
01-14 1147
安装： pip install retrying 在@retry()装饰器中，比较重要的几个参数如下： stop_max_attempt_number： 在停止之前尝试的最大次数，最后一次如果还是有异常则会抛出异常，停止运行，默认为5次 wait_random_min： 在两次调用方法停留时长，停留最短时间，默认为0,单位毫秒 wait_random_max： 在两次调用方法停留时长，停留最长时间，默认为1000毫秒 retry_on_result： 指定一个函数，如果指定的函数返回True，则重试，否则抛
探索优雅的重试机制：retry —— Python中的神奇装饰器
gitblog_00033的博客
05-18 304
探索优雅的重试机制：retry —— Python中的神奇装饰器 项目地址:https://gitcode.com/invl/retry 在软件开发中，我们经常遇到网络请求失败、数据库连接超时等不可预测的问题，这些情况通常需要我们以某种方式处理并重新尝试操作。为此，我们向您推荐一个强大的Python库——retry，这是一个轻量级、无依赖且高度可定制化的重试装饰器。 项目介绍 retry 是一款纯...
python 为函数加上自动retry 的装饰器
rav009的专栏
02-01 578
""" :param delays: An iterable object the defines num of seconds between reties, also indicating num of retries. Default: retry 3 times, waiting 1/5/30 seconds. :param exceptions: Specifies exceptions that trigger re.
python重试装饰器的简单实现方法
09-19
本篇文章将详细介绍如何在Python中实现一个简单的重试装饰器。 首先，我们来看一下提供的重试装饰器的实现代码。这个装饰器定义了一个`retry`函数，它可以接受几个参数，如最大重试次数`max_retries`、初始延迟`...
Python自动重试HTTP连接装饰器
09-22
在这里，我们讨论的是一种特定的装饰器，即"Python自动重试HTTP连接装饰器"，它会在HTTP连接失败时自动进行重试，从而提高接口调用的可靠性。 首先，让我们深入理解装饰器的工作原理。装饰器本质上是一个接收函数...
python重试装饰器示例
12-24
利用python 写一些网络服务的时候，当网络状况不好，或者资源占用过多，任务拥塞的情况下，总会抛出一些异常，当前任务就被终止了，可以很好的利用@装饰器，写一个重试的装饰器，这样比较python！执行结果：复制代码...
Python中的多重装饰器
09-22
主要介绍了Python中的多重装饰器,多重装饰器即多个装饰器修饰同一个对象,但实际上并非完全如此,本文用实例讲解了各种情况,需要的朋友可以参考下
《云计算全栈》-python篇：使用装饰器实现-测试程序运行效率
01-21
查看每个函数运行耗时时长，这时如果修改每个函数，为它加上计时的功能，我们需要耗时去了解每个函数的功能，思考如何修改去增加计时功能，这样会相当繁琐，为避免这种现象出现，我们利用装饰器函数在不变动其他函数...
python之装饰器，多重装饰器，多层函数装饰器
12-21
Python中的装饰器是一种强大的工具，它允许我们修改或增强函数、类或其他可调用对象的行为，而无需直接改动它们的源代码。装饰器基于闭包的概念，因此理解闭包是学习装饰器的关键。 闭包是一种特殊的函数，它定义在...
Python自动重试HTTP连接装饰器.pdf
04-17
装饰器内部使用了一个字典`count`来跟踪重试的次数，每次发生异常时，`count['num']`会递增1，直到达到最大重试次数。 当`wrapped`函数执行时，如果`try`块中的代码（即调用原始函数`function`）抛出异常，且`count...
12个步骤教你理解Python装饰器
09-19
Python装饰器是Python语言中的一个重要特性，用于修改或增强函数、方法或类的行为。通过装饰器，可以在不改变原函数代码的情况下，增加额外的功能，如性能监控、日志记录、权限控制等。以下是对装饰器的详细解释： ...
Python 程序语言设计模式思路-结构型模式：装饰器讲解及利用Python装饰器模式实现高效日志记录和性能测试
最新发布
05-21
装饰器模式（Decorator Pattern）是结构型设计模式之一，用于动态地向对象添加额外的职责，而不影响其他对象。这种模式通过使用装饰器函数，允许你在保持原始功能的基础上，灵活地扩展代码的行为。
12步教你理解Python装饰器
12-23
通过下面的步骤让你由浅入深明白装饰器是什么。假定你拥有最基本的Python知识，本文阐述的东西可能对那些在工作中经常接触Python的人有很大的帮助。 1、函数（Functions） 在Python里，函数是用def关键字后跟一个...
python重试装饰器
恒
06-24 319
def retry(max_retries: int = 3, interval: (int, float) = 0, exceptions: list = None, front_waiting: bool = False): """ 重试装饰器。 被修饰的函数被要求只有两类结果，要么是异常，要么是正确的结果。 :param max_retries: 重试次数。 :param interval: 可重试异常发生时、重试的延迟，单位秒。 .
python重试装饰器(Python function retry decorator)
程序员-小枫的博客
09-14 1764
python重试装饰器(Python function retry decorator) 在用requests请求接口或者html的时候，很容易出现超时，限制等各种原因。 在对源代码不进行修改的情况下，可以用装饰器来进行重试 任何函数： 成功，返回-结果，失败，返回--False 都可以用这个装饰器进行重试 1.不需要传参的装饰器写法: max_retry 为默认重试的次数 import requests def retry(func): def inner(*args, **kw
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值