Python脚本怎么实现出错后自动重复执行

唐可
唐可
发布时间:2026-11-17| 4人浏览过
原创

全面讲解Python脚本出错后自动重复执行的实现方法,从内部try-except循环捕获、指数退避装饰器、tenacity工业级重试库,到外部Shell与Systemd进程守护,提供完整代码与选型指南。

在网络请求、数据抓取、文件批处理或后台长时间运行的任务中,Python 脚本经常会因为临时网络断开、服务端限流、超时等非致命问题发生异常。解决这类问题有两种截然不同的控制层级:一种是在 Python 代码内部针对易错函数执行循环重试,另一种是在代码外部借助系统工具对崩溃退出的进程进行自动拉起。本文将依次讲解原生循环捕获、指数退避策略封装、工业级第三方库应用以及操作系统级外部守护的具体实现方法与最佳实践。

Python脚本怎么实现出错后自动重复执行
图 0:Python 出错自动重试的三层技术方案矩阵

一、整体架构:代码内重试与进程级守护

在设计容错机制前,首先需要区分两种错误表现:

  • 瞬时业务异常:网络抖动、目标服务器返回 502/503、数据库读写锁冲突。此时 Python 进程本身仍然健康,只需捕获特定异常并重新调用对应代码块。
  • 致命进程崩溃:内存超限触发系统 OOM Killer、C 扩展段错误(Segmentation Fault)、未捕获的全局顶层异常导致解释器退出。代码内部的 try...except 无法在进程已经消亡后生效,必须依赖操作系统级外部工具重新拉起。
Python脚本怎么实现出错后自动重复执行
图 1:Python 故障自动恢复的双层架构关系图

二、方案一:原生 while 循环与 try...except 捕获

这是最基础、最直接的重试方式。无需引入任何第三方库,仅利用 Python 内置的控制流即可完成。核心思路是使用计数器限制重试上限,在 except 块中拦截指定异常并休眠,重试成功时直接 break 或 return。

1. 完整实现代码

import time
import requests

def request_with_retry(url: str, max_retries: int = 3, delay: float = 2.0) -> dict:
    """
    通过循环机制实现网络请求出错自动重试
    """
    attempt = 1
    while attempt <= max_retries:
        try:
            print(f"正在进行第 {attempt} 次请求: {url}")
            response = requests.get(url, timeout=5)
            response.raise_for_status()  # 如果状态码是 4xx 或 5xx 则抛出 HTTPError
            return response.json()
        except (requests.exceptions.RequestException, requests.exceptions.Timeout) as exc:
            print(f"第 {attempt} 次尝试发生异常: {exc}")
            if attempt == max_retries:
                print("已达到最大重试次数上限,放弃重试并向上抛出异常。")
                raise exc
            print(f"等待 {delay} 秒后发起下一次重试...")
            time.sleep(delay)
            attempt += 1

# 示例调用
if __name__ == "__main__":
    try:
        data = request_with_retry("https://api.example.com/data", max_retries=3, delay=1.5)
        print("最终成功获取数据:", data)
    except Exception as err:
        print("流程失败,错误详情:", err)
Python脚本怎么实现出错后自动重复执行
图 2:原生循环捕获的操作步骤与控制执行流
注意事项:切忌使用没有任何参数的 except: 或直接捕获顶层 BaseException。这会拦截 KeyboardInterrupt(用户在控制台按 Ctrl+C 终止)和 SystemExit(脚本正常退出指令),导致脚本无法被手动停止。应明确声明要捕获的具体异常类元组。

三、方案二:指数退避与通用装饰器封装

如果在代码中有多处操作都需要重试,使用普通的 while 循环会导致业务逻辑代码中充斥大量重复的样板代码。此外,固定时间间隔重试(如每次都等 2 秒)在分布式系统或高并发场景下存在“雷鸣群涌”(Thundering Herd)隐患:当代下游服务暂时故障时,所有客户端以固定步调同步重试,会瞬间打垮正在恢复的下游服务器。

为了解决这个问题,工程上通常采用指数退避(Exponential Backoff)结合随机抖动(Jitter)策略,并将其封装为通用的 Python 装饰器。

Python脚本怎么实现出错后自动重复执行
图 3:三种重试退避算法的时序特征与适用场景对比

2. 自定义通用重试装饰器

使用 Python 内置的 functools.wraps 可以实现一个开箱即用的重试装饰器:

import time
import random
import functools
from typing import Tuple, Type

