python之第三方库tenacity重试库的详细使用：Tenacity是一个通用的retry库，简化为任何任务加入重试的功能

前言

1、在实际应用中，经常会碰到在web网络请求时，因为网络的不稳定，会有请求超时的问题，这时候，一般都是自己去实现重试请求的逻辑，直到得到响应或者超时。虽然这样的逻辑并不复杂，但是代码写起来却不那么优雅，不那么pythonic。

2、在与接口的通信过程中，为了防止由于网络不稳定情况，造成请求错误或者超时等问题，或者其他不可控因素等造成功能性问题，代码中一般都会加入重试功能以增加代码的健壮性。

3、 tenacity 库是一个重试库，使用python语言编写，它能够让我们在任务的重试操作中变得非常简单，使用的是Apache 2.0开源协议。

4、 tenacity 库是一个 Apache 2.0 许可的通用重试库，用 Python 编写，用于简化向几乎任何事物添加重试行为的任务。

5、 tenacity 库的特性：

通用装饰器 API
指定停止条件（即尝试次数限制）
指定等待条件（即尝试之间的指数退避睡眠）
自定义重试异常
自定义对预期返回结果的重试
重试协程
使用上下文管理器重试代码块

6、在编写程序尤其是与网络请求相关的程序，如调用web接口、运行网络爬虫等任务时，经常会遇到一些偶然发生的请求失败的状况，这种时候如果我们仅仅简单的捕捉错误然后跳过对应任务，肯定是不严谨的，尤其是在网络爬虫中，会存在损失有价值数据的风险。

安装

pip install tenacity

使用

1、基本重试（无条件重试，重试之间无间隔，报错之后就立马重试）

tenacity 库的错误重试核心功能由其 retry 装饰器来实现，默认在不给 retry 装饰器传参数时，它会在其所装饰的函数运行过程抛出错误时不停地重试下去。

from tenacity import retry


@retry
def never_give_up_never_surrender():
    print("无条件重试，重试之间无间隔，报错之后就立马重试")
    raise Exception


if __name__ == '__main__':
    never_give_up_never_surrender()

运行结果：

2、停止重试

设置重试次数：

有些时候我们对某段函数逻辑错误重试的忍耐是有限度的，譬如当我们调用某个网络接口时，如果连续n次都执行失败，我们可能就会认为这个任务本身就存在缺陷，不是通过重试就能够使其正常的。

这种时候我们可以利用 tenacity 库中的 stop_after_attempt 函数，作为 retry() 中的 stop 参数传入，从而为我们“无尽”的错误重试过程添加一个终点，其中 stop_after_attempt() 接受一个整数输入作为「最大重试」的次数：

from tenacity import retry, stop_after_attempt


@retry(stop=stop_after_attempt(max_attempt_number=7))
def stop_after_7_attempts():
    print("重试7次后停止")
    raise Exception


if __name__ == '__main__':
    stop_after_7_attempts()

运行结果：

设置时间限制：

tenacity 库还为我们提供了 stop_after_delay() 函数来设置整个重试过程的最大耗时，超出这个时长也会结束重试过程：

from tenacity import retry, stop_after_delay


@retry(stop=stop_after_delay(10))
def stop_after_10_s():
    print("10秒后停止重试")
    raise Exception


if __name__ == '__main__':
    stop_after_10_s()

运行结果：

组合多个停止条件：

如果我们的任务同时需要添加最大重试次数以及最大超时时长限制，在 tenacity 库中仅需要用|运算符组合不同的限制条件再传入 retry() 的 stop 参数即可。

将 stop_after_delay 函数和 stop_after_attempt 函数组合起来用，如下的代码，只要其中一个条件满足，函数就抛出异常。

譬如下面的例子，当我们的函数执行重试超过3秒或次数大于5次时均可以结束重试：

from tenacity import retry, stop_after_delay, stop_after_attempt


@retry(stop=(stop_after_delay(max_delay=3) | stop_after_attempt(max_attempt_number=5)))
def stop_after_3_s_or_5_retries():
    print("10秒后或者5次重试后停止重试")
    raise Exception


if __name__ == '__main__':
    stop_after_3_s_or_5_retries()

运行结果：

可以看到，在下面的结果中，先达到了“最大重试5次”的限制从而结束了函数执行的重试过程。

3、重试前等待（设置相邻函数重试之间的时间间隔）

有些情况下我们并不希望每一次重试抛出错误后，立即开始下一次的重试，譬如爬虫任务中为了更好地伪装我们的程序， tenacity 库中提供了一系列非常实用的函数，配合 retry() 装饰器中的 wait 参数，可以妥善处理相邻重试之间的时间间隔，其中较为实用的主要有以下两种方式：

重试之前等待固定时间：

通过使用 tenacity 库中的 wait_fixed() 函数可以为相邻重试之间设置固定的等待间隔秒数，示例：

from tenacity import retry, wait_fixed


