Python爬虫零基础入门【第九章：实战项目教学·第8节】限速器进阶:令牌桶 + 动态降速(429/5xx)！

喵手2026-01-26 12:40

🔥本期内容已收录至专栏《Python爬虫实战》，持续完善知识体系与项目实战，建议先订阅收藏，后续查阅更方便～持续更新中！！

全文目录：

    • [🌟 开篇语](#🌟 开篇语)
    • [📌 上期回顾](#📌 上期回顾)
    • [🎯 本期目标](#🎯 本期目标)
    • [💡 为什么需要动态限速?](#💡 为什么需要动态限速?)
    • [🔧 技术方案拆解](#🔧 技术方案拆解)
    • [📝 完整实现](#📝 完整实现)
    • [🔍 代码关键点解析](#🔍 代码关键点解析)
      • [1. 令牌桶的实现技巧](#1. 令牌桶的实现技巧)
      • [2. 降速要狠,提速要慢](#2. 降速要狠,提速要慢)
      • [3. 暂停机制](#3. 暂停机制)
      • [4. 线程安全](#4. 线程安全)
    • [📊 实战验收](#📊 实战验收)
    • [🎨 进阶优化方向](#🎨 进阶优化方向)
      • [1. 分布式限速](#1. 分布式限速)
      • [2. 更智能的提速策略](#2. 更智能的提速策略)
      • [3. 指标持久化](#3. 指标持久化)
      • [4. 优雅退出](#4. 优雅退出)
    • [⚠️ 常见坑点](#⚠️ 常见坑点)
      • [1. 不要过度限速](#1. 不要过度限速)
      • [2. 日志洪水](#2. 日志洪水)
      • [3. 时钟问题](#3. 时钟问题)
    • [💼 实际应用场景](#💼 实际应用场景)
    • [🎯 本期总结](#🎯 本期总结)
    • [📖 下期预告](#📖 下期预告)
    • [🌟 文末](#🌟 文末)
      • [📌 专栏持续更新中｜建议收藏 + 订阅](#📌 专栏持续更新中｜建议收藏 + 订阅)
      • [✅ 互动征集](#✅ 互动征集)

🌟 开篇语

哈喽，各位小伙伴们你们好呀～我是【喵手】。

运营社区： C站 / 掘金 / 腾讯云 / 阿里云 / 华为云 / 51CTO

欢迎大家常来逛逛，一起学习，一起进步～🌟

我长期专注 Python 爬虫工程化实战 ，主理专栏 👉 《Python爬虫实战》：从采集策略 到反爬对抗 ，从数据清洗 到分布式调度 ，持续输出可复用的方法论与可落地案例。内容主打一个"能跑、能用、能扩展 "，让数据价值真正做到------抓得到、洗得净、用得上。

📌 专栏食用指南（建议收藏）

  • ✅ 入门基础：环境搭建 / 请求与解析 / 数据落库
  • ✅ 进阶提升：登录鉴权 / 动态渲染 / 反爬对抗
  • ✅ 工程实战：异步并发 / 分布式调度 / 监控与容错
  • ✅ 项目落地：数据治理 / 可视化分析 / 场景化应用

📣 专栏推广时间 ：如果你想系统学爬虫，而不是碎片化东拼西凑，欢迎订阅/关注专栏《Python爬虫实战》

订阅后更新会优先推送，按目录学习更高效～

📌 上期回顾

上一期《Python爬虫零基础入门【第九章：实战项目教学·第7节】增量采集：last_time / last_id 两种策略各做一遍！》我们实现了增量采集的两种策略------基于时间戳和基于ID的方案。通过维护状态文件,让爬虫变得"聪明"起来,知道从哪里继续抓,避免重复劳动。但光知道抓什么还不够,怎么抓得既快又稳才是真功夫。

想象你在高速公路上开车,油门踩太猛容易出事故,太慢又浪费时间。爬虫也一样------请求发太快会被服务器拉黑(429错误),太慢又效率低下。今天咱们就来解决这个"油门控制"的问题。

🎯 本期目标

这一期你会得到:

  • 令牌桶限速器:比固定延迟更灵活的流量控制方案
  • 动态降速机制:遇到429/5xx自动刹车,恢复后再提速
  • 可观测指标:实时监控QPS、错误率、降速次数
  • 生产级代码:带完整日志、配置、异常处理的工程化实现

验收标准很简单:跑起来后,即使触发对方限流,你的爬虫也能自己"悬崖勒马"然后稳稳恢复,全程不把对方服务器打爆💥

💡 为什么需要动态限速?

固定延迟的尴尬

很多新手的限速方式是这样的:

python 复制代码 
for url in urls:
    fetch(url)
    time.sleep(1)  # 固定等1秒

这种方法有三个硬伤:

  1. 太僵硬:服务器状态会变化,你却一成不变
  2. 浪费时间:凌晨3点服务器空闲,你还在傻傻等1秒
  3. 没防护:真遇到429了,继续1秒一发只会越陷越深

真实世界的复杂性

实际采集中你会遇到:

  • 业务高峰期(白天)限流更严格
  • 突发流量导致服务器临时抽风
  • CDN节点差异导致某些IP被重点"照顾"
  • 网站反爬策略升级,之前的节奏突然不行了

**静态配置应对不了动态变化。**你需要一个会"察言观色"的限速器。

🔧 技术方案拆解

方案一:令牌桶算法(Token Bucket)

核心思想:用令牌控制请求权

想象有个桶,每秒往里丢N个令牌(比如5个),每次请求消耗1个令牌:

  • 桶里有令牌→立即执行请求
  • 桶空了→等待新令牌生成
  • 桶满了→新令牌丢弃(保持上限)

优势:

  • 允许短时"突发"(积攒的令牌可以一次用掉)
  • 长期平均速率可控
  • 实现简单,性能好

方案二:动态降速策略

监控响应状态码,按规则调整速率:

复制代码 
429(限流) → 立即降速50%,暂停30秒
5xx(服务器错误) → 降速30%,暂停10秒
连续成功100次 → 尝试恢复10%速率(不超过初始值)

关键点:降速要狠,提速要慢。就像开车,刹车要快,加速要稳。

方案三:可观测指标

实时记录:

  • 当前QPS(每秒请求数)
  • 429/5xx触发次数
  • 降速/恢复事件时间线
  • 令牌桶状态(当前令牌数/容量)

这些数据不仅用于调试,还能帮你优化配置参数。

📝 完整实现

整体架构说明

我们会实现三个核心类:

  1. TokenBucket:令牌桶限速器核心
  2. AdaptiveRateLimiter:自适应限速器(包装TokenBucket+动态调整逻辑)
  3. RateLimitedClient:HTTP客户端(集成限速器+重试+指标)

数据流向:

复制代码 
发起请求 → 限速器检查令牌 → 执行HTTP请求 → 根据响应调整速率 → 记录指标

代码实现

python 复制代码 
"""
高级限速器实现
包含:令牌桶、动态降速、指标监控
"""
import time
import threading
import logging
from typing import Optional, Dict, Any
from dataclasses import dataclass, field
from collections import deque
from datetime import datetime
import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

# 配置日志
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s [%(levelname)s] %(name)s: %(message)s'
)
logger = logging.getLogger(__name__)


@dataclass
class RateLimitConfig:
    """限速器配置"""
    initial_rate: float = 5.0  # 初始QPS
    min_rate: float = 0.5      # 最低QPS(降速下限)
    max_rate: float = 10.0     # 最高QPS(提速上限)
    
    # 降速策略
    throttle_on_429: float = 0.5    # 遇429降速比例(50%)
    throttle_on_5xx: float = 0.7    # 遇5xx降速比例(30%)
    pause_on_429: float = 30.0      # 遇429暂停秒数
    pause_on_5xx: float = 10.0      # 遇5xx暂停秒数
    
    # 恢复策略
    recovery_threshold: int = 100    # 连续成功N次后尝试提速
    recovery_rate: float = 1.1       # 提速比例(10%)
    
    # 令牌桶参数
    bucket_capacity: int = 10        # 桶容量(允许短时突发)


@dataclass
class RateLimitMetrics:
    """限速器指标"""
    total_requests: int = 0
    total_429: int = 0
    total_5xx: int = 0
    total_throttles: int = 0  # 降速次数
    total_recoveries: int = 0  # 提速次数
    
    current_rate: float = 0.0
    consecutive_success: int = 0
    
    # 滑动窗口统计(最近60秒)
    recent_requests: deque = field(default_factory=lambda: deque(maxlen=60))
    
    def add_request(self, success: bool, status_code: Optional[int] = None):
        """记录请求"""
        self.total_requests += 1
        self.recent_requests.append({
            'time': time.time(),
            'success': success,
            'status': status_code
        })
        
        if success:
            self.consecutive_success += 1
        else:
            self.consecutive_success = 0
            if status_code == 429:
                self.total_429 += 1
            elif status_code and 500 <= status_code < 600:
                self.total_5xx += 1
    
    def get_recent_qps(self) -> float:
        """计算最近实际QPS"""
        if not self.recent_requests:
            return 0.0
        
        now = time.time()
        recent = [r for r in self.recent_requests if now - r['time'] <= 60]
        return len(recent) / 60.0 if recent else 0.0
    
    def to_dict(self) -> Dict[str, Any]:
        """导出指标"""
        return {
            'total_requests': self.total_requests,
            'total_429': self.total_429,
            'total_5xx': self.total_5xx,
            'total_throttles': self.total_throttles,
            'total_recoveries': self.total_recoveries,
            'current_rate': round(self.current_rate, 2),
            'recent_qps': round(self.get_recent_qps(), 2),
            'consecutive_success': self.consecutive_success
        }


class TokenBucket:
    """
    令牌桶限速器
    
    原理:
    - 每秒产生rate个令牌
    - 每次请求消耗1个令牌
    - 桶容量上限为capacity
    """
    
    def __init__(self, rate: float, capacity: int):
        """
        Args:
            rate: 每秒生成令牌数(即QPS)
            capacity: 桶容量
        """
        self.rate = rate
        self.capacity = capacity
        self.tokens = capacity  # 初始满桶
        self.last_update = time.time()
        self.lock = threading.Lock()
    
    def update_rate(self, new_rate: float):
        """动态调整速率"""
        with self.lock:
            self.rate = new_rate
            logger.info(f"令牌桶速率调整为: {new_rate:.2f} tokens/s")
    
    def _add_tokens(self):
        """补充令牌(内部方法)"""
        now = time.time()
        elapsed = now - self.last_update
        
        # 计算应补充的令牌数
        new_tokens = elapsed * self.rate
        self.tokens = min(self.capacity, self.tokens + new_tokens)
        self.last_update = now
    
    def acquire(self, tokens: int = 1) -> float:
        """
        获取令牌(阻塞直到成功)
        
        Returns:
            等待时间(秒)
        """
        wait_time = 0.0
        
        with self.lock:
            self._add_tokens()
            
            # 令牌不足,计算需要等待的时间
            if self.tokens < tokens:
                deficit = tokens - self.tokens
                wait_time = deficit / self.rate
                
                # 等待期间不持有锁(避免阻塞其他线程)
                # 这里简化处理,生产环境可用Condition实现
                pass
            
            # 消耗令牌
            self.tokens -= tokens
        
        # 实际等待
        if wait_time > 0:
            time.sleep(wait_time)
        
        return wait_time
    
    def try_acquire(self, tokens: int = 1) -> bool:
        """
        尝试获取令牌(非阻塞)
        
        Returns:
            是否成功获取
        """
        with self.lock:
            self._add_tokens()
            
            if self.tokens >= tokens:
                self.tokens -= tokens
                return True
            return False


class AdaptiveRateLimiter:
    """
    自适应限速器
    
    功能:
    - 基于令牌桶的基础限速
    - 遇到429/5xx自动降速
    - 连续成功后尝试恢复
    """
    
    def __init__(self, config: Optional[RateLimitConfig] = None):
        self.config = config or RateLimitConfig()
        self.metrics = RateLimitMetrics()
        
        # 初始化令牌桶
        self.bucket = TokenBucket(
            rate=self.config.initial_rate,
            capacity=self.config.bucket_capacity
        )
        
        self.current_rate = self.config.initial_rate
        self.metrics.current_rate = self.current_rate
        
        self.lock = threading.Lock()
        logger.info(f"限速器初始化: {self.config.initial_rate} QPS")
    
    def acquire(self):
        """获取执行权限"""
        self.bucket.acquire()
    
    def report_result(self, success: bool, status_code: Optional[int] = None):
        """
        报告请求结果,触发动态调整
        
        Args:
            success: 是否成功
            status_code: HTTP状态码
        """
        with self.lock:
            self.metrics.add_request(success, status_code)
            
            # 降速逻辑
            if status_code == 429:
                self._throttle(
                    reason="429 Too Many Requests",
                    factor=self.config.throttle_on_429,
                    pause=self.config.pause_on_429
                )
            elif status_code and 500 <= status_code < 600:
                self._throttle(
                    reason=f"5xx Server Error ({status_code})",
                    factor=self.config.throttle_on_5xx,
                    pause=self.config.pause_on_5xx
                )
            
            # 恢复逻辑
            elif success and self.metrics.consecutive_success >= self.config.recovery_threshold:
                self._try_recovery()
    
    def _throttle(self, reason: str, factor: float, pause: float):
        """降速"""
        old_rate = self.current_rate
        new_rate = max(self.config.min_rate, old_rate * factor)
        
        self.current_rate = new_rate
        self.bucket.update_rate(new_rate)
        self.metrics.total_throttles += 1
        self.metrics.current_rate = new_rate
        
        logger.warning(
            f"🚨 降速触发 | 原因:{reason} | "
            f"{old_rate:.2f} -> {new_rate:.2f} QPS | "
            f"暂停{pause}秒"
        )
        
        # 暂停一段时间
        time.sleep(pause)
    
    def _try_recovery(self):
        """尝试提速恢复"""
        if self.current_rate >= self.config.max_rate:
            return  # 已达上限
        
        old_rate = self.current_rate
        new_rate = min(self.config.max_rate, old_rate * self.config.recovery_rate)
        
        # 只在有实际提升时才调整
        if new_rate > old_rate:
            self.current_rate = new_rate
            self.bucket.update_rate(new_rate)
            self.metrics.total_recoveries += 1
            self.metrics.current_rate = new_rate
            self.metrics.consecutive_success = 0  # 重置计数
            
            logger.info(
                f"✅ 提速恢复 | {old_rate:.2f} -> {new_rate:.2f} QPS | "
                f"连续成功{self.config.recovery_threshold}次"
            )
    
    def get_metrics(self) -> Dict[str, Any]:
        """获取当前指标"""
        return self.metrics.to_dict()


class RateLimitedClient:
    """
    带限速的HTTP客户端
    
    集成:限速器 + 重试 + 指标
    """
    
    def __init__(
        self,
        rate_limiter: Optional[AdaptiveRateLimiter] = None,
        max_retries: int = 3,
        timeout: int = 10
    ):
        self.rate_limiter = rate_limiter or AdaptiveRateLimiter()
        
        # 配置Session
        self.session = requests.Session()
        
        # 重试策略(只重试网络错误,不重试HTTP错误)
        retry_strategy = Retry(
            total=max_retries,
            backoff_factor=1,
            status_forcelist=[],  # 不自动重试HTTP错误
            allowed_methods=["GET", "POST", "PUT"]
        )
        
        adapter = HTTPAdapter(max_retries=retry_strategy)
        self.session.mount("http://", adapter)
        self.session.mount("https://", adapter)
        
        self.timeout = timeout
        
        logger.info("HTTP客户端初始化完成")
    
    def get(self, url: str, **kwargs) -> requests.Response:
        """
        执行GET请求(带限速)
        
        Args:
            url: 目标URL
            **kwargs: 传递给requests.get的其他参数
        
        Returns:
            Response对象
        
        Raises:
            可能抛出requests异常
        """
        # 1. 限速检查(阻塞等待)
        self.rate_limiter.acquire()
        
        # 2. 执行请求
        try:
            response = self.session.get(
                url,
                timeout=kwargs.pop('timeout', self.timeout),
                **kwargs
            )
            
            # 3. 报告结果
            success = response.status_code < 400
            self.rate_limiter.report_result(success, response.status_code)
            
            # 4. 检查是否需要手动重试(429/5xx已触发降速)
            if not success:
                logger.warning(f"请求失败: {url} | 状态码:{response.status_code}")
            
            return response
        
        except requests.RequestException as e:
            # 网络错误
            self.rate_limiter.report_result(False, None)
            logger.error(f"请求异常: {url} | {type(e).__name__}: {e}")
            raise
    
    def get_metrics(self) -> Dict[str, Any]:
        """获取限速器指标"""
        return self.rate_limiter.get_metrics()
    
    def print_metrics(self):
        """打印可读指标"""
        metrics = self.get_metrics()
        print("\n" + "="*50)
        print("📊 限速器指标报告")
        print("="*50)
        print(f"总请求数:      {metrics['total_requests']}")
        print(f"429错误:       {metrics['total_429']}")
        print(f"5xx错误:       {metrics['total_5xx']}")
        print(f"降速次数:      {metrics['total_throttles']}")
        print(f"提速次数:      {metrics['total_recoveries']}")
        print(f"当前速率:      {metrics['current_rate']} QPS")
        print(f"实际QPS:       {metrics['recent_qps']} (最近60秒)")
        print(f"连续成功:      {metrics['consecutive_success']}")
        print("="*50 + "\n")


# =============================================================================
# 使用示例
# =============================================================================

def demo_basic_usage():
    """示例1:基础用法"""
    print("\n🔹 示例1:基础限速")
    
    client = RateLimitedClient()
    
    # 模拟采集
    urls = [f"https://httpbin.org/delay/0" for _ in range(10)]
    
    for i, url in enumerate(urls, 1):
        try:
            response = client.get(url)
            print(f"[{i}/10] {response.status_code} | QPS: {client.get_metrics()['current_rate']}")
        except Exception as e:
            print(f"[{i}/10] 失败: {e}")
    
    client.print_metrics()


def demo_adaptive_throttle():
    """示例2:自适应降速(模拟429)"""
    print("\n🔹 示例2:自适应降速")
    
    # 配置更激进的参数方便演示
    config = RateLimitConfig(
        initial_rate=3.0,
        min_rate=0.5,
        max_rate=5.0,
        recovery_threshold=5  # 5次成功就尝试提速
    )
    
    client = RateLimitedClient(
        rate_limiter=AdaptiveRateLimiter(config)
    )
    
    # 模拟:前10次正常,第11次触发429,后续恢复
    test_cases = [
        ("https://httpbin.org/status/200", 200),  # 正常
        ("https://httpbin.org/status/200", 200),
        ("https://httpbin.org/status/200", 200),
        ("https://httpbin.org/status/429", 429),  # 触发降速
        ("https://httpbin.org/status/200", 200),  # 降速后恢复
        ("https://httpbin.org/status/200", 200),
        ("https://httpbin.org/status/200", 200),
        ("https://httpbin.org/status/200", 200),
        ("https://httpbin.org/status/200", 200),  # 连续成功,可能提速
    ]
    
    for i, (url, expected) in enumerate(test_cases, 1):
        try:
            response = client.get(url)
            metrics = client.get_metrics()
            print(
                f"[{i}] 状态:{response.status_code} | "
                f"QPS:{metrics['current_rate']:.2f} | "
                f"连续成功:{metrics['consecutive_success']}"
            )
        except Exception as e:
            print(f"[{i}] 异常: {e}")
        
        time.sleep(0.5)  # 稍微间隔,方便观察
    
    client.print_metrics()


def demo_production_scenario():
    """示例3:生产场景模拟"""
    print("\n🔹 示例3:生产场景")
    
    config = RateLimitConfig(
        initial_rate=5.0,
        min_rate=1.0,
        max_rate=10.0,
        recovery_threshold=20
    )
    
    client = RateLimitedClient(
        rate_limiter=AdaptiveRateLimiter(config),
        max_retries=2,
        timeout=5
    )
    
    # 模拟真实采集场景
    success_count = 0
    fail_count = 0
    
    print("开始采集100个URL...")
    start_time = time.time()
    
    for i in range(1, 101):
        try:
            # 实际使用时替换为真实URL
            response = client.get("https://httpbin.org/delay/0")
            
            if response.status_code == 200:
                success_count += 1
            else:
                fail_count += 1
            
            # 每20次打印一次进度
            if i % 20 == 0:
                metrics = client.get_metrics()
                print(
                    f"进度:{i}/100 | 成功:{success_count} | "
                    f"失败:{fail_count} | QPS:{metrics['current_rate']:.2f}"
                )
        
        except Exception as e:
            fail_count += 1
            logger.error(f"请求{i}失败: {e}")
    
    elapsed = time.time() - start_time
    
    print(f"\n✅ 采集完成!")
    print(f"总耗时: {elapsed:.2f}秒")
    print(f"成功: {success_count}, 失败: {fail_count}")
    print(f"平均速度: {100/elapsed:.2f} req/s")
    
    client.print_metrics()


if __name__ == "__main__":
    # 运行示例
    demo_basic_usage()
    # demo_adaptive_throttle()  # 取消注释运行
    # demo_production_scenario()  # 取消注释运行

🔍 代码关键点解析

1. 令牌桶的实现技巧

python 复制代码 
def _add_tokens(self):
    now = time.time()
    elapsed = now - self.last_update
    new_tokens = elapsed * self.rate  # 关键:时间差 × 速率
    self.tokens = min(self.capacity, self.tokens + new_tokens)

不是定时器,而是"按需计算"。每次acquire时才更新令牌数,避免额外线程开销。

2. 降速要狠,提速要慢

python 复制代码 
# 降速:立即 × 0.5
new_rate = max(min_rate, old_rate * 0.5)

# 提速:需要连续100次成功,且只 × 1.1
if consecutive_success >= 100:
    new_rate = min(max_rate, old_rate * 1.1)

这个不对称设计很重要------宁可慢点稳定,也不要频繁触发限流。

3. 暂停机制

python 复制代码 
if status_code == 429:
    time.sleep(30)  # 暂停30秒冷静一下

遇到429不是简单降速就完事,还要停一会儿,给服务器恢复的时间。

4. 线程安全

所有状态修改都用with self.lock保护,支持多线程并发调用。

📊 实战验收

运行测试

bash 复制代码 
python rate_limiter_advanced.py

预期输出

复制代码 
[1/10] 200 | QPS: 5.0
[2/10] 200 | QPS: 5.0
...
🚨 降速触发 | 原因:429 Too Many Requests | 5.0 -> 2.5 QPS | 暂停30秒
...
✅ 提速恢复 | 2.5 -> 2.75 QPS | 连续成功100次

验收标准

  • 正常情况下按初始速率运行
  • 遇到429能立即降速并暂停
  • 恢复后能逐步提速
  • 指标统计准确(429次数、降速次数等)
  • 多线程环境不崩溃

🎨 进阶优化方向

1. 分布式限速

当前实现是单机版,如果多台机器跑同一个目标,需要共享限速状态:

  • 用Redis的INCR + EXPIRE实现分布式计数器
  • 或者用Redis的Lua脚本实现分布式令牌桶

2. 更智能的提速策略

目前是"连续N次成功就提速",可以改进为:

  • 监控响应时间,如果RT变长说明服务器压力大,暂缓提速
  • 根据时段调整(凌晨可以更激进)

3. 指标持久化

把RateLimitMetrics定期保存到文件或数据库,用于:

  • 长期趋势分析
  • A/B测试不同参数配置
  • 告警规则(429次数/小时超阈值)

4. 优雅退出

当前如果程序中断,正在等待的令牌会丢失。可以:

  • 捕获SIGTERM信号
  • 将当前限速状态保存
  • 下次启动时恢复

⚠️ 常见坑点

1. 不要过度限速

有同学担心被封,把初始QPS设成0.1,结果100个URL要跑16分钟...
建议:从保守值(比如2 QPS)开始,观察一段时间后再调整。

2. 日志洪水

降速事件很重要,但别每次都打WARNING。可以改成:

python 复制代码 
# 同一小时内同类降速只记录首次
if not self._throttled_this_hour.get(reason):
    logger.warning(...)
    self._throttled_this_hour[reason] = True

3. 时钟问题

time.time()在某些环境下可能不准(比如虚拟机时钟漂移)。生产环境建议:

  • 用time.monotonic()代替(不受系统时间调整影响)
  • 或者依赖外部时钟服务

💼 实际应用场景

场景1:多源聚合采集

你要同时采10个站点,每个站点限流规则不同:

python 复制代码 
# 为每个站点创建独立限速器
limiters = {
    'site_a': AdaptiveRateLimiter(RateLimitConfig(initial_rate=10)),
    'site_b': AdaptiveRateLimiter(RateLimitConfig(initial_rate=2)),
}

def fetch(site, url):
    limiter = limiters[site]
    limiter.acquire()
    # ... 执行请求

场景2:搜索引擎爬虫

搜索引擎对爬虫很敏感,需要更保守的策略:

python 复制代码 
config = RateLimitConfig(
    initial_rate=1.0,      # 起步很慢
    max_rate=3.0,          # 上限也不高
    recovery_threshold=200 # 200次成功才提速
)

场景3:电商价格监控

需要高频采集(每分钟),但又要避开业务高峰:

python 复制代码 
# 根据时段动态调整基础速率
hour = datetime.now().hour
if 9 <= hour <= 22:  # 白天降速
    base_rate = 2.0
else:  # 夜间提速
    base_rate = 5.0

config = RateLimitConfig(initial_rate=base_rate, ...)

🎯 本期总结

今天我们实现了一个生产级的自适应限速器:

✅ 令牌桶算法 :平滑限速,允许短时突发

✅ 动态降速 :遇到429/5xx自动刹车

✅ 渐进恢复 :连续成功后小心翼翼地提速

✅ 可观测性 :详尽的指标统计

✅ 线程安全:支持并发场景

核心思想就一句话:让爬虫像老司机一样,会根据路况随时调整车速🚗

这套机制不仅能防止被封,还能在安全范围内跑出最高效率。更重要的是,有了指标数据,你可以不断优化参数,找到"效率"和"安全"的最佳平衡点。

📖 下期预告

9-09｜可观测性:日志规范 + trace_id + 可复现错误包

限速器帮你控住了速度,但爬虫出问题时,你还需要快速定位原因。下一期我们聊:

  • 如何设计结构化日志(JSON格式,方便检索)
  • trace_id全链路追踪(一个请求从发起到入库的完整日志)
  • 错误现场打包(HTML原文+请求参数+异常栈,一键复现)

有了这套"黑匣子",任何问题都能快速回溯,再也不用盯着日志发呆了

作业(可选):

  1. 运行demo,观察降速和恢复过程
  2. 调整recovery_threshold参数,看提速速度的变化
  3. 尝试用Redis改造成分布式限速器(提示:INCR+TTL)

有问题随时在评论区讨论,咱们下期见!

🌟 文末

好啦～以上就是本期 《Python爬虫实战》的全部内容啦！如果你在实践过程中遇到任何疑问，欢迎在评论区留言交流，我看到都会尽量回复～咱们下期见！

小伙伴们在批阅的过程中，如果觉得文章不错，欢迎点赞、收藏、关注哦～
三连就是对我写作道路上最好的鼓励与支持！ ❤️🔥

📌 专栏持续更新中｜建议收藏 + 订阅

专栏 👉 《Python爬虫实战》，我会按照"入门 → 进阶 → 工程化 → 项目落地"的路线持续更新，争取让每一篇都做到：

✅ 讲得清楚（原理）｜✅ 跑得起来（代码）｜✅ 用得上（场景）｜✅ 扛得住（工程化）

📣 想系统提升的小伙伴：强烈建议先订阅专栏，再按目录顺序学习，效率会高很多～

✅ 互动征集

想让我把【某站点/某反爬/某验证码/某分布式方案】写成专栏实战？

评论区留言告诉我你的需求，我会优先安排更新 ✅

⭐️ 若喜欢我，就请关注我叭～（更新不迷路）

⭐️ 若对你有用，就请点赞支持一下叭～（给我一点点动力）

⭐️ 若有疑问，就请评论留言告诉我叭～（我会补坑 & 更新迭代）

免责声明：本文仅用于学习与技术研究，请在合法合规、遵守站点规则与 Robots 协议的前提下使用相关技术。严禁将技术用于任何非法用途或侵害他人权益的行为。

相关推荐
深度学习lover2 小时前
＜项目代码＞yolo毛毛虫识别＜目标检测＞
人工智能·python·yolo·目标检测·计算机视觉·毛毛虫识别
喵手2 小时前
Python爬虫零基础入门【第九章：实战项目教学·第3节】通用清洗工具包：日期/金额/单位/空值（可复用）！
爬虫·python·python爬虫实战·python爬虫工程化实战·python爬虫零基础入门·通用清洗工具包·爬虫实战项目
b2077212 小时前
Flutter for OpenHarmony 身体健康状况记录App实战 - 体重趋势实现
python·flutter·harmonyos
喵手2 小时前
Python爬虫零基础入门【第九章：实战项目教学·第4节】质量报告自动生成：缺失率/重复率/异常值 TopN！
爬虫·python·爬虫实战·python爬虫工程化实战·零基础python爬虫教学·实战项目教学·质量报告自动生成
b2077212 小时前
Flutter for OpenHarmony 身体健康状况记录App实战 - 个人中心实现
android·java·python·flutter·harmonyos
喵手2 小时前
Python爬虫零基础入门【第九章：实战项目教学·第7节】增量采集：last_time / last_id 两种策略各做一遍！
爬虫·python·爬虫实战·python爬虫工程化实战·零基础python爬虫教学·增量采集·策略采集
子午2 小时前
【2026计算机毕设】水果识别分类系统~python+深度学习+人工智能+算法模型+TensorFlow
人工智能·python·深度学习
No0d1es2 小时前
2023年NOC大赛创客智慧编程赛项Python复赛模拟题（二）
python·青少年编程·noc·复赛·模拟题
SmartRadio2 小时前
ESP32-S3实现KVM远控+云玩功能 完整方案
运维·python·计算机外设·esp32·kvm·云玩
热门推荐
01GitHub 镜像站点02OpenCode 入门教程：介绍 · 安装 · 配置第三方 API (如 Claude)03Claude Code Skills 实用使用手册04Open Code教程（四）| 高级配置与集成05UV安装并设置国内源06Linux下V2Ray安装配置指南07在VSCode配置Java开发环境的保姆级教程（适配各类AI编程IDE）08安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）09MC.JS 网页版《我的世界》 免安装中文版10BongoCat - 跨平台键盘猫动画工具