爬虫进阶避坑指南：10个实战反爬技巧，从封IP到破签名全解析

作为一名爬取过电商、资讯、社交等多平台数据的开发者，我踩过的反爬坑没有100也有80——刚入门时因不懂User-Agent被直接拒接，后来因高频请求被封IP，甚至遇到过接口签名参数导致爬虫直接瘫痪的情况。

反爬本质是网站与爬虫的“攻防博弈”，但大多数开发者只停留在“换IP、加延迟”的基础操作，面对动态签名、Cookie验证、设备指纹等进阶反爬就束手无策。本文结合我近两年的实战经验，拆解10个高频反爬场景的解决方案，每个技巧都附代码片段和踩坑总结，帮你从“爬虫新手”进阶为“反爬克星”。

一、先搞懂：网站是怎么识别你是爬虫的？

在讲技巧前，先明确网站反爬的核心逻辑——识别“非人类行为”或“异常行为”。常见识别维度包括：

静态标识：固定User-Agent、缺失Referer/Origin请求头；行为特征：请求频率过高、IP地址集中、访问路径固定（如只爬数据页不逛首页）；动态验证：需要登录Cookie、接口签名参数、验证码；环境特征：浏览器指纹（Canvas、WebGL）、设备信息、JS执行能力。

知道了识别逻辑，反爬的核心思路就清晰了：让爬虫的请求“看起来像人类”，让行为“符合正常用户习惯”。

二、10个实战反爬技巧（从基础到进阶）

1. 基础操作：请求头伪装（最容易被忽略，却最关键）

很多新手爬虫只加一个User-Agent就敢爬，结果被网站直接拉黑——现代网站会校验多个请求头字段，缺失或异常都会被标记为爬虫。

实战技巧：

完整模拟浏览器请求头，包含User-Agent、Referer、Accept、Accept-Language等；User-Agent随机切换（避免单一UA被识别），优先选择真实浏览器的UA（而非自定义）；动态设置Referer（如爬商品详情页时，Referer设为商品列表页URL）。

代码示例：

import requests
from fake_useragent import UserAgent
import random

# 1. 构建真实请求头池（关键字段缺一不可）
UA_POOL = [
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36",
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Firefox/129.0"
]

def get_random_headers(referer="https://www.baidu.com"):
    """生成随机请求头"""
    ua = random.choice(UA_POOL)
    return {
        "User-Agent": ua,
        "Referer": referer,  # 动态设置Referer
        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
        "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8",
        "Accept-Encoding": "gzip, deflate, br",
        "Connection": "keep-alive",
        "Upgrade-Insecure-Requests": "1"
    }

# 使用示例
url = "https://target-website.com/data"
headers = get_random_headers(referer="https://target-website.com/list")  # Referer设为目标网站列表页
response = requests.get(url, headers=headers, timeout=10)

踩坑总结：

不要用过于老旧的UA（如IE浏览器），容易被识别为异常；部分网站会校验 Sec-Fetch-*系列字段（如 Sec-Fetch-Mode: navigate），可直接从浏览器开发者工具复制完整请求头。

2. 频率控制：模拟人类访问节奏（避免高频请求）

网站最容易识别的异常行为就是“高频次、无间隔”请求——人类浏览网页会有点击、滚动、停顿，而爬虫默认是“秒级爬取”，很容易触发IP封禁。

实战技巧：

随机延迟：每次请求后延迟1-5秒，避免固定延迟（如每次都等2秒，仍会被识别）；访问间隔递增：连续爬取同一网站时，延迟时间逐渐增加（如1秒→2秒→3秒）；限制单日/单IP爬取量：避免一次性爬取上万条数据，分时段、分批次爬取。

代码示例：

import time
import random

