python爬虫多次请求超时的几种重试方法(6种)

1. 前言

在爬虫的过程中，多次请求错误是一个常见的问题。这可能是由于某些原因导致服务器无法及时响应，也可能是由于网站的反爬虫机制使得您的爬虫被禁止访问。为了解决这个问题，我们可以使用一些方法进行重试，以确保我们的爬虫可以顺利地运行。本文将介绍一些重试方法，用于处理多次请求超时的问题。

2. 重试方法

2.1. 多次请求

最简单的重试方法是多次请求。当您的爬虫遇到超时问题时，您可以让它多次尝试请求，直到成功为止。以下是一个示例函数，它将尝试5次请求：

import requests
def retry_request(url, try_times=5):
    for i in range(try_times):
        try:
            response = requests.get(url)
            if response.status_code != 200:
                raise Exception("Failed to get page")
            return response
        except (requests.exceptions.RequestException, Exception):
            pass
    raise Exception("Failed after multiple tries")

上面的代码中，我们定义了一个retry_request函数，它接受一个URL和一个可选的try_times参数。这个函数会尝试try_times次请求，并在所有尝试都失败后抛出异常。如果请求成功返回了响应，则该函数将立即返回该响应。

2.2. 等待时间增加

如果您的爬虫频繁地超时，那么您可以尝试增加等待时间。这可以让您的程序有足够的时间等待服务器响应。以下是一个示例函数，它使用指数退避来增加等待时间：

import requests
import time
def wait_retry_request(url, try_times=5, min_wait=1, max_wait=64):
    for i in range(try_times):
        try:
            response = requests.get(url)
            if response.status_code != 200:
                raise Exception("Failed to get page")
            return response
        except (requests.exceptions.RequestException, Exception):
            pass
        wait_time = min_wait * 2 ** i
        if wait_time > max_wait:
            wait_time = max_wait
        time.sleep(wait_time)
    raise Exception("Failed after multiple tries")

上面的代码中，我们定义了一个wait_retry_request函数，它与retry_request函数类似，但它使用指数退避算法来增加等待时间。这个函数接受额外的min_wait和max_wait参数，它们分别指定了最小和最大等待时间。如果等待时间超过了max_wait，则等待时间将保持不变。

2.3. 增加User-Agent

有些网站会禁止不良的爬虫程序，可以尝试添加User-Agent来伪装为浏览器。以下是一个示例函数，它使用随机User-Agent来请求页面：

import requests
import random
def random_user_agent():
    user_agents = [
        "Mozilla/5.0 (Windows NT 6.1; WOW64; rv:54.0) Gecko/20100101 Firefox/54.0",
        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3",
        "Mozilla/5.0 (Windows NT 6.1; WOW64; Trident/7.0; AS; rv:11.0) like Gecko",
        "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/51.0.2704.103 Safari/537.36",
        "Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3",
        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/50.0.2661.102 Safari/537.36",
        "Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/51.0.2704.103 Safari/537.36 Edge/14.14393",
    ]
    return random.choice(user_agents)
def user_agent_retry_request(url, try_times=5):
    for i in range(try_times):
        try:
            headers = {"User-Agent": random_user_agent()}
            response = requests.get(url, headers=headers)
            if response.status_code != 200:
                raise Exception("Failed to get page")
            return response
        except (requests.exceptions.RequestException, Exception):
            pass
    raise Exception("Failed after multiple tries")

这个代码中，我们定义了一个random_user_agent函数，它返回预定义的User-Agent列表中的一个随机值。然后，我们修改user_agent_retry_request函数以使用随机的User-Agent来请求页面。这个函数与retry_request函数类似，但它允许使用随机的User-Agent来请求页面。

2.4. IP代理

有些网站会禁止某些IP地址访问，这时候可以使用IP代理服务器来突破限制。使用IP代理可以让您的爬虫程序使用不同的IP地址访问目标网站，每次访问时，都可以随机选择代理服务器。以下是一个示例函数，它使用IP代理来请求页面：

import requests
import random
def random_proxy():
    proxies = [
        "http://10.10.1.10:3128",
        "http://192.168.0.1:8080",
        "http://proxy.example.com",
    ]
    return random.choice(proxies)
def proxy_retry_request(url, try_times=5):
    for i in range(try_times):
        try:
            proxy = {"http": random_proxy()}
            response = requests.get(url, proxies=proxy)
            if response.status_code != 200:
                raise Exception("Failed to get page")
            return response
        except (requests.exceptions.RequestException, Exception):
            pass
    raise Exception("Failed after multiple tries")

这个代码中，我们定义了一个random_proxy函数，它返回预定义的代理服务器列表中的一个随机值。然后，我们修改proxy_retry_request函数以使用随机代理来请求页面。这个函数与retry_request函数类似，但它允许使用IP代理服务器来请求页面。

2.5. 降低并发度

如果您的爬虫程序并发度过高，那么您可能会遇到网络瓶颈和服务器压力过大的问题。这时候，您可以通过降低并发度来减轻服务器的负载。以下是一个示例函数，它使用sleep函数来降低并发度：

import requests
import time
def sleep_retry_request(url, try_times=5, sleep_time=1):
    for i in range(try_times):
        try:
            response = requests.get(url)
            if response.status_code != 200:
                raise Exception("Failed to get page")
            return response
        except (requests.exceptions.RequestException, Exception):
            pass
        time.sleep(sleep_time)
    raise Exception("Failed after multiple tries")

这个代码中，我们定义了一个sleep_retry_request函数，它与retry_request函数类似，但它使用sleep函数来降低并发度。这个函数接受一个额外的sleep_time参数，它指定了等待多长时间后再次发送请求。

2.6. 将请求放入队列中

如果您的爬虫需要处理大量的请求，那么您可以考虑将请求放入队列中，然后使用多个线程或进程来处理这些请求。这可以提高处理速度，并将请求发送到不同的服务器上。以下是一个示例代码，它将请求放入队列中，并使用多个线程来处理这些请求：

import requests
import threading
import queue
def worker(q, result):
    while not q.empty():
        url = q.get()
        try:
            response = requests.get(url)
            if response.status_code != 200:
                raise Exception("Failed to get page")
            result[url] = response
        except (requests.exceptions.RequestException, Exception):
            pass
        q.task_done()
def queue_retry_request(urls, num_workers=5):
    q = queue.Queue()
    result = {}
    for url in urls:
        q.put(url)
    for i in range(num_workers):
        t = threading.Thread(target=worker, args=(q, result))
        t.daemon = True
        t.start()
    q.join()
    if len(result) != len(urls):
        raise Exception("Failed to get all pages")
    return result

这个代码中，我们定义了一个worker函数，它接受请求队列和结果字典作为参数，然后不断地从队列中获取请求，并将其发送到服务器上。在主程序中，我们将所有请求放入队列中，然后使用多个线程来处理这些请求。当所有请求都被处理完毕后，结果字典将包含所有请求的响应。

3. 结论

在爬虫的过程中，多次请求超时是一个常见的问题。本文介绍了6种重试方法，用于处理多次请求超时的问题。这些方法包括多次请求、增加等待时间、增加User-Agent、使用IP代理、降低并发度和将请求放入队列中。您可以根据您的具体情况选择其中一种或多种方法来处理请求超时问题。