Python爬虫重难点

备案号:蜀ICP备2026035467号-3|网址:www.xservx.com

爬虫开发全景图谱

在数据驱动决策的时代背景下,网络数据已成为企业战略制定、市场分析、舆情监控及学术研究的重要支撑。Python凭借其简洁的语法、强大的第三方库生态及活跃的社区支持,已成为网络爬虫开发的首选语言。然而,随着反爬技术的持续升级与法律监管的逐步完善,爬虫开发已从“简单抓取”转向“高阶对抗”阶段。

当前主流爬虫项目面临四大结构性挑战:一是反爬策略多元化,包括请求头校验、行为特征检测、IP频率限制、动态渲染渲染、JS混淆等多层防御;二是数据载体复杂化,大量网站采用AJAX异步加载、SPA单页架构、WebAssembly加密等技术;三是法律边界模糊化,2021年《个人信息保护法》实施后,数据采集行为的合法性需结合数据类型、获取方式、使用目的三重维度评估;四是工程化要求提升,企业级爬虫需兼顾稳定性、可维护性、分布式扩展及数据清洗能力。

本专题系统梳理爬虫开发中高频难点与行业痛点,结合真实项目经验,提供可落地的技术方案与合规建议。内容覆盖从基础原理到高阶技巧,从技术实现到法律合规,适合初学者建立完整知识体系,也适合开发者解决实际工程问题。

知识结构全景

  • 底层协议层:HTTP/HTTPS协议细节、TLS握手原理、Cookie机制、Session管理
  • 请求控制层:Headers构造、请求重放、重试策略、超时处理、异常捕获
  • 数据解析层:正则表达式、XPath、CSS选择器、JSON结构化解析、DOM树遍历
  • 反反爬层:IP轮换、User-Agent池、行为模拟、JS逆向、Selenium/Playwright
  • 工程部署层:分布式架构、任务调度、结果存储、增量抓取、日志监控
  • 法律合规层:Robots协议、数据权属、隐私保护、爬虫协议、风险规避

五大核心难点深度解析

1. 反爬识别精度提升

主流网站已构建多层反爬体系,传统简单请求方式成功率不足15%。以某电商平台为例,其反爬策略包含:

  • 请求头校验:必须包含Accept、Accept-Encoding、Accept-Language、Connection、Host、Referer、User-Agent等字段,且Referer需与目标域名匹配
  • 时间戳校验:部分API需携带加密时间戳,如t=1717020000,且与服务器时间差≤120秒
  • 请求频率限制:单IP每分钟请求≤30次,超过触发滑块验证
  • 行为特征检测:通过JavaScript监测鼠标移动轨迹、滚动行为、键盘敲击频率等

解决方案:使用Selenium+Playwright模拟真实用户行为,结合mitmproxy中间人代理动态注入Headers,或使用Playwright的stealth插件隐藏自动化特征。

2. 动态渲染内容抓取

据2024年W3Techs统计,全球前1000万网站中87%采用动态渲染技术。典型场景如:

  • AJAX异步加载:商品列表通过fetch()请求/api/products?offset=20获取JSON数据
  • WebAssembly加密:某社交平台将关键API参数加密为WASM模块,需逆向还原加密逻辑
  • Canvas绘制验证:滑块验证码通过canvas绘制干扰图形,需图像识别辅助

应对策略:优先分析Network面板中的XHR请求,提取真实API;若无直接API,则使用Playwright等待DOM元素加载完成(page.wait_for_selector('.product-item'));极端情况需逆向JS源码,提取加密函数逻辑。

3. 登录态维持与绕过

模拟登录是爬虫开发中最复杂的环节之一,涉及:

  • 加密参数生成:登录接口参数如password需经RSA+AES双重加密,需复现前端加密逻辑
  • 滑块验证绕过:计算滑块位移量需图像识别+轨迹模拟,推荐使用pyautogui+OpenCV组合方案
  • 设备指纹识别:部分网站通过WebGL、Canvas绘制生成设备指纹,需动态注入伪造指纹