def crawl_with_delay(url, headers):
    """带随机延迟的请求函数"""
    try:
        # 随机延迟1-5秒，模拟人类思考时间
        delay = random.uniform(1.2, 4.8)
        time.sleep(delay)
        print(f"延迟{delay:.2f}秒后请求：{url}")
        response = requests.get(url, headers=headers, timeout=10)
        return response
    except Exception as e:
        print(f"请求失败：{e}")
        return None

# 连续爬取时，延迟递增
def batch_crawl(url_list, headers):
    base_delay = 1.0
    for i, url in enumerate(url_list):
        # 每爬5个页面，延迟增加0.5秒
        if i % 5 == 0 and i != 0:
            base_delay += 0.5
        time.sleep(random.uniform(base_delay, base_delay + 1.5))
        crawl_with_delay(url, headers)

踩坑总结：

延迟不是越长越好：延迟过久会降低爬取效率，1-5秒是兼顾效率和反爬的黄金区间；避免“集中爬取”：比如每天凌晨2点集中爬取，容易被网站标记为异常IP（正常用户此时很少访问）。

3. IP池搭建：突破IP封禁（反爬核心操作）

当请求频率控制后仍被封IP，说明网站已对IP进行了限制——此时需要用IP池切换IP，让网站无法识别你的真实地址。

实战技巧：

IP类型选择：优先用高匿代理（避免透明代理暴露真实IP），静态IP适合长期爬取，动态IP适合短期高频爬取；IP池架构：自建IP池（成本高但稳定）或使用第三方IP池（如阿布云、快代理，成本低但需筛选质量）；IP切换策略：每爬取3-5个页面切换一次IP，请求失败时立即切换IP并重试。

代码示例（IP池集成）：

import requests

