Python爬虫如何应对内容频繁更新的网页？

对于内容频繁更新的网页，爬虫的关键在于动态适应。核心思路是让爬虫能识别内容变化并调整抓取策略。

1. 智能频率控制 别用固定time.sleep。根据更新规律动态调整：

import time
import random
from datetime import datetime

class AdaptiveCrawler:
    def __init__(self):
        self.base_interval = 60  # 基础间隔
        self.last_change_time = None
        
    def calculate_interval(self, content_changed):
        if content_changed:
            self.last_change_time = datetime.now()
            return random.uniform(10, 30)  # 内容刚更新，稍快检查
        else:
            # 长时间无更新则拉长间隔
            if self.last_change_time:
                idle_time = (datetime.now() - self.last_change_time).seconds
                if idle_time > 300:  # 5分钟无更新
                    return random.uniform(120, 180)
            return random.uniform(self.base_interval, self.base_interval*1.5)

2. 内容变化检测 用哈希或关键特征比对，别傻傻的全文比较：

import hashlib
from difflib import SequenceMatcher

class ContentMonitor:
    def detect_changes(self, old_content, new_content):
        # 方法1：哈希对比
        old_hash = hashlib.md5(old_content.encode()).hexdigest()
        new_hash = hashlib.md5(new_content.encode()).hexdigest()
        
        if old_hash != new_hash:
            # 方法2：相似度分析（针对部分更新）
            similarity = SequenceMatcher(None, old_content, new_content).ratio()
            return similarity < 0.95  # 相似度低于95%认为有实质更新
        
        return False

3. 增量抓取策略 只抓变化的部分，用版本号或时间戳：

class IncrementalCrawler:
    def __init__(self):
        self.last_version = None
        
    def fetch_updates(self, url):
        # 假设API返回带版本号的数据
        response = requests.get(f"{url}?since={self.last_version}")
        data = response.json()
        
        if data['version'] != self.last_version:
            self.last_version = data['version']
            return data['updates']  # 只返回增量内容
        return []

4. 实战示例 结合以上策略的完整流程：

import requests
from bs4 import BeautifulSoup
import json
from typing import Optional

class DynamicPageCrawler:
    def __init__(self, url):
        self.url = url
        self.content_hash = None
        self.session = requests.Session()
        
    def fetch_with_retry(self, max_retries=3):
        for attempt in range(max_retries):
            try:
                resp = self.session.get(self.url, timeout=10)
                resp.raise_for_status()
                return resp.text
            except requests.RequestException as e:
                if attempt == max_retries - 1:
                    raise
                time.sleep(2 ** attempt)  # 指数退避
    
    def run(self, check_interval=60):
        while True:
            try:
                html = self.fetch_with_retry()
                soup = BeautifulSoup(html, 'html.parser')
                
                # 提取核心内容区域
                main_content = soup.find('div', {'class': 'content-area'})
                if not main_content:
                    main_content = soup.body
                
                current_hash = hashlib.md5(str(main_content).encode()).hexdigest()
                
                if self.content_hash != current_hash:
                    print(f"[{datetime.now()}] 检测到内容更新")
                    self.content_hash = current_hash
                    # 处理新内容...
                    
                # 动态调整下次检查时间
                change_detected = self.content_hash != current_hash
                wait_time = self.calculate_interval(change_detected)
                time.sleep(wait_time)
                
            except KeyboardInterrupt:
                break
            except Exception as e:
                print(f"抓取失败: {e}")
                time.sleep(300)  # 出错时长时间等待

关键点总结：

• 用哈希快速检测变化，不是所有网站都适合固定频率
• 优先找增量接口，没有再用内容对比
• 异常时自动退避，别把服务器搞崩了

一句话建议：让爬虫像人一样观察网页变化规律再行动。