自用半年！Python爬虫通用代理IP配置模板

原创

永不掉线的小白

发布于 2026-08-20 14:13:32

做爬虫开发的小伙伴应该都懂，代理IP配置不稳定、代码复用性差、频繁封IP是最头疼的问题。我这套Python爬虫代理IP模板实测稳定使用半年，适配静态代理、动态短效代理，支持requests、selenium两大主流爬虫场景，自带IP有效性校验、失败重连、自动换IP机制，开箱即用，无需重复修改核心逻辑。

下面完整分享模板代码、配置说明及实操避坑要点，新手老手都能直接套用。

一、模板核心优势

通用性强：兼容HTTP/HTTPS代理，支持付费独享代理、免费临时代理、隧道代理
容错性高：内置IP失效检测、请求超时重试、自动切换新IP，避免爬虫中断
极简复用：配置与业务代码分离，只需修改代理接口/账号密码即可适配新项目
防封优化：附带请求头伪装、超时控制、请求间隔，降低IP封禁概率

二、Requests爬虫代理IP通用模板

适用于绝大多数静态网页、接口爬虫，是日常使用频率最高的版本，核心逻辑封装完整，直接复制可用。

import requests
import random
import time
import threading

# ====================== 代理配置区（仅需修改这里）======================
# 方式1：单个固定代理（静态独享IP）
PROXY = {
    "http": "http://账号:密码@代理IP:端口",
    "https": "http://账号:密码@代理IP:端口"
}

# 方式2：批量代理池（动态轮换IP，推荐！长期爬虫必备）
PROXY_POOL = [
    "http://账号:密码@IP1:端口",
    "http://账号:密码@IP2:端口",
    "http://账号:密码@IP3:端口"
]

# 请求超时时间、重试次数、请求间隔（防封核心参数）
TIMEOUT = 10
RETRY_TIMES = 3
SLEEP_MIN = 1
SLEEP_MAX = 3

# 代理池定时重检配置（长期挂机爬虫专用）
PROXY_CHECK_INTERVAL = 300  # 有效IP重检周期，单位：秒，默认5分钟刷新一次
# =====================================================================

# 通用请求头伪装（模拟真实浏览器，避免裸请求被拦截）
HEADERS = {
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
    "Accept-Language": "zh-CN,zh;q=0.9",
    "Referer": "https://www.baidu.com/"
}

# 全局锁，防止多线程检测代理池冲突
POOL_LOCK = threading.Lock()

def check_proxy_valid(proxy_url, test_url="http://httpbin.org/ip"):
    """
    单个代理IP有效性检测
    :param proxy_url: 代理地址 格式：http://账号:密码@IP:端口
    :param test_url: 代理检测测试接口
    :return: True-有效 False-无效
    """
    check_proxies = {"http": proxy_url, "https": proxy_url}
    try:
        res = requests.get(test_url, headers=HEADERS, proxies=check_proxies, timeout=8)
        return res.status_code == 200
    except Exception:
        return False

def filter_valid_proxy_pool(pool):
    """
    批量过滤代理池，仅保留有效IP
    :param pool: 原始代理IP池列表
    :return: 清洗后的有效代理池
    """
    print("开始检测代理IP有效性，清洗无效IP...")
    valid_pool = [proxy for proxy in pool if check_proxy_valid(proxy)]
    print(f"代理池清洗完成：原始{len(pool)}个IP，有效{len(valid_pool)}个IP")
    return valid_pool

def auto_refresh_proxy_pool():
    """
    定时后台刷新代理池，长期爬虫自动剔除失效IP
    独立线程运行，不阻塞主爬虫任务
    """
    global PROXY_POOL
    while True:
        # 休眠指定时间后重检
        time.sleep(PROXY_CHECK_INTERVAL)
        with POOL_LOCK:
            PROXY_POOL = filter_valid_proxy_pool(PROXY_POOL)
        print(f"【定时刷新完成】当前可用代理IP数量：{len(PROXY_POOL)}")

# 启动前自动清洗代理池（全局生效）
PROXY_POOL = filter_valid_proxy_pool(PROXY_POOL)

# 后台启动定时刷新线程（守护线程，主程序关闭自动退出）
threading.Thread(target=auto_refresh_proxy_pool, daemon=True).start()
print(f"已开启代理池定时刷新任务，每{PROXY_CHECK_INTERVAL}秒自动重检IP有效性")

def get_random_proxy():
    """从代理池随机获取一个有效代理IP"""
    with POOL_LOCK:
        if PROXY_POOL:
            return {"http": random.choice(PROXY_POOL), "https": random.choice(PROXY_POOL)}
    return PROXY

def spider_request(url, method="GET", data=None, params=None):
    """
    封装带代理的通用请求方法
    :param url: 请求地址
    :param method: 请求方式 GET/POST
    :param data: POST请求体
    :param params: GET请求参数
    :return: 响应内容/None（请求失败）
    """
    for _ in range(RETRY_TIMES):
        try:
            proxy = get_random_proxy()
            # 随机休眠，模拟人工操作
            time.sleep(random.uniform(SLEEP_MIN, SLEEP_MAX))
            
            if method.upper() == "GET":
                res = requests.get(url, headers=HEADERS, proxies=proxy, timeout=TIMEOUT, params=params)
            else:
                res = requests.post(url, headers=HEADERS, proxies=proxy, timeout=TIMEOUT, data=data)
            
            # 状态码校验，过滤无效响应
            if res.status_code == 200:
                return res
            else:
                print(f"请求失败，状态码：{res.status_code}，即将重试")
                continue
        except Exception as e:
            print(f"代理请求异常：{str(e)}，更换IP重试")
            continue
    print("多次重试失败，当前代理池暂无可用IP")
    return None

