让你的代码不再“死磕”，这个库就能搞定！

让你的代码不再“死磕”，这个库就能搞定！

背景

在开发过程中，我们经常会遇到一些不可预测的错误，比如网络请求失败、数据库连接超时等。如果程序在遇到这些错误时直接崩溃，不仅会影响用户体验，还会增加维护成本。为了解决这些问题，我们需要一种机制来自动重试失败的操作，直到成功或者达到最大重试次数。retrying库就是这样一个可以帮助我们轻松实现重试功能的Python三方库。

retrying库是什么

retrying是一个Python库，它提供了一个装饰器@retry，可以方便地为函数添加重试逻辑。通过这个装饰器，我们可以在函数执行失败时自动进行重试，而无需手动编写繁琐的循环和条件判断代码。

安装retrying库

由于retrying是一个三方库，我们需要通过pip命令来安装它。在命令行中输入以下命令即可完成安装：

pip install retrying

常用库函数及使用方法

1. 基本重试

Python复制

from retrying import retry

@retry
def unreliable_function():
    # 模拟一个可能会失败的函数
    import random
    if random.random() < 0.5:
        raise Exception("Operation failed!")
    return "Success!"

unreliable_function()

• @retry：这是一个装饰器，用于为函数添加重试逻辑。

• unreliable_function()：被装饰的函数，在执行失败时会自动重试。

2. 设置最大重试次数

Python复制

@retry(stop_max_attempt_number=3)
def function_with_max_retries():
    # 模拟一个可能会失败的函数
    import random
    if random.random() < 0.5:
        raise Exception("Operation failed!")
    return "Success!"

function_with_max_retries()

• stop_max_attempt_number=3：设置最大重试次数为3次。

3. 设置重试间隔

Python复制

@retry(wait_fixed=1000)
def function_with_fixed_wait():
    # 模拟一个可能会失败的函数
    import random
    if random.random() < 0.5:
        raise Exception("Operation failed!")
    return "Success!"

function_with_fixed_wait()

• wait_fixed=1000：设置每次重试之间的固定等待时间为1000毫秒。

4. 设置指数退避重试间隔

Python复制

@retry(wait_exponential_multiplier=1000, wait_exponential_max=10000)
def function_with_exponential_backoff():
    # 模拟一个可能会失败的函数
    import random
    if random.random() < 0.5:
        raise Exception("Operation failed!")
    return "Success!"

function_with_exponential_backoff()

• wait_exponential_multiplier=1000：指数退避的乘数因子，用于计算每次重试的等待时间。

• wait_exponential_max=10000：设置指数退避的最大等待时间为10000毫秒。

5. 捕获特定异常进行重试

Python复制

@retry(stop_max_attempt_number=3, retry_on_exception=lambda e: isinstance(e, ValueError))
def function_retry_on_value_error():
    # 模拟一个可能会抛出ValueError的函数
    import random
    if random.random() < 0.5:
        raise ValueError("Value error occurred!")
    return "Success!"

function_retry_on_value_error()

• retry_on_exception=lambda e: isinstance(e, ValueError)：设置只有当抛出ValueError异常时才进行重试。

实际场景中的应用

场景一：网络请求重试

Python复制

import requests
from retrying import retry

@retry(stop_max_attempt_number=3, wait_fixed=1000)
def fetch_data_from_api(url):
    response = requests.get(url)
    if response.status_code != 200:
        raise Exception("Failed to fetch data from API")
    return response.json()

data = fetch_data_from_api("https://api.example.com/data")
print(data)

• 在这个场景中，我们使用retry装饰器为网络请求函数添加了重试逻辑，确保在请求失败时自动重试3次，每次重试间隔1000毫秒。

场景二：数据库连接重试

Python复制

import psycopg2
from retrying import retry

@retry(stop_max_attempt_number=5, wait_exponential_multiplier=500, wait_exponential_max=5000)
def connect_to_database():
    conn = psycopg2.connect(
        dbname="your_dbname",
        user="your_user",
        password="your_password",
        host="your_host"
    )
    return conn

database_connection = connect_to_database()

• 在连接数据库的场景中，我们设置了指数退避的重试策略，最大重试次数为5次，初始等待时间为500毫秒，最大等待时间为5000毫秒。

场景三：文件读取重试

Python复制

from retrying import retry

@retry(stop_max_attempt_number=3, wait_fixed=2000)
def read_file(filename):
    with open(filename, 'r') as file:
        return file.read()

file_content = read_file("example.txt")
print(file_content)