class ProxyPool:
    def __init__(self, proxy_api):
        self.proxy_api = proxy_api  # 第三方IP池API
        self.proxies = []  # 缓存的代理IP列表
    
    def fetch_proxies(self):
        """从API获取代理IP列表"""
        try:
            response = requests.get(self.proxy_api, timeout=5)
            self.proxies = response.text.split("
")  # 假设API返回格式为每行一个IP:端口
            print(f"获取到{len(self.proxies)}个代理IP")
        except Exception as e:
            print(f"获取IP池失败：{e}")
    
    def get_random_proxy(self):
        """随机获取一个代理IP"""
        if not self.proxies:
            self.fetch_proxies()
        return random.choice(self.proxies) if self.proxies else None

# 使用示例
proxy_pool = ProxyPool("http://your-proxy-api.com/get_proxies")

def crawl_with_proxy(url, headers):
    proxy = proxy_pool.get_random_proxy()
    if not proxy:
        print("无可用代理，使用本机IP")
        return requests.get(url, headers=headers, timeout=10)
    
    proxies = {
        "http": f"http://{proxy}",
        "https": f"https://{proxy}"
    }
    
    try:
        response = requests.get(url, headers=headers, proxies=proxies, timeout=10)
        return response
    except Exception as e:
        print(f"代理{proxy}失效，切换IP")
        proxy_pool.proxies.remove(proxy)  # 移除失效代理
        return crawl_with_proxy(url, headers)  # 递归重试

踩坑总结：

免费IP池质量差：免费代理大多是共享IP，容易被网站拉黑，不建议用于重要爬取；验证IP有效性：爬取前先测试代理是否能正常访问目标网站，避免无效IP浪费时间；避免同一IP爬取敏感数据：如用户评论、商品价格等，容易触发更严格的反爬。

4. Cookie管理：维持登录状态（突破登录墙）

很多网站的核心数据（如用户评价、历史价格）需要登录后才能访问——此时需要管理Cookie，让爬虫维持登录状态，避免每次请求都被要求登录。

实战技巧：

手动登录获取Cookie：用浏览器登录后，从开发者工具复制Cookie，保存到文件复用；Cookie自动更新：定期检查Cookie有效性（如请求返回302跳转登录页时），重新登录获取新Cookie；用Session维持会话：requests.Session会自动保存Cookie，避免每次请求都手动添加。

代码示例（Cookie管理）：

import requests
import json

# 1. 保存Cookie到文件（首次登录后执行）
def save_cookies(session, filename="cookies.json"):
    cookies = session.cookies.get_dict()
    with open(filename, "w", encoding="utf-8") as f:
        json.dump(cookies, f, ensure_ascii=False, indent=2)
    print("Cookie保存成功")

# 2. 从文件加载Cookie
def load_cookies(session, filename="cookies.json"):
    try:
        with open(filename, "r", encoding="utf-8") as f:
            cookies = json.load(f)
        session.cookies.update(cookies)
        print("Cookie加载成功")
        return True
    except FileNotFoundError:
        print("未找到Cookie文件，请先登录")
        return False

# 3. 登录获取Cookie（以模拟登录为例）
def login_and_get_cookies(username, password):
    session = requests.Session()
    login_url = "https://target-website.com/login"
    data = {
        "username": username,
        "password": password
    }
    response = session.post(login_url, data=data, headers=get_random_headers())
    if response.status_code == 200 and "登录成功" in response.text:
        save_cookies(session)
        return session
    else:
        print("登录失败")
        return None

# 使用示例
def crawl_with_login(url):
    session = requests.Session()
    # 尝试加载已保存的Cookie
    if not load_cookies(session):
        # 加载失败则重新登录
        session = login_and_get_cookies("your-username", "your-password")
        if not session:
            return None
    
    headers = get_random_headers(referer="https://target-website.com")
    response = session.get(url, headers=headers, timeout=10)
    
    # 检查Cookie是否有效（如返回登录页则重新登录）
    if "登录" in response.text and "登录成功" not in response.text:
        print("Cookie失效，重新登录")
        session = login_and_get_cookies("your-username", "your-password")
        response = session.get(url, headers=headers, timeout=10)
    
    return response

踩坑总结：

Cookie有有效期：大多数网站Cookie有效期为7-30天，需定期更新；避免多IP共用Cookie：同一Cookie在不同IP下使用，容易被网站判定为账号被盗，直接封禁账号；敏感操作加延迟：登录、下单等敏感操作后，延迟3-5秒再爬取，避免触发账号安全机制。

5. 动态渲染页面：突破JS加载（Selenium/Playwright）

很多现代网站用Vue、React等框架开发，数据通过JS动态加载（如滚动加载、点击“加载更多”）——此时requests无法获取动态数据，需要模拟浏览器执行JS。

实战技巧：

优先用Playwright（比Selenium更稳定，反爬能力更强），模拟真实浏览器操作（滚动、点击）；启用无头模式（headless）减少资源占用，但部分网站会检测无头浏览器，需添加伪装；避免快速操作：模拟人类点击、滚动节奏，如点击“加载更多”后延迟2秒再获取数据。

代码示例（Playwright爬动态页面）：

from playwright.sync_api import sync_playwright
import time

def crawl_dynamic_page(url):
    with sync_playwright() as p:
        # 启动Chrome浏览器，添加伪装（避免被识别为无头浏览器）
        browser = p.chromium.launch(
            headless=True,
            args=[
                "--disable-blink-features=AutomationControlled",  # 禁用自动化标识
                "--user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36"
            ]
        )
        context = browser.new_context(
            viewport={"width": 1920, "height": 1080},  # 模拟桌面浏览器窗口
            geolocation={"longitude": 116.403874, "latitude": 39.914885},  # 模拟地理位置
            permissions=["geolocation"]
        )
        page = context.new_page()
        
        # 屏蔽webdriver标识
        page.add_init_script("""
            delete window.navigator.webdriver;
            window.navigator.languages = ["zh-CN", "zh"];
        """)
        
        # 访问页面
        page.goto(url, wait_until="networkidle")  # 等待网络空闲（确保JS加载完成）
        time.sleep(random.uniform(1.5, 2.5))
        
        # 模拟滚动加载（滚动3次，每次滚动后等待数据加载）
        for _ in range(3):
            page.mouse.wheel(0, 1000)  # 向下滚动1000像素
            page.wait_for_timeout(random.uniform(1000, 2000))  # 等待1-2秒
        
        # 获取页面HTML（此时已包含动态加载的数据）
        html = page.content()
        browser.close()
        return html

踩坑总结：

Playwright比Selenium更抗反爬：Selenium的 window.navigator.webdriver标识容易被检测，而Playwright默认隐藏该标识；避免过度模拟：如连续点击、快速滚动，容易触发网站的行为验证（如滑块验证码）；优先捕获AJAX接口：如果能通过开发者工具找到动态加载的AJAX接口，用requests直接请求比Playwright更高效。

6. 接口签名破解：突破参数加密（核心进阶技巧）

很多API接口会对请求参数进行加密（如添加sign、timestamp、nonce等字段），直接拼接参数会返回403——破解签名是爬虫进阶的关键，核心是“还原网站的加密逻辑”。

实战技巧：

步骤1：通过Chrome开发者工具（Sources面板）找到签名函数（搜索sign、encrypt等关键词）；步骤2：分析签名逻辑（如MD5加密、HMAC加密，参数是否包含timestamp、nonce、Cookie等）；步骤3：用Python还原加密逻辑，动态生成签名参数。

案例：破解某网站API签名（MD5加密）

假设网站接口参数为： ?id=123&timestamp=1699999999&nonce=abc123&sign=xxx，其中sign是MD5加密后的字符串。

破解步骤：

打开开发者工具→Sources→搜索“sign”，找到签名函数：

// 网站JS签名逻辑
function generateSign(params, secret) {
    // 1. 参数按key排序
    let sortedKeys = Object.keys(params).sort();
    // 2. 拼接参数：key1=value1&key2=value2+secret
    let signStr = sortedKeys.map(key => `${key}=${params[key]}`).join("&") + secret;
    // 3. MD5加密并转大写
    return md5(signStr).toUpperCase();
}

确定secret（密钥）：可能是固定值（如“abcdef123”），或从页面HTML、Cookie中获取；用Python还原逻辑：

代码示例（Python生成签名）：

import hashlib
import time
import random
import string

def generate_nonce(length=6):
    """生成随机nonce字符串（大小写字母+数字）"""
    return ''.join(random.choices(string.ascii_letters + string.digits, k=length))

def generate_sign(params, secret="abcdef123"):
    """还原JS签名逻辑：MD5加密"""
    # 1. 参数按key排序
    sorted_keys = sorted(params.keys())
    # 2. 拼接参数字符串
    sign_str = "&".join([f"{key}={params[key]}" for key in sorted_keys]) + secret
    # 3. MD5加密并转大写
    md5 = hashlib.md5()
    md5.update(sign_str.encode("utf-8"))
    return md5.hexdigest().upper()

def crawl_signed_api():
    api_url = "https://target-website.com/api/data"
    # 1. 构造基础参数
    params = {
        "id": 123,
        "timestamp": int(time.time()),  # 时间戳（秒级）
        "nonce": generate_nonce()  # 随机字符串
    }
    # 2. 生成签名
    params["sign"] = generate_sign(params, secret="abcdef123")  # 替换为真实secret
    # 3. 发送请求
    headers = get_random_headers(referer="https://target-website.com")
    response = requests.get(api_url, params=params, headers=headers, timeout=10)
    print(f"接口响应：{response.json()}")
    return response

踩坑总结：

密钥可能动态变化：部分网站会从页面JS、Cookie中动态获取secret，需先爬取secret再生成签名；时间戳校验：网站可能校验timestamp与服务器时间差（如±30秒），需用服务器时间或同步本地时间；避免硬编码密钥：如果网站更新密钥，爬虫会直接失效，建议动态提取密钥（如从页面HTML中解析）。

7. 验证码破解：突破人机验证（OCR/打码平台）

当爬虫触发高强度反爬时，网站会弹出验证码（如滑块验证码、图文验证码、短信验证码）——此时需要破解验证码才能继续爬取。

实战技巧：

图文验证码：用Tesseract-OCR识别简单验证码，复杂验证码（如扭曲文字、干扰线）用第三方打码平台（如云打码、超级鹰）；滑块验证码：用Playwright模拟滑块拖动（匹配缺口位置），或使用打码平台识别缺口坐标；短信验证码：不建议破解（涉及用户隐私，且容易触发账号封禁），优先用Cookie维持登录状态。

代码示例（Tesseract-OCR识别简单验证码）：

from PIL import Image
import pytesseract
import requests

# 注意：需先安装Tesseract-OCR，并配置环境变量
pytesseract.pytesseract.tesseract_cmd = r"C:Program FilesTesseract-OCR	esseract.exe"

def recognize_captcha(captcha_url):
    """下载验证码并识别"""
    # 1. 下载验证码图片
    response = requests.get(captcha_url, stream=True, timeout=10)
    with open("captcha.png", "wb") as f:
        f.write(response.content)
    
    # 2. 预处理图片（灰度化、二值化，提高识别率）
    img = Image.open("captcha.png").convert("L")  # 灰度化
    threshold = 127  # 二值化阈值
    img = img.point(lambda p: p > threshold and 255)  # 二值化
    
    # 3. OCR识别
    captcha_text = pytesseract.image_to_string(img).strip()
    print(f"识别到验证码：{captcha_text}")
    return captcha_text

# 复杂验证码：使用打码平台（以超级鹰为例）
def recognize_captcha_with_platform(captcha_path):
    """调用超级鹰打码平台识别验证码"""
    import requests
    from hashlib import md5

    username = "your-username"
    password = md5("your-password".encode()).hexdigest()
    appid = "123456"  # 替换为你的appid
    appkey = "your-appkey"
    url = "http://upload.chaojiying.net/Upload/Processing.php"
    
    data = {
        "user": username,
        "pass2": password,
        "softid": appid,
        "codetype": "1004",  # 验证码类型（1004为4位数字字母）
    }
    files = {"userfile": open(captcha_path, "rb")}
    
    response = requests.post(url, data=data, files=files)
    result = response.json()
    if result["err_no"] == 0:
        return result["pic_str"]
    else:
        print(f"打码失败：{result['err_str']}")
        return None

踩坑总结：

Tesseract-OCR识别率有限：仅适用于无干扰、字体清晰的验证码，复杂验证码建议用打码平台；滑块验证码防模拟：部分网站会检测滑块拖动速度（如过快、匀速拖动），需模拟人类拖动节奏（先慢→快→慢）；避免频繁触发验证码：验证码是网站的“最后防线”，频繁触发会导致IP/账号被封禁，建议优化前面的反爬策略。

8. 浏览器指纹伪装：突破设备识别

现代网站会通过浏览器指纹（Canvas、WebGL、UserAgent、屏幕分辨率等）识别设备——即使你换了IP和Cookie，同一设备的指纹仍会被识别为爬虫。

实战技巧：

禁用Canvas/WebGL指纹：通过Playwright添加初始化脚本，修改Canvas绘制结果；随机屏幕分辨率、语言设置：模拟不同设备的浏览器环境；避免使用默认浏览器配置：自定义浏览器参数（如禁用插件、清除缓存）。

代码示例（Playwright伪装浏览器指纹）：

from playwright.sync_api import sync_playwright

def fake_browser_fingerprint():
    with sync_playwright() as p:
        browser = p.chromium.launch(headless=True)
        context = browser.new_context(
            viewport={"width": random.randint(1366, 1920), "height": random.randint(768, 1080)},
            user_agent=random.choice(UA_POOL),
            locale="zh-CN",
            timezone_id="Asia/Shanghai"
        )
        page = context.new_page()
        
        # 伪装Canvas指纹
        page.add_init_script("""
            // 重写Canvas绘制方法，修改指纹结果
            const originalToDataURL = HTMLCanvasElement.prototype.toDataURL;
            HTMLCanvasElement.prototype.toDataURL = function(type) {
                const canvas = document.createElement('canvas');
                canvas.width = this.width;
                canvas.height = this.height;
                const ctx = canvas.getContext('2d');
                ctx.fillStyle = '#fff';
                ctx.fillRect(0, 0, canvas.width, canvas.height);
                return originalToDataURL.call(canvas, type);
            };
            
            // 伪装WebGL指纹
            const originalGetParameter = WebGLRenderingContext.prototype.getParameter;
            WebGLRenderingContext.prototype.getParameter = function(pname) {
                if (pname === 37445) return 'Intel(R) UHD Graphics';  // 伪装显卡型号
                if (pname === 37446) return '4.6.0 - Build 27.20.100.9664';  // 伪装WebGL版本
                return originalGetParameter.call(this, pname);
            };
        """)
        
        page.goto("https://target-website.com", wait_until="networkidle")
        # 验证指纹伪装是否成功（访问指纹检测网站）
        # page.goto("https://browserleaks.com/canvas", wait_until="networkidle")
        # time.sleep(5)
        # page.screenshot(path="fingerprint.png")
        
        browser.close()

踩坑总结：

指纹伪装不宜过度：过度修改指纹可能导致与浏览器环境不匹配，反而被识别为异常；参考真实设备指纹：从真实浏览器中获取Canvas、WebGL指纹数据，再进行伪装，更贴近真实环境；部分网站会检测插件：禁用浏览器插件（如AdBlock），避免插件暴露爬虫身份。

9. 分布式爬取：突破单机限制（Scrapy-Redis）

当爬取数据量过大（如百万级数据）时，单机爬虫效率低、易被封IP——分布式爬取可将任务分配到多个节点，同时爬取并共享进度，突破单机限制。

实战技巧：

基于Scrapy-Redis实现分布式：Redis作为任务队列和去重集合，多个爬虫节点共享任务；统一IP池：所有节点使用同一个IP池，避免单个节点IP被封影响整体爬取；任务分片：按数据ID、分类等维度分片，避免节点重复爬取。

核心配置（Scrapy-Redis分布式）：

# settings.py
from scrapy_redis.spiders import RedisSpider
from scrapy_redis.connection import RedisConnection

# 启用Redis调度器（任务队列）
SCHEDULER = "scrapy_redis.scheduler.Scheduler"
# 启用Redis去重（避免重复爬取）
DUPEFILTER_CLASS = "scrapy_redis.dupefilter.RFPDupeFilter"
# Redis连接配置
REDIS_URL = "redis://localhost:6379/0"
# 任务队列持久化（避免爬虫重启后任务丢失）
SCHEDULER_PERSIST = True
# 任务优先级（默认按FIFO排序）
SCHEDULER_QUEUE_CLASS = "scrapy_redis.queue.PriorityQueue"

# 自定义分布式爬虫
class DistributedSpider(RedisSpider):
    name = "distributed_spider"
    redis_key = "spider:start_urls"  # Redis中任务队列的key
    
    def parse(self, response):
        # 解析数据（与普通Scrapy爬虫一致）
        yield {"data": response.text}
        
        # 提取下一页URL，加入任务队列
        next_url = response.css("a.next::attr(href)").get()
        if next_url:
            yield scrapy.Request(next_url, callback=self.parse)

踩坑总结：

Redis稳定性关键：确保Redis服务正常运行，避免因Redis宕机导致任务丢失；控制并发数：每个节点的并发数不宜过高（建议5-10），避免整体请求频率过高被封IP；数据同步：分布式爬取的数据需统一存储（如MySQL集群、MongoDB分片），避免数据分散。

10. 合规爬取：避免法律风险（最容易被忽视）

反爬不仅是技术问题，还涉及法律风险——未经允许爬取网站数据，可能违反《网络安全法》《反不正当竞争法》，甚至面临诉讼。

实战技巧：

遵守robots.txt协议：网站根目录的robots.txt文件会明确允许爬取的路径，避免爬取禁止路径；爬取非敏感数据：仅爬取公开的非敏感数据（如商品列表、新闻资讯），不爬取用户隐私、商业机密；注明爬取用途：个人学习研究为主，不用于商业用途；商业爬取需提前获得网站授权。

合规检查清单：

访问网站的robots.txt（如https://www.baidu.com/robots.txt）；查看网站用户协议，确认是否禁止数据爬取；爬取频率控制在合理范围，不影响网站正常运行；不篡改、伪造请求头欺骗网站服务器。

三、反爬实战：多策略组合（以电商平台为例）

单一反爬技巧难以应对复杂场景，实际爬取时需组合使用——以下是电商平台爬取的组合策略：

基础层：完整请求头伪装 + 随机延迟（1-3秒）；核心层：IP池（每5页切换一次IP） + Cookie管理（维持登录状态）；进阶层：Playwright模拟浏览器（爬动态价格数据） + 接口签名破解（爬评价数据）；保障层：分布式爬取（百万级商品） + 合规检查（不爬用户隐私）。

组合策略代码框架：

def ecommerce_crawler(product_url):
    # 1. 初始化Session和IP池
    session = requests.Session()
    proxy_pool = ProxyPool("http://your-proxy-api.com/get_proxies")
    load_cookies(session)  # 加载登录Cookie
    
    # 2. 构造请求头
    headers = get_random_headers(referer="https://ecommerce-platform.com/list")
    
    # 3. 切换IP
    proxy = proxy_pool.get_random_proxy()
    proxies = {"http": f"http://{proxy}", "https": f"https://{proxy}"} if proxy else None
    
    # 4. 随机延迟
    time.sleep(random.uniform(1.5, 3.5))
    
    try:
        # 5. 爬取商品详情页（动态数据用Playwright）
        if "dynamic" in product_url:
            html = crawl_dynamic_page(product_url)
            # 解析动态价格数据
        else:
            response = session.get(product_url, headers=headers, proxies=proxies, timeout=10)
            # 解析静态数据
        
        # 6. 爬取评价接口（需要签名）
        comment_api = "https://ecommerce-platform.com/api/comments"
        params = generate_comment_params(product_id=123)  # 生成带签名的参数
        comment_response = session.get(comment_api, params=params, headers=headers, proxies=proxies)
        
        return {"product_data": response.text, "comments": comment_response.json()}
    except Exception as e:
        print(f"爬取失败：{e}")
        proxy_pool.proxies.remove(proxy)  # 移除失效IP
        return ecommerce_crawler(product_url)  # 重试

四、踩坑总结与经验分享

反爬是“循序渐进”的：先从基础技巧（请求头、延迟）开始，无效再用进阶技巧（IP池、签名破解），避免过度复杂；优先捕获AJAX接口：动态页面优先用开发者工具找AJAX接口，比模拟浏览器更高效、更稳定；IP池质量 > 数量：10个高质量高匿IP，比100个免费共享IP更有用；关注网站更新：定期检查目标网站的接口、参数、反爬策略，及时更新爬虫代码；技术是手段，合规是底线：爬取数据前务必确认合规性，避免法律风险。

反爬没有万能公式，核心是“灵活应变”——不同网站的反爬策略不同，需要针对性调整。但掌握了以上10个技巧，你就能应对90%以上的爬取场景。

如果在实战中遇到具体的反爬难题（如某网站的签名参数、滑块验证码），欢迎在评论区交流，我会尽力帮你解答！