def retry(
    max_retries: int = 3,
    initial_delay: float = 1.0,
    backoff_factor: float = 2.0,
    jitter: bool = True,
    exceptions: Tuple[Type[Exception], ...] = (Exception,)
):
    """
    带指数退避和抖动的重试装饰器
    """
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            delay = initial_delay
            for attempt in range(1, max_retries + 1):
                try:
                    return func(*args, **kwargs)
                except exceptions as exc:
                    if attempt == max_retries:
                        print(f"[{func.__name__}] 达到最大重试次数 {max_retries},抛出最终异常。")
                        raise exc
                    
                    # 计算实际等待时间(是否加入随机扰动)
                    sleep_time = delay * (1 + random.uniform(0.1, 0.5)) if jitter else delay
                    print(f"[{func.__name__}] 第 {attempt} 次失败: {exc},将在 {sleep_time:.2f} 秒后重试...")
                    time.sleep(sleep_time)
                    delay *= backoff_factor
        return wrapper
    return decorator

# 使用装饰器修饰易错函数
@retry(max_retries=4, initial_delay=1.0, backoff_factor=2.0, exceptions=(IOError, ConnectionError))
def sync_remote_storage(file_id: str):
    print(f"正在同步文件 {file_id} 到云存储...")
    # 模拟偶发性网络中断
    if random.random() < 0.7:
        raise ConnectionError("远端存储连接被重置")
    return "SUCCESS"

if __name__ == "__main__":
    result = sync_remote_storage("DOC-2026-X1")
    print("操作结果:", result)

四、方案三:使用成熟重试库 tenacity(工业级标准)

在生产级项目中,自行封装的装饰器往往难以全面满足各种复杂场景(如:根据返回值判断是否重试、限制总超时时间、重试前后的回调通知、异步支持等)。社区事实上的重试标准是 tenacity 库。

1. 安装依赖

pip install tenacity

2. 核心功能与示例代码

tenacity 采用声明式的配置语法,将重试条件、等待时长、终止条件高度模块化组合:

import requests
from tenacity import (
    retry,
    stop_after_attempt,
    stop_after_delay,
    wait_exponential,
    wait_random,
    retry_if_exception_type,
    before_sleep_log
)
import logging

# 配置日志记录器
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("RetryLogger")

@retry(
    # 终止条件:最多重试 5 次,或总耗时超过 30 秒时停止
    stop=(stop_after_attempt(5) | stop_after_delay(30)),
    # 等待策略:指数退避,基数为 2 秒,最大等待 10 秒,外加 0~1 秒随机抖动
    wait=(wait_exponential(multiplier=1, min=2, max=10) + wait_random(0, 1)),
    # 仅在遇到特定网络错误时重试,遇到逻辑错误(如参数错误 ValueError)直接失败
    retry=retry_if_exception_type((requests.exceptions.RequestException, TimeoutError)),
    # 每次重试休眠前自动输出规范日志
    before_sleep=before_sleep_log(logger, logging.WARNING),
    # 达到上限时重新抛出原始异常,而非包裹后的 RetryError
    reraise=True
)
def fetch_user_profile(user_id: int):
    url = f"https://api.example.com/users/{user_id}"
    resp = requests.get(url, timeout=3)
    resp.raise_for_status()
    return resp.json()

五、方案四:外部进程守护(防范脚本崩溃退出)

当 Python 脚本遇到未被捕获的致命错误退出,或者由于内存泄漏触发 Linux OOM Killer 时,Python 内部的所有重试代码都会随着进程销毁而终止。此时必须在进程外部配置守护机制。

1. 简易 Shell 启动循环

在 Linux/macOS 终端中,可以直接编写一个简易的 bash 脚本来包裹 Python 程序的执行:

#!/usr/bin/env bash
# run_worker.sh: 外部进程守护脚本

PYTHON_BIN="python3"
SCRIPT_PATH="main.py"
RETRY_DELAY=5

echo "开始启动外部守护监控..."

while true; do
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] 启动目标脚本: $SCRIPT_PATH"
    $PYTHON_BIN $SCRIPT_PATH
    EXIT_CODE=$?

    # 判断退出代码
    if [ $EXIT_CODE -eq 0 ]; then
        echo "[$(date '+%Y-%m-%d %H:%M:%S')] 脚本正常退出 (Code 0),守护结束。"
        break
    else
        echo "[$(date '+%Y-%m-%d %H:%M:%S')] 脚本异常退出 (Code $EXIT_CODE),将在 ${RETRY_DELAY} 秒后重新启动..."
        sleep $RETRY_DELAY
    fi