实战案例:某视频平台登录流程包含5步验证,最终解决方案为:1)使用Playwright初始化浏览器;2)注入自定义JS覆盖navigator.webdriver标志;3)模拟人工操作滑块;4)保存Cookie会话复用。

4. 数据清洗与结构化

原始爬取数据需经多轮清洗才能用于分析,典型流程包括:

  1. 去重处理:基于URL、内容哈希(MD5)、关键字段组合去重
  2. 异常值剔除:使用Z-score或IQR识别并移除离群数据
  3. 格式标准化:统一时间格式(YYYY-MM-DD HH:mm:ss)、货币单位(元/万元)、数值精度
  4. 实体识别:通过正则提取手机号、邮箱、IP地址等敏感信息

推荐工具链:pandas处理结构化数据、regex处理复杂文本、spaCy进行实体识别、polars实现高性能计算。

5. 分布式架构设计

单机爬虫无法满足亿级数据采集需求,主流分布式方案包括:

  • Scrapy+Redis:任务队列分布式,支持多节点协同
  • Scrapy-Redis+Proxies:集成代理池实现IP轮换
  • Distributed Crawler Framework:自研框架,基于RabbitMQ任务队列+MySQL状态存储
  • Kubernetes编排:容器化部署,自动扩缩容

关键指标:分布式系统应实现99.9%任务成功率、每秒500+请求吞吐量、故障节点自动迁移能力。

反爬机制全景图谱

请求头校验策略

主流网站请求头校验要素:

字段 必填项 典型值 校验方式
Referer ✓ https://www.example.com/list 必须与目标URL域名匹配
User-Agent ✓ Mozilla/5.0 (Windows NT 10.0; Win64; x64) 禁止出现python-requests标识
Accept-Encoding ✓ gzip, deflate, br 必须包含br(Brotli)支持
Origin 部分 https://www.example.com CORS请求必需字段
X-Requested-With ✓ XMLHttpRequest AJAX请求必需标识

绕过技巧:使用requests.Session()自动维护Cookie,通过hook_requests函数动态修改Headers;或使用aiohttp配合自定义ClientSession实现异步Headers注入。

行为特征检测应对

现代反爬系统会监测以下行为特征:

  • 鼠标轨迹:正常用户移动轨迹呈曲线,自动化工具多为直线
  • 滚动行为:真实用户滚动存在加速度变化
  • 键盘事件:按键间隔时间符合人类特征(200-300ms)
  • 页面停留时间:单页面停留≥3秒才触发后续动作

解决方案:使用Playwright的stealth插件隐藏自动化特征,配合pyautogui生成平滑鼠标轨迹,模拟人类操作节奏。示例代码:

import asyncio
from playwright.async_api import async_playwright
async def main():
    async with async_playwright() as p:
        browser = await p.chromium.launch(headless=False)
        context = await browser.new_context()
        await context.add_init_script(path='./stealth.min.js')  # 隐藏自动化特征
        page = await context.new_page()
        await page.goto('https://example.com')
        # 模拟人类操作
        await page.mouse.move(100, 100)
        await page.mouse.down()
        await page.mouse.move(200, 150, steps=10)  # 平滑移动
        await page.mouse.up()
        await browser.close()
asyncio.run(main())

IP封禁应对策略

IP封禁是网站最基础的反爬手段,应对方案包括:

  • 代理池构建:集成免费代理(如快代理、无忧代理)+付费代理(如芝麻、阿布云)
  • IP健康检测:每5分钟检测代理可用性,剔除失效IP
  • 访问频率控制:单IP每分钟请求≤10次,请求间隔随机化(500-1500ms)
  • 指纹伪装:通过TLS指纹混淆工具(如tls-client)模拟不同浏览器指纹

代理池架构设计:

class ProxyPool:
    def __init__(self):
        self.proxies = []
        self.health_check_interval = 300  # 秒
        self.max_failures = 3
    async def add_proxy(self, proxy):
        """添加代理并初始化失败计数"""
        self.proxies.append({
            'proxy': proxy,
            'failures': 0,
            'last_check': 0
        })
    async def get_proxy(self):
        """获取可用代理"""
        for p in self.proxies:
            if await self._is_valid(p):
                return p['proxy']
        return None
    async def _is_valid(self, p):
        """验证代理有效性"""
        if p['failures'] >= self.max_failures:
            return False
        current_time = time.time()
        if current_time - p['last_check'] < self.health_check_interval:
            return True
        # 执行健康检查...
        p['last_check'] = current_time
        return True

动态加载内容抓取方案

AJAX请求提取技巧

以某招聘网站为例,职位列表通过/api/jobs接口获取数据:

POST /api/jobs HTTP/1.1
Host: www.example.com
Content-Type: application/json
X-Request-ID: a1b2c3d4e5f6g7h8i9j0
{
  "page": 2,
  "size": 20,
  "keyword": "python",
  "sort": "relevance"
}

关键步骤:

  1. 打开浏览器开发者工具Network标签
  2. 筛选XHR请求,定位包含数据的API
  3. 复制请求URL、Headers、Body参数
  4. 使用requests复现请求,注意处理加密参数

加密参数处理:若请求包含加密token,需分析JS源码提取加密函数,或使用Playwright调用页面JS环境执行加密逻辑。

Playwright深度抓取

Playwright是微软开源的自动化测试框架,支持多浏览器、多语言,特别适合动态内容抓取:

from playwright.sync_api import sync_playwright
def scrape_dynamic_page():
    with sync_playwright() as p:
        browser = p.chromium.launch(headless=True)
        page = browser.new_page()
        page.goto('https://example.com')
        # 等待关键元素加载
        page.wait_for_selector('.product-list .item', timeout=10000)
        # 滚动到底部触发懒加载
        page.evaluate('window.scrollTo(0, document.body.scrollHeight)')
        page.wait_for_timeout(2000)
        # 提取数据
        items = page.query_selector_all('.product-item')
        data = []
        for item in items:
            title = item.query_selector('.title').inner_text()
            price = item.query_selector('.price').inner_text()
            data.append({'title': title, 'price': price})
        browser.close()
        return data

优势:无需处理加密逻辑,真实渲染环境;劣势:资源消耗大、速度慢、易被检测。

JavaScript逆向实战

某视频平台使用WebAssembly加密API参数,逆向流程:

  1. 定位加密函数:通过断点调试找到加密入口点
  2. 提取WASM模块:使用chrome://tracing分析内存加载过程
  3. 还原JS逻辑:使用IDA Pro或Ghidra反编译WASM
  4. Python复现:将加密逻辑转换为Python代码

示例:某加密函数逻辑为

function encrypt(data, timestamp) {
  const key = 'secret_key_' + timestamp.substring(0, 4);
  const encrypted = AES.encrypt(data, key);
  return encrypted + '_' + timestamp;
}

Python复现代码:

from Crypto.Cipher import AES
from Crypto.Util.Padding import pad
import hashlib
def encrypt_data(data, timestamp):
    key = ('secret_key_' + timestamp[:4]).encode()
    cipher = AES.new(pad(key, 16), AES.MODE_CBC, b'0' * 16)
    encrypted = cipher.encrypt(pad(data.encode(), 16))
    return encrypted.hex() + '_' + timestamp

模拟登录技术详解

登录流程解析

以某社交平台为例,登录包含5个关键步骤:

  1. 获取公钥:GET /login/public_key 获取RSA公钥
  2. 加密密码:RSA加密密码 + AES加密二次加密
  3. 滑块验证:计算位移量 + 模拟轨迹
  4. 提交登录:POST /login 提交加密参数
  5. 保存会话:提取Cookie保存至Session

完整代码示例:

import requests
from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_v1_5, AES
from base64 import b64encode
import hashlib
import time
class SocialLogin:
    def __init__(self):
        self.session = requests.Session()
        self.base_url = 'https://www.example.com'
    def get_public_key(self):
        """获取RSA公钥"""
        resp = self.session.get(f'{self.base_url}/login/public_key')
        return resp.json()['key']
    def encrypt_password(self, password, public_key):
        """RSA加密密码"""
        key = RSA.import_key(public_key)
        cipher = PKCS1_v1_5.new(key)
        encrypted = b64encode(cipher.encrypt(password.encode())).decode()
        return encrypted
    def crack_slider(self):
        """破解滑块验证码"""
        # 获取滑块图片
        bg_img = self.session.get(f'{self.base_url}/captcha/bg').content
        slider_img = self.session.get(f'{self.base_url}/captcha/slider').content
        # 图像识别计算位移量
        offset = self._calculate_offset(bg_img, slider_img)
        # 模拟轨迹
        track = self._generate_track(offset)
        return track, offset
    def login(self, username, password):
        """执行登录流程"""
        # 1. 获取公钥
        public_key = self.get_public_key()
        # 2. 加密密码
        timestamp = str(int(time.time() * 1000))
        encrypted_pwd = self.encrypt_password(password, public_key)
        # 3. 破解滑块
        track, offset = self.crack_slider()
        # 4. 提交登录
        data = {
            'username': username,
            'password': encrypted_pwd,
            'token': self._generate_token(username, encrypted_pwd, timestamp),
            'slider_offset': offset,
            'slider_track': track
        }
        resp = self.session.post(f'{self.base_url}/login', json=data)
        return resp.json()['success']

设备指纹绕过

主流网站通过以下方式生成设备指纹:

  • Canvas绘制:在canvas上绘制文字/图形,生成哈希值
  • WebGL渲染:获取GPU信息生成唯一标识
  • AudioContext:分析音频处理能力
  • 字体检测:检测系统安装字体列表

绕过方案:使用Playwright注入JS覆盖关键API

const fingerprintScript = `
  Object.defineProperty(navigator, 'webdriver', {
    get: () => undefined
  });
  // 覆盖Canvas
  HTMLCanvasElement.prototype.getContext = function() {
    return {
      fillText: () => {},
      getImageData: () => ({
        data: new Uint8ClampedArray(4)
      })
    };
  };
  // 覆盖WebGL
  WebGLRenderingContext.prototype.getExtension = function() {
    return {
      getParameter: () => 'fake-renderer'
    };
  };
  // 覆盖AudioContext
  AudioContext.prototype.open = function() {
    return {
      close: () => {}
    };
  };
`;
await page.add_init_script(fingerprintScript)

验证码识别技术方案

滑块验证码识别

滑块验证码识别分三步:

  1. 缺口检测:使用OpenCV模板匹配定位缺口
  2. 轨迹生成:基于物理模型模拟人类移动
  3. 位移计算:计算缺口中心与滑块中心距离

缺口检测代码:

import cv2
import numpy as np
def detect_gap(bg_path, slider_path):
    # 读取图像
    bg = cv2.imread(bg_path, 0)
    slider = cv2.imread(slider_path, 0)
    # 边缘检测
    bg_edges = cv2.Canny(bg, 100, 200)
    slider_edges = cv2.Canny(slider, 100, 200)
    # 模板匹配
    result = cv2.matchTemplate(bg_edges, slider_edges, cv2.TM_CCOEFF_NORMED)
    min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(result)
    # 计算缺口位置
    x = max_loc[0]
    return x

轨迹生成使用物理模型模拟加减速:

def generate_track(distance):
    track = []
    current = 0
    mid = distance * 0.6  # 加速点
    t = 0.2
    v = 0
    while current < distance:
        if current < mid:
            a = 2  # 加速度
        else:
            a = -3  # 减速度
        v0 = v
        s = v0 * t + 0.5 * a * t * t
        current += s
        v = v0 + a * t
        track.append(round(s, 2))
    return track