# 测试调用
if __name__ == "__main__":
    # 测试代理有效性（访问IP查询接口）
    test_url = "http://httpbin.org/ip"
    result = spider_request(test_url)
    if result:
        print("代理配置成功！当前IP：", result.text)

三、Selenium无头浏览器代理模板

针对JS渲染的动态网页爬虫，适配Chrome无头浏览器，解决selenium代理配置繁琐、IP不生效的问题，同样支持自动换IP。

from selenium import webdriver
from selenium.webdriver.chrome.options import Options
import random
import time

# 代理配置（同requests模板，统一配置更省心）
PROXY_POOL = [
    "账号:密码@IP1:端口",
    "账号:密码@IP2:端口"
]

def get_selenium_driver():
    """配置带代理的Chrome驱动"""
    chrome_options = Options()
    # 无头模式（后台运行，不弹出浏览器）
    chrome_options.add_argument("--headless=new")
    # 随机选取代理
    proxy = random.choice(PROXY_POOL)
    chrome_options.add_argument(f"--proxy-server=http://{proxy}")
    # 忽略证书报错
    chrome_options.add_argument("--ignore-certificate-errors")
    # 模拟真实设备
    chrome_options.add_argument("user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36")
    
    driver = webdriver.Chrome(options=chrome_options)
    driver.set_page_load_timeout(15)
    return driver

# 测试调用
if __name__ == "__main__":
    driver = get_selenium_driver()
    driver.get("http://httpbin.org/ip")
    print("当前浏览器代理IP：", driver.page_source)
    time.sleep(2)
    driver.quit()

四、隧道代理专属配置

隧道代理是7×24小时稳定爬虫、高频批量采集的最优选择，无需手动维护IP池、自动秒级换IP、无IP数量限制，完美解决短效代理频繁失效、IP池耗尽的问题，下面适配requests、Selenium双场景可直接套用。

4.1 Requests 隧道代理完整代码

import requests
import random
import time

# ====================== 隧道代理专属配置区 ======================
# 隧道代理域名、端口、账号密码（代理商家提供）
TUNNEL_HOST = "隧道代理域名"
TUNNEL_PORT = 端口数字
TUNNEL_USER = "代理账号"
TUNNEL_PWD = "代理密码"

# 爬虫防封参数
TIMEOUT = 12
RETRY_TIMES = 3
SLEEP_MIN = 0.5
SLEEP_MAX = 2
# =================================================================

HEADERS = {
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
    "Accept-Language": "zh-CN,zh;q=0.9",
    "Referer": "https://www.baidu.com/"
}

# 组装隧道代理固定格式
TUNNEL_PROXY = {
    "http": f"http://{TUNNEL_USER}:{TUNNEL_PWD}@{TUNNEL_HOST}:{TUNNEL_PORT}",
    "https": f"http://{TUNNEL_USER}:{TUNNEL_PWD}@{TUNNEL_HOST}:{TUNNEL_PORT}"
}

def check_tunnel_proxy():
    """隧道代理专属连通性预检测"""
    try:
        res = requests.get("http://httpbin.org/ip", headers=HEADERS, proxies=TUNNEL_PROXY, timeout=10)
        if res.status_code == 200:
            print("隧道代理通道连接正常！")
            return True
    except Exception as e:
        print(f"隧道代理通道异常：{str(e)}，请检查账号域名配置")
    return False

# 启动前强制检测隧道代理可用性
check_tunnel_proxy()

def tunnel_spider_request(url, method="GET", data=None, params=None):
    """隧道代理专属请求方法，自动轮换全局IP"""
    for _ in range(RETRY_TIMES):
        try:
            time.sleep(random.uniform(SLEEP_MIN, SLEEP_MAX))
            if method.upper() == "GET":
                res = requests.get(url, headers=HEADERS, proxies=TUNNEL_PROXY, timeout=TIMEOUT, params=params)
            else:
                res = requests.post(url, headers=HEADERS, proxies=TUNNEL_PROXY, timeout=TIMEOUT, data=data)
            if res.status_code == 200:
                return res
            else:
                print(f"隧道代理请求异常，状态码：{res.status_code}，重试中")
                continue
        except Exception as e:
            print(f"隧道代理连接失败：{str(e)}，重试中")
            continue
    print("隧道代理多次请求失败，请检查账号配置或代理通道状态")
    return None

# 测试隧道代理
if __name__ == "__main__":
    res = tunnel_spider_request("http://httpbin.org/ip")
    if res:
        print("隧道代理连接成功！当前IP：", res.text)

4.2 Selenium 隧道代理配置

from selenium import webdriver
from selenium.webdriver.chrome.options import Options
import time

# 隧道代理配置（与requests统一）
TUNNEL_HOST = "隧道代理域名"
TUNNEL_PORT = 端口数字
TUNNEL_USER = "代理账号"
TUNNEL_PWD = "代理密码"

def get_tunnel_driver():
    chrome_options = Options()
    chrome_options.add_argument("--headless=new")
    chrome_options.add_argument(f"--proxy-server=http://{TUNNEL_USER}:{TUNNEL_PWD}@{TUNNEL_HOST}:{TUNNEL_PORT}")
    chrome_options.add_argument("--ignore-certificate-errors")
    chrome_options.add_argument("--disable-web-security")
    chrome_options.add_argument("user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36")
    
    driver = webdriver.Chrome(options=chrome_options)
    driver.set_page_load_timeout(20)
    return driver

# 测试调用
if __name__ == "__main__":
    driver = get_tunnel_driver()
    driver.get("http://httpbin.org/ip")
    print("Selenium隧道代理IP：", driver.page_source)
    time.sleep(3)
    driver.quit()