@retry(wait=wait_fixed(2))
def wait_2_s():
    print("每次重试前等待2秒")
    raise Exception


if __name__ == '__main__':
    wait_2_s()

运行结果：

等待随机时间：

除了设置固定的时间间隔外， tenacity 库还可以通过 wait_random() 函数帮助我们为相邻重试设置均匀分布随机数，只需要设置好均匀分布的范围即可：

from tenacity import retry, wait_random


@retry(wait=wait_random(min=1, max=2))
def wait_random_1_to_2_s():
    print("每次重试前等待1-2秒之间")
    raise Exception


if __name__ == '__main__':
    wait_random_1_to_2_s()

运行结果：

等待指数时间：

from tenacity import retry, wait_exponential


@retry(wait=wait_exponential(multiplier=1, min=4, max=10))
def wait_exponential_1():
    print("每次重试等待 2^x * multiplier 秒，x为重试次数，最小4秒，最多10秒")
    raise Exception


if __name__ == '__main__':
    wait_exponential_1()

运行结果：

结合固定和抖动等待：

from tenacity import retry, wait_random, wait_fixed


@retry(wait=wait_fixed(3) + wait_random(0, 2))
def wait_fixed_jitter():
    print("每次重试前等待3到3+2秒之间")
    raise Exception


if __name__ == '__main__':
    wait_fixed_jitter()

运行结果：

链式等待：

from tenacity import retry, wait_fixed, wait_chain


@retry(wait=wait_chain(*[wait_fixed(3) for i in range(3)] +
                        [wait_fixed(7) for i in range(2)] +
                        [wait_fixed(9)]))
def wait_fixed_chained():
    print("前3次等待3秒，接下来2次等待7秒，后面等待9秒")
    raise Exception


if __name__ == '__main__':
    wait_fixed_chained()

运行结果：

4、自定义是否触发重试机制

tenacity 库中 retry() 装饰器的默认策略是当其所装饰的函数执行过程“抛出任何错误”时即进行重试，但有些情况下我们需要的可能是对特定错误类型的捕捉/忽略，亦或是对异常计算结果的捕捉。

捕捉或忽略特定的错误类型：

当函数中抛出的异常类型与 @retry() 装饰器中定义的异常类型相同时则执行重试策略，否则函数执行一次时直接抛出异常。（可以通过 retry_if_exception_type 函数指定的特定类型的异常出现时，任务才重试）

from tenacity import retry, retry_if_exception_type, retry_if_not_exception_type


@retry(retry=retry_if_exception_type(FileExistsError))
def demo_func7():
    raise TimeoutError


@retry(retry=retry_if_not_exception_type(FileNotFoundError))
def demo_func8():
    raise FileNotFoundError


if __name__ == '__main__':
    demo_func7()
    # demo_func8()

运行结果：

自定义函数结果条件判断函数

通过可以编写额外的条件判断函数，配合 tenacity 库中的 retry_if_result() 装饰器，实现对函数的返回结果进行自定义条件判断，返回True时才会触发重试操作：

import random
from tenacity import retry, retry_if_result


@retry(retry=retry_if_result(lambda x: x >= 0.1))
def demo_func9():
    a = random.random()
    print(a)
    return a


# 记录开始时间
demo_func9()

运行结果：

5、对函数的错误重试情况进行统计

被 tenacity 库中的 retry() 装饰的函数，可以通过打印其 retry.statistics 属性查看其历经的错误重试统计记录结果：

import random
from tenacity import retry, retry_if_result


@retry(retry=retry_if_result(lambda x: x >= 0.1))
def demo_func9():
    a = random.random()
    print(a)
    return a


# 记录开始时间
demo_func9()

print(demo_func9.retry.statistics)

运行结果：

6、重试错误后的异常抛出

出现异常后，函数会进行重试，若重试后还是失败，默认情况下，程序最后抛出的异常会变成 RetryError 异常。这样的话会脱离程序的原本目的。

因此可以在 @retry() 装饰器中加一个参数 reraise=True ，使得当函数重试失败后，函数往外抛出的异常还是原来的那个异常。

1）不加 reraise=True 参数

from tenacity import retry, stop_after_attempt


@retry(stop=stop_after_attempt(3))
def task():
    print("task running ... ")
    raise Exception


task()

运行结果：

2）加 reraise=True 参数

from tenacity import retry, stop_after_attempt


@retry(stop=stop_after_attempt(3), reraise=True)
def task():
    print("task running ... ")
    raise Exception


task()

运行结果：

7、在函数重试前执行动作

tenacity 库可以在任务重试前后执行某些动作，这里以加日志为例：

在函数执行之前先执行添加日志的操作，然后再执行函数，然后函数抛出异常后重新执行该函数，然后在重新执行该函数之前再执行添加日志操作，以此类推。。。

from tenacity import retry, stop_after_attempt, before_log
import logging
import sys
 