done

2. Linux Systemd 系统服务(生产环境标准)

在 Linux 服务器上,将脚本注册为 Systemd 服务是最高效、稳定的方案,系统会在脚本异常退出时自动重新拉起,且支持开机自启和日志集中管理。

创建服务文件 /etc/systemd/system/py-worker.service:

[Unit]
Description=Python 自动化工作进程自动重试守护
After=network.target

[Service]
Type=simple
User=www-data
WorkingDirectory=/var/www/app
ExecStart=/usr/bin/python3 /var/www/app/main.py

# 异常退出时自动重启(遇到 exit 0 则不重启)
Restart=on-failure
# 重启前休眠间隔
RestartSec=5s

# 限制频繁重启(如果 30 秒内重启超过 5 次则暂停,防止死循环刷爆系统资源)
StartLimitIntervalSec=30
StartLimitBurst=5

[Install]
WantedBy=multi-user.target

启用并启动服务:

sudo systemctl daemon-reload
sudo systemctl enable py-worker.service
sudo systemctl start py-worker.service
sudo systemctl status py-worker.service

六、生产落地关键注意事项

  1. 操作幂等性(Idempotency):重试只适用于具有幂等性特征的操作(如读取数据 GET、查询接口)。如果操作涉及扣减余额、发送邮件、插入订单等非幂等行为,必须在服务端使用唯一业务流水号(Idempotency Key)防重,否则盲目重试会导致数据重复创建。
  2. 防范无限死循环:任何重试都必须设置硬性的上限限制(如最大次数或最大超时时间)。如果一个问题是由于参数错误(如 400 Bad Request 或鉴权失败 401/403)引起的,重试一百次也不会成功,只会白白消耗计算资源。
  3. 资源释放与连接复用:在 try...except 块中打开的文件、数据库游标或网络连接,必须在 finally 块中妥善关闭,或使用 with 上下文管理器,防止重试过程中句柄泄漏导致系统文件描述符耗尽。
  4. 告警埋点与日志:每一次重试都应记录告警级别日志(Warning),在达到最大次数彻底失败时,必须记录带有完整堆栈信息的致命日志(Error/Critical),并接入邮件、钉钉或企业微信告警通道。

七、总结与选型决策指南

Python脚本怎么实现出错后自动重复执行
图 4:Python 脚本出错重试技术选型全景路线图
方案类型 典型工具/方法 适用场景 优点 缺点/限制
原生代码循环 while + try...except 简单抓取脚本、临时单点逻辑 零依赖,语法简单直观 重试逻辑与业务混杂,难以复用
策略装饰器 自定义 @retry 多函数需重试、需指数退避 解耦业务与容错逻辑,易维护 需要维护自定义装饰器代码
专用重试库 tenacity 生产级服务、复杂条件过滤 策略完备、声明式语法、支持异步 需要引入额外的第三方包依赖
外部守护工具 Systemd / Shell 常驻后台任务、防进程崩溃退出 进程死亡自动重启,托底保障可靠 需要系统运维配置权限,开销较高
相关专题:

免责声明:本文内容仅供参考,不代表本站观点。转载或引用请注明出处。

Python 相关产品和应用

全部下载
Selenium

Selenium

4.51.0 · Windows

用于浏览器自动化和 Web 测试的 Python 工具。

scikit-learn

scikit-learn

1.9.1 · Windows

常用 Python 机器学习算法与模型评估工具库。

Black

Black

26.10.1 · Windows

强调一致性的 Python 自动代码格式化工具。

Ruff

Ruff

0.17.1 · macOS

由 Rust 编写的高速 Python 代码检查和格式化工具。

pytest

pytest

9.1.1 · Windows

简洁而强大的 Python 自动化测试框架。

FastAPI

FastAPI

0.146.0 · Windows

高性能 Python API 框架,支持类型提示和自动接口文档。

Flask

Flask

3.1.3 · Windows

轻量灵活的 Python Web 应用框架。

Django

Django

6.1.2 · Windows

成熟的 Python Web 框架,适合构建内容站点和业务系统。

Spyder

Spyder

6.1.7 · Windows

面向科学计算与数据分析的 Python 集成开发环境。

SciPy

SciPy

1.18.1 · Windows

面向科学、工程和技术计算的 Python 算法库。