python中retrying的使用

叁歲伎倆 2022-05-27 12:14 369阅读 0赞

循环、重复调用一个方法其实在很多时候都要用到，比如支付，当回调接口有问题时会重复回调，比如集群中主从节点，他们会使用心跳来保证是否宕机等等，在python中有一个retrying模块，提供了重复循环调用的方法和装饰器

首先我们需要手动安装retrying模块

pip install retrying

使用pycharm的自然知道在哪安装吧？附一张图

![70][]

安装完之后我们可以看一下retrying.py文件

这里面有三个对象(Retrying、Attempt、RetryError)和一个装饰器retry

本片文章主要说一下装饰器retry，手下呢，我们看一下Retrying对象的初始化函数

def __init__(self,
                 stop=None, wait=None,
                 stop_max_attempt_number=None,
                 stop_max_delay=None,
                 wait_fixed=None,
                 wait_random_min=None, wait_random_max=None,
                 wait_incrementing_start=None, wait_incrementing_increment=None,
                 wait_exponential_multiplier=None, wait_exponential_max=None,
                 retry_on_exception=None,
                 retry_on_result=None,
                 wrap_exception=False,
                 stop_func=None,
                 wait_func=None,
                 wait_jitter_max=None):
    
        self._stop_max_attempt_number = 5 if stop_max_attempt_number is None else stop_max_attempt_number
        self._stop_max_delay = 100 if stop_max_delay is None else stop_max_delay
        self._wait_fixed = 1000 if wait_fixed is None else wait_fixed
        self._wait_random_min = 0 if wait_random_min is None else wait_random_min
        self._wait_random_max = 1000 if wait_random_max is None else wait_random_max
        self._wait_incrementing_start = 0 if wait_incrementing_start is None else wait_incrementing_start
        self._wait_incrementing_increment = 100 if wait_incrementing_increment is None else wait_incrementing_increment
        self._wait_exponential_multiplier = 1 if wait_exponential_multiplier is None else wait_exponential_multiplier
        self._wait_exponential_max = MAX_WAIT if wait_exponential_max is None else wait_exponential_max
        self._wait_jitter_max = 0 if wait_jitter_max is None else wait_jitter_max

在此删除了一部分代码，主要是看一下\_\_init\_\_中的参数：

stop\_max\_attempt\_number：在停止之前尝试的最大次数，最后一次如果还是有异常则会抛出异常，停止运行，默认为5次

stop\_max\_delay：最大延迟时间，大概意思就是：如果调用的函数出现异常，那么就会重复调用这个函数，最大调用时间，默认为100毫秒

wait\_fixed：两次调用方法期间停留时长, 如果出现异常则会一直重复调用，默认 1000毫秒

wait\_random\_min：在两次调用方法停留时长，停留最短时间，默认为0

wait\_random\_max：在两次调用方法停留时长，停留最长时间，默认为1000毫秒

wait\_incrementing\_increment：每调用一次则会增加的时长，默认 100毫秒

wait\_exponential\_multiplier和wait\_exponential\_max：以指数的形式产生两次retrying之间的停留时间，产生的值为2^previous\_attempt\_number \* wait\_exponential\_multiplier，previous\_attempt\_number是前面已经retry的次数，如果产生的这个值超过了wait\_exponential\_max的大小，那么之后两个retrying之间的停留值都为wait\_exponential\_max

retry\_on\_exception: 指定一个函数，如果此函数返回指定异常，则会重试，如果不是指定的异常则会退出

retry\_on\_result：指定一个函数，如果指定的函数返回True，则重试，否则抛出异常退出

wrap\_exception：参数设置为True/False，如果指定的异常类型，包裹在RetryError中，会看到RetryError和程序抛的Exception error

stop\_func: 每次抛出异常时都会执行的函数，如果和stop\_max\_delay、stop\_max\_attempt\_number配合使用，则后两者会失效

指定的stop\_func会有两个参数：attempts, delay

wait\_func：和stop\_func用法差不多，不多描述

下面给几个例子：

1、只使用@retry，则会一直不停运行

@retry def test_retry():
        try:
            1/0
        except Exception as e:
            print(e)
            raise e
    test_retry()

2、使用stop\_max\_attempt\_number最大运行次数

@retry(stop_max_attempt_number=3)
    def test_stop_max_attempt_number():
        try:
            1/0
        except Exception as e:
            print(e)
            raise e
    test_stop_max_attempt_number()