logging.basicConfig(stream=sys.stderr, level=logging.DEBUG)
logger = logging.getLogger(__name__)
 
@retry(stop=stop_after_attempt(3), before=before_log(logger=logger, log_level=logging.DEBUG))
def task():
    print("task running ... ")
    raise Exception
 
task()

运行结果：

8、在函数重试后执行操作

与函数函数重试之前的操作类似：

import time

from tenacity import retry, stop_after_attempt, after_log
import logging
import sys

logging.basicConfig(stream=sys.stderr, level=logging.DEBUG)
logger = logging.getLogger(__name__)


@retry(stop=stop_after_attempt(3), after=after_log(logger=logger, log_level=logging.DEBUG))
def task():
    print("task running ... ")
    time.sleep(2)
    raise Exception


task()

运行结果：

9、自定义回调函数（当最后一次重试失败后，可以执行一个回调函数）

定义函数最后一次重试仍然失败调用的函数（只在最后一次重试失败时调用），回调函数应该接受一个被调用的参数 retry_state ，该参数包含有关当前重试调用的所有信息。

@retry 装饰器的定义回调函数的参数为： retry_error_callback=函数名（回调函数一般返回最后一次函数重试的函数执行结果）

示例1：

from tenacity import stop_after_attempt, retry, retry_if_result


def return_last_value(retry_state):
    """return the result of the last call attempt"""
    print('执行回调函数')
    print(retry_state.outcome.result())
    return retry_state.outcome.result()


def is_false(value):
    """Return True if value is False"""
    return value is False


# will return False after trying 3 times to get a different result
@retry(stop=stop_after_attempt(3),
       retry_error_callback=return_last_value,
       retry=retry_if_result(is_false))
def eventually_return_false():
    print('函数重试')
    return False


if __name__ == '__main__':
    eventually_return_false()

运行结果：

retry_state 参数是 RetryCallState 类的对象，具有以下属性：

start_time(float) 重试开始时间戳
retry_object(BaseRetrying) 重试对象
fn(callable) 此重试调用包装的函数
args(tuple) 此重试调用包装的函数参数
kwargs(dict) 此重试调用包装的函数的关键字参数
attempt_number(int) 当前尝试次数
outcome(tenacity.FutureorNone) 函数产生的最后结果（结果或异常）
outcome_timestamp(floatorNone) 最后结果的时间戳
idle_for(float) 重试等待时间
next_action(tenacity.RetryActionorNone) 由重试管理器决定的下一步操作

示例2：

from tenacity import retry, stop_after_attempt, retry_if_result


def return_last_value(retry_state):
    print("执行回调函数")
    return retry_state.outcome.result()  # 表示原函数的返回值


def is_false(value):
    print('执行《判断是否进行被装饰函数重试》的函数')
    return value is False


@retry(stop=stop_after_attempt(3),
       retry_error_callback=return_last_value,
       retry=retry_if_result(is_false))
def test_retry():
    print("等待重试.....")
    return False


print(test_retry())

运行结果：

https://blog.csdn.net/djstavaV/article/details/112261899

https://zhuanlan.zhihu.com/p/391812968

https://www.cnblogs.com/wuzhibinsuib/p/13443622.html

posted @ 2022-07-18 15:54 习久性成阅读(1733) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

· python之为函数执行设置超时时间（允许函数执行的最大时间）[python第三方库func_timeout]

· （数据科学学习手札135）tenacity：Python中最强大的错误重试库

· python tenacity 重试库

· Python重试任务模块tenacity

阅读排行：
· 全程不用写代码，我用AI程序员写了一个飞机大战
· DeepSeek 开源周回顾「GitHub 热点速览」
· 记一次.NET内存居高不下排查解决与启示
· 物流快递公司核心技术能力-地址解析分单基础技术分享
· .NET 10首个预览版发布：重大改进与新特性概览！

公告

昵称：习久性成
园龄： 4年1个月
粉丝： 195
关注： 5

+加关注

2025年3月

日

一

二

三

四

五

六

python之第三方库tenacity重试库的详细使用：Tenacity是一个通用的retry库，简化为任何任务加入重试的功能

前言

安装

使用

1、基本重试（无条件重试，重试之间无间隔，报错之后就立马重试）

2、停止重试

设置重试次数：

设置时间限制：

组合多个停止条件：

3、重试前等待（设置相邻函数重试之间的时间间隔）

重试之前等待固定时间：

等待随机时间：

等待指数时间：

结合固定和抖动等待：

链式等待：

4、自定义是否触发重试机制

捕捉或忽略特定的错误类型：

自定义函数结果条件判断函数

5、对函数的错误重试情况进行统计

6、重试错误后的异常抛出

7、在函数重试前执行动作

8、在函数重试后执行操作

9、自定义回调函数（当最后一次重试失败后，可以执行一个回调函数）

公告

搜索

常用链接

随笔分类

随笔档案

阅读排行榜

评论排行榜

推荐排行榜

最新评论