• 当读取文件可能失败时，我们添加了重试逻辑，确保在文件读取失败时自动重试3次，每次重试间隔2000毫秒。

场景四：外部服务调用重试

Python复制

from retrying import retry

@retry(stop_max_attempt_number=4, retry_on_exception=lambda e: isinstance(e, TimeoutError))
def call_external_service():
    # 模拟调用外部服务
    import random
    if random.random() < 0.3:
        raise TimeoutError("External service call timed out!")
    return "Service call successful!"

service_result = call_external_service()
print(service_result)

• 在调用外部服务时，我们设置了重试策略，只在遇到TimeoutError异常时进行重试，最大重试次数为4次。

场景五：并发任务重试

Python复制

from retrying import retry
from concurrent.futures import ThreadPoolExecutor

@retry(stop_max_attempt_number=3, wait_fixed=500)
def execute_concurrent_task(task_id):
    # 模拟并发任务执行
    import random
    if random.random() < 0.4:
        raise Exception(f"Task {task_id} failed!")
    return f"Task {task_id} completed successfully!"

with ThreadPoolExecutor(max_workers=3) as executor:
    futures = [executor.submit(execute_concurrent_task, i) for i in range(5)]
    for future in futures:
        print(future.result())

• 在并发任务执行的场景中，我们为每个任务添加了重试逻辑，确保任务在失败时自动重试3次，每次重试间隔500毫秒。

常见bug及解决方案

错误一：未正确捕获异常导致重试失败

错误信息 ：

Exception: Operation failed!

代码实例 ：

Python复制

from retrying import retry

@retry(stop_max_attempt_number=3)
def function_without_proper_exception_handling():
    # 模拟一个可能会失败的函数
    import random
    if random.random() < 0.5:
        raise ValueError("Value error occurred!")
    return "Success!"

function_without_proper_exception_handling()

解决方案 ： 在retry装饰器中指定retry_on_exception参数，明确捕获特定异常：

Python复制

@retry(stop_max_attempt_number=3, retry_on_exception=lambda e: isinstance(e, ValueError))
def function_with_proper_exception_handling():
    # 模拟一个可能会失败的函数
    import random
    if random.random() < 0.5:
        raise ValueError("Value error occurred!")
    return "Success!"

function_with_proper_exception_handling()

错误二：重试间隔设置不合理导致性能问题

错误信息 ：

Operation took too long to complete.

代码实例 ：

Python复制

from retrying import retry

@retry(stop_max_attempt_number=5, wait_fixed=5000)
def function_with_long_wait():
    # 模拟一个可能会失败的函数
    import random
    if random.random() < 0.5:
        raise Exception("Operation failed!")
    return "Success!"

function_with_long_wait()

解决方案 ： 根据实际场景调整重试间隔，例如使用指数退避策略：

Python复制

@retry(stop_max_attempt_number=5, wait_exponential_multiplier=500, wait_exponential_max=5000)
def function_with_reasonable_wait():
    # 模拟一个可能会失败的函数
    import random
    if random.random() < 0.5:
        raise Exception("Operation failed!")
    return "Success!"

function_with_reasonable_wait()

错误三：未正确设置最大重试次数导致无限重试

错误信息 ：

Program is stuck in an infinite retry loop.

代码实例 ：

Python复制

from retrying import retry

@retry
def function_without_max_attempts():
    # 模拟一个可能会失败的函数
    import random
    if random.random() < 0.5:
        raise Exception("Operation failed!")
    return "Success!"

function_without_max_attempts()

解决方案 ： 始终设置stop_max_attempt_number参数来限制最大重试次数：

Python复制

@retry(stop_max_attempt_number=3)
def function_with_max_attempts():
    # 模拟一个可能会失败的函数
    import random
    if random.random() < 0.5:
        raise Exception("Operation failed!")
    return "Success!"

function_with_max_attempts()

总结

retrying库为Python开发者提供了一种简单而强大的方式来处理函数执行失败的情况。通过使用@retry装饰器，我们可以轻松地为函数添加重试逻辑，提高程序的健壮性和可靠性。在实际应用中，我们可以根据不同的场景灵活设置重试次数、重试间隔以及捕获的异常类型，以满足各种需求。掌握retrying库的使用方法，将使我们在处理不可预测的错误时更加从容，让代码不再“死磕”，而是能够智能地进行重试，直到成功或者达到预设的终止条件。

如果你觉得文章还不错，请大家 点赞、分享、留言 下，因为这将是我持续输出更多优质文章的最强动力！