3、 stop\_max\_delay 设置失败重试的最大时间, 单位毫秒，超出时间，则停止重试

@retry(stop_max_delay=1000)
    def test_stop_max_delay():
        try:
            # sleep(2) print("test")
            1/0
        except Exception as e:
            print(e)
            raise e
    
    test_stop_max_delay()

4、 wait\_fixed 设置失败重试的间隔时间

@retry(wait_fixed=1000)
    def test_wait_fixed():
        try:
            print("test")
            1/0
        except Exception as e:
            print(e)
            raise e
    
    test_wait_fixed()

5、 wait\_random\_min, wait\_random\_max 设置失败重试随机性间隔时间

@retry(wait_random_min=1000,wait_random_max=10000)
    def test_wait_random():
        try:
            print("test")
            1/0
        except Exception as e:
            print(e)
            raise e
    test_wait_random()

6、 wait\_exponential\_multiplier-间隔时间倍数增加，wait\_exponential\_max-最大间隔时间

@retry(wait_exponential_multiplier=1000, wait_exponential_max=10000)
    def test_wait_exponential():
        print("test %d" % int(time()))
        raise Exception
    test_wait_exponential()

7、retry\_on\_exception：指定异常类型，指定的异常类型会重试，不指定的类型，会直接异常退出，wrap\_exception参数设置为True，则其他类型异常，或包裹在RetryError中，会看到RetryError和程序抛的Exception error

def retry_if_io_error(exception):
        print("---------------------------")
        return isinstance(exception, FileNotFoundError)
    
    @retry(retry_on_exception=retry_if_io_error)
    def this_maybe_has_error():
        try:
            print("test")
            with open("aa.txt", 'r') as f:
                f.readlines()
        except FileNotFoundError as e:
            raise FileNotFoundError
    this_maybe_has_error()

此时会重复调用this\_maybe\_has\_error()

def retry_if_io_error(exception):
        print("---------------------------")
        return isinstance(exception, FileNotFoundError)
    @retry(retry_on_exception=retry_if_io_error, wrap_exception=True)
    def test_retry_error():
        print("Retry forever with no wait if an FileNotFoundError occurs, raise any other errors wrapped in RetryError")
        raise Exception('a')
    
    test_retry_error()

只会调用一次即结束

8、retry\_on\_result, 指定要在得到哪些结果的时候去retry，retry\_on\_result传入一个函数对象,在执行get\_result成功后，会将函数的返回值通过形参result的形式传入retry\_if\_result\_none函数中，如果返回值是None那么就进行retry，否则就结束并返回函数值

def retry_if_result_none(result):
        print("retry_if_result_none")
        return result is None
    
    @retry(retry_on_result=retry_if_result_none)
    def get_result():
        print('Retry forever ignoring Exceptions with no wait if return value is None')
        return None
    get_result()

如果retry\_if\_result\_none返回True则会一直循环调用，以上代码会一直循环调用

def retry_if_result_none(result):
        print("retry_if_result_none")
        return result is not None
    
    @retry(retry_on_result=retry_if_result_none)
    def get_result():
        print('Retry forever ignoring Exceptions with no wait if return value is None')
        return None
    get_result()

以上代码只会调用调用一次

9、stop\_func: 每次抛出异常时都会执行的函数，如果和stop\_max\_delay、stop\_max\_attempt\_number配合使用，则后两者会失效

指定的stop\_func会有两个参数：attempts, delay

def stop_func(attempts, delay):
        print("stop_func %d--->%d" % (attempts,delay))
    
    @retry(stop_max_delay=10, stop_func=stop_func)
    def test_stop_func():
        print("test_stop_func")
        raise Exception
    
    test_stop_func()

stop\_max\_delay失去了作用，会一直循环下去，截取一部分结果：

test_stop_func
     stop_func 6849--->185
    test_stop_func
     stop_func 6850--->185
    test_stop_func
     stop_func 6851--->185
    test_stop_func
     stop_func 6852--->185

大家可以自己动手试试，也可以多种情况配合使用，但有些配合有可能导致某些属性失去作用，这个必须要注意

努力成就非凡，请不要在最该奋斗的年纪选择安逸

[70]: /images/20220527/41b505698e3540338229e2b21a7d3e74.png