Python之tenacity中的retry机制
1、场景：
使用Python处理业务时，往往会调用到其他接口，比如调用WebService，调用HTTP接口，也会连接数据库，连接Redis等，这些场景都会由于网络原因、并发数量过大、用户名密码错误等问题，导致调用失败，程序抛出异常。此时我们需要进行retry处理。
2、一般retry写法
一般retry写法，使用while或者for循环，贴个伪代码看看即可，这种大家都能写出来。
3、推荐使用第三方库tenacity中的retry装饰器
使用第三方库tenacity中的retry装饰器来实现重试，这个retry装饰器比较通用，复用性比较好，也能根据多种场景来判断是否重试。
-
安装
pypi链接
https://pypi.org/project/tenacity/
安装命令
python -m pip install tenacity -
函数中抛出异常就会重试,一直重试到没有异常抛出
import random
from tenacity import retry # 导入retry装饰器
@retry # 函数中抛出异常就会重试,一直重试到没有异常抛出
def test_retry(name, age):
"""
假装有参数,一个是name姓名,一个是age年龄
随机一个0-10的数,随机数小于max_number就抛出异常
:param name:姓名
:param age:年龄
:return:随机数
"""
number = random.randint(0, 10)
max_number = 5
if number < max_number:
msg = f'随机数字小于:{max_number}, 随机数:{number}'
print(msg)
raise Exception(msg)
else:
msg = f'随机数不小于:{max_number}, 随机数:{number}'
print(msg)
return number
if __name__ == '__main__':
ret = test_retry('name', 23)
print(f'ret:{ret}')
-
函数中抛出异常就会重试,一直重试到没有异常抛出,重试前会等wait秒
import random
from tenacity import *
@retry(wait=wait_fixed(2)) # 函数中抛出异常就会重试,一直重试到没有异常抛出,重试前会等wait秒
def test_retry(name, age):
"""
假装有参数,一个是name姓名,一个是age年龄
随机一个0-10的数,随机数小于max_number就抛出异常
:param name:姓名
:param age:年龄
:return:随机数
"""
number = random.randint(0, 10)
max_number = 5
if number < max_number:
msg = f'随机数字小于:{max_number}, 随机数:{number}'
print(msg)
raise Exception(msg)
else:
msg = f'随机数不小于:{max_number}, 随机数:{number}'
print(msg)
return number
if __name__ == '__main__':
now = time.time()
ret = test_retry('name', 23)
print(f'ret:{ret}')
end = time.time()
print(f'用时:{end - now}秒')
-
函数中抛出异常就会重试,重试stop次就不重试了,重试失败，会抛出异常
import random
from tenacity import *
@retry(stop=stop_after_attempt(2))
# 函数中抛出异常就会重试,重试stop次就不重试了,重试失败，会抛出异常
def test_retry(name, age):
"""
假装有参数,一个是name姓名,一个是age年龄
随机一个0-10的数,随机数小于max_number就抛出异常
:param name:姓名
:param age:年龄
:return:随机数
"""
number = random.randint(0, 10)
max_number = 5
if number < max_number:
msg = f'随机数字小于:{max_number}, 随机数:{number}'
print(msg)
raise Exception(msg)
else:
msg = f'随机数不小于:{max_number}, 随机数:{number}'
print(msg)
return number
if __name__ == '__main__':
try:
ret = test_retry('name', 23)
print(f'ret:{ret}')
except Exception as e:
print(f'重试次数用完后,捕获到的异常:{e}')
pass
-
函数中抛出异常就会重试,重试stop秒就不重试了,重试失败，会抛出异常
import random
from tenacity import *
@retry(stop=stop_after_delay(2))
# 函数中抛出异常就会重试,重试stop秒就不重试了,重试失败，会抛出异常
def test_retry(name, age):
"""
假装有参数,一个是name姓名,一个是age年龄
随机一个0-10的数,随机数小于max_number就抛出异常
:param name:姓名
:param age:年龄
:return:随机数
"""
number = random.randint(0, 10)
max_number = 5
time.sleep(2)
if number < max_number:
msg = f'随机数字小于:{max_number}, 随机数:{number}'
print(msg)
raise Exception(msg)
else:
msg = f'随机数不小于:{max_number}, 随机数:{number}'
print(msg)
return number
if __name__ == '__main__':
try:
ret = test_retry('name', 23)
print(f'ret:{ret}')
except Exception as e:
print(f'重试时间超时后,捕获到的异常:{e}')
pass
-
函数中抛出异常就会重试,重试stop秒后或重试stop次后就不重试了,重试失败，会抛出异常
import random
from tenacity import *
@retry(stop=(stop_after_delay(4) | stop_after_attempt(2)))
# 函数中抛出异常就会重试,重试stop秒后或重试stop次后就不重试了,重试失败，会抛出异常
def test_retry(name, age):
"""
假装有参数,一个是name姓名,一个是age年龄
随机一个0-10的数,随机数小于max_number就抛出异常
:param name:姓名
:param age:年龄
:return:随机数
"""
number = random.randint(0, 10)
max_number = 7
time.sleep(2)
if number < max_number:
msg = f'随机数字小于:{max_number}, 随机数:{number}'
print(msg)
raise Exception(msg)
else:
msg = f'随机数不小于:{max_number}, 随机数:{number}'
print(msg)
return number
if __name__ == '__main__':
try:
ret = test_retry('name', 23)
print(f'ret:{ret}')
except Exception as e:
print(f'重试时间超时或次数超过后,捕获到的异常:{e}')
pass
-
根据捕获到的异常类型判断是否需要retry
import random
from tenacity import *
@retry(retry=retry_if_exception_type(IOError))
# 函数中抛出异常且异常类型是retry类型就会重试,其他类型会抛出异常
def test_retry(name, age):
"""
假装有参数,一个是name姓名,一个是age年龄
随机一个0-10的数,随机数小于max_number就抛出异常
:param name:姓名
:param age:年龄
:return:随机数
"""
number = random.randint(0, 10)
max_number = 7
if number < max_number:
msg = f'随机数字小于:{max_number}, 随机数:{number}'
print(msg)
if random.randint(0, 1):
print('不应该被捕获到,会进入retry逻辑')
raise IOError(msg) # 测试抛出不同类型的异常,是否会进入retry逻辑,
else:
print('应该被捕获到,不会进入retry逻辑')
raise Exception('Exception msg') # 测试抛出不同类型的异常,是否会进入retry逻辑
else:
msg = f'随机数不小于:{max_number}, 随机数:{number}'
print(msg)
return number
if __name__ == '__main__':
try:
ret = test_retry('name', 23)
print(f'ret:{ret}')
except Exception as e:
print(f'捕获到的异常信息:{e}')
print(f'捕获到的异常类型:{type(e)}')
pass
-
解析返回值来决定是否需要retry
import random
from tenacity import *
def check_return_info(return_info):
# 检查函数的返回值
if return_info == 1:
return True # 返回True会触发retry
else:
return False # 返回False不会触发retry
@retry(retry=retry_if_result(check_return_info))
# 函数返回值进入check_return_info函数检查，如果check_return_info函数返回True则retry,否则不retry
# 一般用于函数中不会抛异常的情况,直接根据返回值来判断是否需要retry
# 如果函数中抛出异常,也不会进入retry,直接会抛出异常,因为抛出了异常,就无法触发return语句，也就进不去check_return_info函数,也就不会retry
def test_retry(name, age):
"""
假装有参数,一个是name姓名,一个是age年龄
随机一个0-10的数,随机数小于max_number就抛出异常
:param name:姓名
:param age:年龄
:return:随机数
"""
number = random.randint(0, 10)
max_number = 7
if number < max_number:
msg = f'随机数字小于:{max_number}, 随机数:{number}'
print(msg)
# raise Exception(msg)
return 1
else:
msg = f'随机数不小于:{max_number}, 随机数:{number}'
print(msg)
return 0
if __name__ == '__main__':
try:
ret = test_retry('name', 23)
print(f'ret:{ret}')
except Exception as e:
print(f'捕获到的异常信息:{e}')
print(f'捕获到的异常类型:{type(e)}')
pass
-
抛出原来的异常信息(重试失败后，默认抛出RetryError)
import random
from tenacity import *
@retry(stop=stop_after_attempt(2), reraise=True)
# 函数中抛出异常就会重试,重试stop次就不重试了,此时失败，会抛出异常
# 当出现异常后，tenacity 会进行重试，若重试后还是失败，默认情况下，往上抛出的异常会变成 RetryError，而不是最根本的原因。
# 因此可以加一个参数（reraise=True),使得当重试失败后，往外抛出的异常还是原来的那个。
def test_retry(name, age):
"""
假装有参数,一个是name姓名,一个是age年龄
随机一个0-10的数,随机数小于max_number就抛出异常
:param name:姓名
:param age:年龄
:return:随机数
"""
number = random.randint(0, 10)
max_number = 5
if number < max_number:
msg = f'随机数字小于:{max_number}, 随机数:{number}'
print(msg)
raise Exception(msg)
else:
msg = f'随机数不小于:{max_number}, 随机数:{number}'
print(msg)
return number
if __name__ == '__main__':
try:
ret = test_retry('name', 23)
print(f'ret:{ret}')
except Exception as e:
print(f'重试次数用完后,捕获到的异常:{e}')
pass
-
重试失败后的回调函数
import random
from tenacity import *
def callback(return_object):
print(f'return_object:{return_object}')
print(f'return_object type:{type(return_object)}')
print('我是回调函数哟')
print(vars(return_object))
@retry(stop=stop_after_attempt(1), reraise=True, retry_error_callback=callback)
# retry依旧失败后,执行回调函数callback
def test_retry(name, age):
"""
假装有参数,一个是name姓名,一个是age年龄
随机一个0-10的数,随机数小于max_number就抛出异常
:param name:姓名
:param age:年龄
:return:随机数
"""
number = random.randint(0, 10)
max_number = 5
if number < max_number:
msg = f'随机数字小于:{max_number}, 随机数:{number}'
print(msg)
raise Exception(msg)
else:
msg = f'随机数不小于:{max_number}, 随机数:{number}'
print(msg)
return number
if __name__ == '__main__':
try:
ret = test_retry('name', 23)
print(f'ret:{ret}')
except Exception as e:
print(f'重试次数用完后,捕获到的异常:{e}')
pass
-
以上的用法可以合在一起使用，例如
import random
from tenacity import *
@retry(stop=(stop_after_attempt(2) or stop_after_delay(2)), retry=retry_if_exception_type(IOError), wait=wait_fixed(2),
reraise=True)
# 函数中抛出异常就会重试,重试stop次就不重试了,此时失败，会抛出异常
# 函数中抛出异常就会重试,重试stop秒就不重试了,此时失败，会抛出异常
# 函数中抛出异常且异常类型是retry类型就会重试,其他类型会抛出异常
# 重试中等待wait秒
# 当出现异常后，tenacity 会进行重试，若重试后还是失败，默认情况下，往上抛出的异常会变成 RetryError，而不是最根本的原因。
# 因此可以加一个参数（reraise=True),使得当重试失败后，往外抛出的异常还是原来的那个。
def test_retry(name, age):
"""
假装有参数,一个是name姓名,一个是age年龄
随机一个0-10的数,随机数小于max_number就抛出异常
:param name:姓名
:param age:年龄
:return:随机数
"""
number = random.randint(0, 10)
max_number = 8
if number < max_number:
msg = f'随机数字小于:{max_number}, 随机数:{number}'
print(msg)
raise IOError(msg)
else:
msg = f'随机数不小于:{max_number}, 随机数:{number}'
print(msg)
return number
if __name__ == '__main__':
try:
ret = test_retry('name', 23)
print(f'ret:{ret}')
except Exception as e:
print(f'重试次数用完后,捕获到的异常:{e}')
pass