点选验证码识别

点选验证码要求点击特定区域(如"所有含猫的图片"),解决方案:

  1. 图像预处理:灰度化、二值化、去噪
  2. 目标检测:使用YOLOv5训练猫目标检测模型
  3. 坐标转换:将图像坐标转换为点击坐标

YOLO模型推理代码:

import torch
from PIL import Image
# 加载模型
model = torch.hub.load('ultralytics/yolov5', 'yolov5s')
def detect_cats(image_path):
    results = model(Image.open(image_path))
    detections = results.xyxy[0]  # xyxy格式
    cat_detections = detections[detections[:, 5] == 16]  # 类别16为cat
    return cat_detections[:, :4].tolist()  # 返回坐标列表

坐标转换需考虑页面缩放比例:

def convert_coordinates(x, y, img_width, img_height, page_width, page_height):
    scale_x = page_width / img_width
    scale_y = page_height / img_height
    return int(x * scale_x), int(y * scale_y)

文字验证码识别

文字验证码识别分两种场景:

  • 简单文字:使用Tesseract OCR
  • 复杂干扰:使用CNN模型微调

Tesseract识别代码:

import pytesseract
from PIL import Image
def recognize_text(image_path):
    img = Image.open(image_path)
    # 预处理
    img = img.convert('L')  # 灰度化
    img = img.point(lambda x: 0 if x < 128 else 255)  # 二值化
    # OCR识别
    text = pytesseract.image_to_string(img, config='--psm 7')
    return text.strip()

复杂验证码需使用深度学习模型:

import tensorflow as tf
# 加载预训练模型
model = tf.keras.models.load_model('captcha_model.h5')
def recognize_complex_captcha(image_path):
    img = preprocess_image(image_path)  # 自定义预处理
    prediction = model.predict(img)
    return decode_prediction(prediction)  # 解码为文字

代理方案对比与选型

代理类型分析

类型 优点 缺点 适用场景 成本
免费代理 零成本 存活率<10%,速度慢 测试环境 ¥0/月
住宅代理 IP真实,反爬效果好 成本高,速度中等 电商数据采集 ¥5000/万IP
数据中心代理 速度快,可用性高 易被识别,需轮换 新闻网站抓取 ¥800/万IP
移动代理 IP移动性强,反爬效果佳 成本极高,带宽小 社交平台监控 ¥15000/万IP

代理池架构设计

企业级代理池应包含以下模块:

  • 代理获取模块:集成多个代理供应商API
  • 健康检查模块:每5分钟检测代理可用性
  • 失败惩罚模块:连续失败3次则暂停使用1小时
  • 负载均衡模块:按响应速度动态分配代理
  • 监控告警模块:代理失效率>20%时触发告警

代理健康检查流程:

async def check_proxy(proxy):
    try:
        start = time.time()
        async with aiohttp.ClientSession() as session:
            async with session.get(
                'https://httpbin.org/ip',
                proxy=f'http://{proxy}',
                timeout=10
            ) as resp:
                if resp.status == 200:
                    return {
                        'status': 'valid',
                        'latency': time.time() - start
                    }
        return {'status': 'invalid'}
    except Exception:
        return {'status': 'error'}

代理IP轮换策略

推荐采用动态轮换策略:

  1. 请求频次:单IP每分钟请求≤5次
  2. 连续请求:相同域名连续请求需更换IP
  3. 失败回退:请求失败后自动切换IP
  4. 智能分配:根据目标网站反爬强度分配代理类型

轮换逻辑示例:

class ProxyManager:
    def __init__(self, proxy_pool):
        self.pool = proxy_pool
        self.usage_count = {}
        self.max_requests = 5
    async def get_proxy(self, domain):
        # 检查当前域名使用次数
        if self.usage_count.get(domain, 0) >= self.max_requests:
            self.usage_count[domain] = 0
            return await self._get_new_proxy()
        # 获取可用代理
        proxy = await self.pool.get_proxy()
        if not proxy:
            return await self._get_new_proxy()
        # 更新使用计数
        self.usage_count[domain] = self.usage_count.get(domain, 0) + 1
        return proxy
    async def _get_new_proxy(self):
        self.pool.rotate()  # 强制轮换
        return await self.pool.get_proxy()

主流框架对比分析

Scrapy vs Playwright vs 自研框架

特性 Scrapy Playwright 自研框架
并发能力 ★★★★★ ★★★☆☆ ★★★★☆
动态渲染支持 ★★☆☆☆ ★★★★★ ★★★★☆
反反爬能力 ★★★☆☆ ★★★★☆ ★★★★★
学习曲线 ★★★☆☆ ★★☆☆☆ ★★★★☆
扩展性 ★★★★☆ ★★★☆☆ ★★★★★
适用场景 静态网站批量抓取 动态网站小规模采集 定制化企业级项目

Scrapy高阶技巧

企业级Scrapy项目需集成以下中间件:

  • RandomUserAgentMiddleware:随机User-Agent
  • ProxyMiddleware:代理IP轮换
  • RetryMiddleware:失败重试策略
  • AntiBanMiddleware:反爬对抗逻辑

配置示例:

DOWNLOADER_MIDDLEWARES = {
    'scrapy.downloadermiddlewares.useragent.UserAgentMiddleware': None,
    'myproject.middlewares.RandomUserAgentMiddleware': 400,
    'myproject.middlewares.ProxyMiddleware': 410,
    'myproject.middlewares.RetryMiddleware': 550,
    'myproject.middlewares.AntiBanMiddleware': 560,
}

Spider配置优化:

class ProductSpider(scrapy.Spider):
    name = 'products'
    custom_settings = {
        'DOWNLOAD_DELAY': 1.5,
        'CONCURRENT_REQUESTS': 16,
        'ROBOTSTXT_OBEY': True,
        'COOKIES_ENABLED': False,
        'ITEM_PIPELINES': {
            'myproject.pipelines.DataCleanPipeline': 300,
            'myproject.pipelines.DedupPipeline': 400,
        }
    }

Playwright性能优化

Playwright性能瓶颈主要在浏览器启动,优化策略:

  1. 浏览器复用:创建浏览器实例池
  2. 无头模式:headless=True减少资源消耗
  3. CDP协议:使用page.context.new_cdp_session()绕过DOM操作
  4. 并行执行:使用asyncio.gather()并发请求

浏览器池实现:

class BrowserPool:
    def __init__(self, size=3):
        self.pool = []
        self.size = size
    async def get_browser(self):
        if not self.pool:
            browser = await chromium.launch(headless=True)
            self.pool.append(browser)
        return self.pool[0]
    async def release_browser(self, browser):
        pass  # 浏览器复用不释放

实战案例详解

电商商品数据采集项目

项目背景:某零售企业需监控竞品价格,覆盖100+电商平台,要求:

  • 数据更新频率:每30分钟一次
  • 数据准确率:≥99.5%
  • 单次采集量:50万+商品
  • 响应时间:2小时内完成

技术方案:

  1. 架构设计:Scrapy+Redis分布式集群
  2. 代理方案:住宅代理池(5000+IP)
  3. 反爬策略:随机延迟+Headers混淆+滑块绕过
  4. 数据处理:Kafka消息队列+Spark实时清洗
  5. 监控告警:Prometheus+AlertManager

关键代码片段:

class ProductSpider(scrapy.Spider):
    name = 'product_monitor'
    custom_settings = {
        'DOWNLOAD_DELAY': random.uniform(1.0, 2.5),
        'DOWNLOADER_MIDDLEWARES': {
            'middlewares.RandomUserAgent': 400,
            'middlewares.ProxyMiddleware': 410,
            'middlewares.SliderBypass': 420,
        }
    }
    def parse(self, response):
        # 解析商品列表
        for item in response.css('.product-item'):
            yield {
                'name': item.css('.title::text').get(),
                'price': self._clean_price(item.css('.price::text').get()),
                'stock': self._check_stock(item),
                'rating': self._get_rating(item),
            }
        # 翻页处理
        next_page = response.css('.pagination .next::attr(href)').get()
        if next_page and self.page_count < 50:
            yield response.follow(next_page, callback=self.parse)

项目成果:

  • 数据采集成功率:98.7%
  • 平均更新延迟:28分钟
  • 单日采集量:62万商品
  • 系统可用性:99.95%

社交媒体舆情监控系统

项目挑战:实时监控微博、小红书等平台关键词,需解决:

  • 高频反爬(每IP每秒≤2请求)
  • 动态渲染(SPA架构)
  • 设备指纹识别
  • 法律风险(用户隐私)

解决方案:

  1. 代理方案:移动代理池(IP轮换+轨迹模拟)
  2. 数据采集:Playwright+CDP协议抓取API
  3. 隐私保护:用户ID脱敏+内容过滤
  4. 实时处理:Flink流处理+ES索引

关键代码:

async def scrape_social_media(keyword):
    browser = await launch(headless=True)
    page = await browser.new_page()
    # 隐藏自动化特征
    await page.add_init_script("""
      Object.defineProperty(navigator, 'webdriver', {get: () => undefined});
    """)
    # 请求API
    await page.goto(f'https://example.com/search?q={keyword}')
    await page.wait_for_selector('.post-item')
    # 通过CDP获取API响应
    cdp = await page.context.new_cdp_session(page)
    cdp.send('Network.enable')
    # 监听请求
    async def handle_request(request):
        if 'search' in request.url and request.method == 'GET':
            response = await request.response()
            data = await response.json()
            for post in data['posts']:
                yield {
                    'content': post['content'],
                    'user_id': hash(post['user_id']),  # 脱敏
                    'timestamp': post['timestamp']
                }
    cdp.on('Network.requestWillBeSent', handle_request)
    await browser.close()

高频问题解答

Q1:如何判断网站是否允许爬虫?

A:检查以下三处:

  1. robots.txt文件(如https://example.com/robots.txt)
  2. 网站用户协议(通常在"法律声明"或"服务条款"中)
  3. 页面底部版权声明(如"未经许可禁止抓取")

若三处均未明确禁止,且数据为公开信息,则一般视为允许。但需注意:robots.txt仅具道德约束力,不具备法律效力。

Q2:爬虫被封IP怎么办?

A:分三步处理:

  1. 立即停止请求,避免加剧封禁
  2. 更换IP(使用代理池或重启路由器)
  3. 降低请求频率(建议≥5秒/次)

长期策略:构建多层反爬应对方案,包括代理池、行为模拟、请求指纹混淆等。

Q3:动态加载数据如何抓取?

A:优先级方案:

  1. 分析Network面板,直接抓取API请求(最高效)
  2. 使用Playwright等待DOM加载完成(次优)
  3. JS逆向还原加密逻辑(最复杂)

示例:某网站商品列表通过/api/products?offset=20获取,直接复现该请求即可,无需模拟浏览器渲染。

Q4:爬虫法律风险如何规避?

A:遵循"三不原则":

  • 不绕过技术措施(如破解加密、绕过登录)
  • 不采集敏感数据(个人身份信息、生物特征)
  • 不用于商业盈利(直接销售原始数据)

建议:采集前进行合规评估,使用数据脱敏技术,建立操作日志审计机制。

Q5:Scrapy和Playwright如何选型?

A:参考决策树:

if 网站为静态页面:
    选择 Scrapy(高并发、低资源)
elif 网站含大量动态内容:
    if 数据量小:
        选择 Playwright(易开发、真实渲染)
    else:
        选择 Scrapy + Splash(分布式+渲染)
else:
    选择自研框架(完全定制化)