第 11 讲 · 工程化四件套:让爬虫「跑一整晚不出事」
本讲目标 :把「跑演示能用」的脚本,变成「敢让它无人值守跑一整晚」的工程。
四件套:日志、重试、限速、断点续爬。它们不是优化,是及格线。
配套代码 :
spiders/s11_engineering.py运行 :
python spiders/s11_engineering.py本讲产物 :
data/spider.log(全量运行日志)、data/s11_progress.json(断点状态)
---下载地址:git clone https://gitee.com/wuyikui555/python-spider.git
一、日志:出事了要知道「当时在干什么」
前几讲的代码跑 50 条没问题,跑 5 万条就会暴露第一个问题:出错了不知道哪一步挂的。
爬虫和普通脚本最大的不同是------它的「输入」在网络上,是一个你控制不了、也进不去的别人的服务器。出了问题,你没法在对方机器上打断点。唯一能还原现场的,就是日志。
本工程的日志设计有两条规矩:
日志分两级去处:
控制台 → 只给「现在」看(安静模式下压到 WARNING)
文件 → 全量留档,事后复盘靠它
日志文件:C:\Users\28003\WorkBuddy\2026-10-09-20-13-37\outputs\python-spider\data\spider.log
★ 爬虫的 bug 大多发生在「别人家服务器」上,你没法断点调试。
唯一能还原现场的,就是「第几次请求、哪个 URL、什么状态码」这三样。
实现就在 utils/log.py,一次配置、控制台和文件各挂一个 handler:
python
logger.setLevel(logging.INFO)
fmt = logging.Formatter("%(asctime)s [%(levelname)s] %(message)s", datefmt="%H:%M:%S")
# 控制台:批处理模式下只留 WARNING 以上,别把结果表冲掉
sh = logging.StreamHandler(sys.stdout)
sh.setFormatter(fmt)
sh.setLevel(logging.WARNING if quiet() else logging.INFO)
logger.addHandler(sh)
# 文件:永远记全量,方便事后复查
fh = logging.FileHandler(LOG_FILE, encoding="utf-8")
fh.setFormatter(fmt)
logger.addHandler(fh)
这就是「控制台安静、文件全量」的落地方式------批处理(SPIDER_QUIET=1)时控制台只留 WARNING,但文件里一条不少。
为什么不用 print
python
log.info("这是一条 INFO:请求成功、数据正常,平时不必看")
log.warning("这是一条 WARNING:拿到了数据但字段缺失,得留意")
实测输出(日志按级别过滤,WARNING 才上控制台):
这是一条 WARNING:拿到了数据但字段缺失,得留意
print 和 log 的区别,是新手最容易忽略的一处:
print |
logging |
|
|---|---|---|
| 级别 | 没有 | INFO/WARNING/ERROR...,可按需过滤 |
| 时间戳 | 要自己拼 | 自动带 |
| 去处 | 只会往 stdout 打 | 同时写控制台和文件 |
| 关掉 | 得删代码 | 调 level 或环境变量 |
记住那个三件套:第几次请求、哪个 URL、什么状态码。 有了它,你才能回答「是第 3000 条开始出问题的,还是从头就错」。
二、重试:只重试「值得重试」的错误
第二个问题:网络抖一下,数据就丢了。重试能救,但不能不问青红皂白地重试。
python
c = HttpClient(base_url=base_url, timeout=5, retries=3)
for i in range(1, 6):
r = c.get("/api/limit")
print(f" 第 {i} 次 → {r.status_code}")
print(f" 统计:{c.stats}")
实测输出:
第 1 次 → 200
第 2 次 → 200
第 3 次 → 200
第 4 次 → 429
第 5 次 → 429
统计:{'requests': 9, 'retries': 4, 'errors': 0}
注意 requests: 9------我们明明只调了 5 次 get()。 多出来的 4 次,就是 HttpClient 在 429 时自动重试打出去的。而 retries: 4 说明它确实退了、等了、又试了。
重试策略的关键,是分清哪些错误值得重试:
重试策略对照表:
429 限流 → 重试(读 Retry-After,退避等待)
500/502/503 → 重试(对方临时抽风)
403/404 → 不重试(再试一万次也是这个结果)
连接异常 → 重试(网络抖动,最常见)
落到代码里就是两道开关(utils/http.py):
python
# 只有"服务端暂时有问题"才重试;400/403/404 重试只是白费力气
if resp.status_code in (429, 500, 502, 503, 504) and attempt < self.retries:
delay = self._retry_delay(resp, attempt)
self.stats["retries"] += 1
time.sleep(delay)
continue
退避时间也不是拍脑袋,而是优先听服务器的:
python
@staticmethod
def _retry_delay(resp, attempt):
after = resp.headers.get("Retry-After")
if after and after.isdigit():
return min(float(after), 10.0) # 服务器让等多久就等多久(封顶 10s)
return min(0.5 * 2 ** (attempt - 1), 5.0) # 否则 0.5s / 1s / 2s ... 封顶 5s
为什么要有退避(backoff)? 因为对方是限流,你越快重试,越是被限。指数退避把重试间隔越拉越大,给对方喘口气。但要清醒地认识到:
退避只能缓解限流,治不了限流。 如果每秒都被 429,说明你的频率本身就超标了------那是第③节「限速」要解决的问题。
一个关于 POST 的提醒
utils/http.py 里显式把 POST 加进了可重试方法:
python
retry = Retry(total=0, connect=retries, read=retries,
backoff_factor=0.4, allowed_methods=frozenset(["GET", "POST"]))
urllib3 默认只重试幂等方法 (GET/PUT/DELETE/HEAD),POST 默认不重试------因为「提交两次」可能造成重复订单。本工程敢让 POST 重试,是因为靶场的提交接口是幂等的(第 13 讲的 /submit)。换成真实站点,重试 POST 前你必须先确认它幂等,否则宁可让它失败。
三、限速:礼貌,也是保命
第三个问题,也是最容易被忽视的:你把对方的网站打崩了,或者把自己的 IP 封了。
限速器本身很朴素------「两次操作之间至少间隔 interval 秒」:
python
for interval in (0.0, 0.2):
limiter = RateLimiter(interval)
c = HttpClient(base_url=base_url, timeout=5)
t0 = time.time()
n = 6
for i in range(n):
limiter.wait()
c.get(f"/book/{i + 1}")
dt = time.time() - t0
print(f" 间隔 {interval:.2f}s 跑 {n} 次详情页 用时 {dt:.2f}s")
实测输出:
间隔 0.00s 跑 6 次详情页 用时 0.17s
间隔 0.20s 跑 6 次详情页 用时 1.03s
(只调 wait()、不发请求:1.00s,可以看出 5 个间隔 × 0.2s = 1.0s)
先看最后一行:只调 wait() 不发请求,耗时正好 1.00s ------6 次 wait() 里有 5 个「间隔」,5 × 0.2s = 1.0s。这说明限速器本身没毛病。
再看前两行:
- 间隔 0.00s,6 个请求用了 0.17s;
- 间隔 0.20s,6 个请求用了 1.03s。
0.17s ÷ 6 ≈ 每个请求本身只要 28ms。所以当间隔 0.20s 远大于 28ms 时,限速生效,总时间被拉到 1s 左右(1.0s 等待 + 0.03s 请求)。
反直觉的点一:单请求比间隔慢时,限速等于没有
假如换成「间隔 0.02s」呢?单个请求本来就要 28ms,而限速要求「距上次 ≥ 20ms」------28ms 早就超过了 20ms,限速器一次都不用等。你设了限速,总时间却几乎没变。
限速器只在「请求快过间隔」时才起作用。 如果你单请求本来就 100ms,那「间隔 0.05 秒」纯属心理安慰------这个参数根本没被触发。
这不是限速器的 bug,是它的定义:它保证的是下限 (不早于),不是上限。
反直觉的点二:限速是「买命」
★ 两个反直觉的点:
1. 如果单个请求本来就要 100ms,那么「间隔 0.05 秒」等于没有限速------
因为根本没到需要等待的程度。限速器只在请求太快时才起作用。
2. 限速确实让爬虫「变慢了」,但它买来的是「不被封」。
一个被 403 的爬虫,速度是 0。
「一个被 403 的爬虫,速度是 0」------这句话值得贴在显示器上。你追求的那点速度,在上封 IP 的那一刻全部归零,还得去换代理、换 UA、人工解封。限速是在给这笔账做风控。
生产环境怎么写
★ 真实项目里要更讲究:随机化间隔(0.8~1.5 秒)。
固定间隔本身就是一种可被识别的机器特征。
固定间隔是可被识别的。 精确每 500ms 一次,和人类点击的节奏完全不同。真实项目里把间隔随机化:
python
# 生产写法:在区间内随机
import random, time
time.sleep(random.uniform(0.8, 1.5))
更讲究的还会:读响应头里的限流信息、按目标的 robots.txt 定间隔、白天高夜间低地模拟人类作息。
四、断点续爬:跑一半崩了,别从头再来
第四个问题:跑了 3 小时抓到第 4 万条,程序崩了。 如果你等全部抓完才写盘,那这 3 小时全白费。
断点续爬的核心只有一句话:状态是「边做边存」的,不是「做完再存」。
python
def run_pass(label: str, stop_at: int) -> None:
done = load_done() # 先读上次的进度
c = HttpClient(base_url=base_url, timeout=CONFIG["timeout"],
retries=CONFIG["retries"])
added = 0
for i in range(1, stop_at + 1):
if i in done: # 做过的直接跳过
continue
c.get(f"/book/{i}")
done.add(i) # ← 边做边记,不是做完再记
added += 1
save_done(done) # 每轮结束落盘
c.close()
print(f" {label}: 本轮新抓 {added} 条,累计已完成 {len(done)} 条")
run_pass("第一轮(模拟跑到第 6 条时崩了)", 6)
run_pass("第二轮(重启,应当从第 7 条继续)", 16)
实测输出:
第一轮(模拟跑到第 6 条时崩了): 本轮新抓 6 条,累计已完成 6 条
第二轮(重启,应当从第 7 条继续): 本轮新抓 10 条,累计已完成 16 条
第二轮的目标是抓到第 16 条,但只新抓了 10 条 (第 7~16 条),前 6 条因为已在 done 里被跳过。这就是断点续爬生效的证据。
对照一下两种状态保存时机:
| 保存时机 | 崩在第 4 万条时 |
|---|---|
| 做完再存(全抓完才写) | 进度为 0,从第 1 条重来 |
| 边做边存(每抓一条/一批就写) | 进度为 39999,从第 40000 条继续 |
关键点:状态是「边做边存」的,不是「做完再存」。
如果你等全部抓完才写文件,那崩了照样得重来。
状态存在哪
本讲用的是 JSON 文件(data/s11_progress.json),够简单。但生产里更推荐存进数据库 ------毕竟第 10 讲的 books 表本来就有主键:
更进一步的做法是把状态存进数据库(上一讲的 books 表),
用 existing_ids() 直接问「哪些我已经有了」。
两种方案对比:
| 方案 | 优点 | 缺点 |
|---|---|---|
| JSON 文件 | 简单、直观、能直接看 | 进度大了读写慢;并发不安全 |
| 数据库主键 | 本身就是数据源,天然幂等 | 要用第 10 讲的 upsert |
一个细节:用「覆盖」代替「删除」
脚本开头初始化状态时,注释里有个很好的习惯:
python
# 从零开始:直接写一个空状态进去,而不是去删旧文件
# ("删除"是副作用,"覆盖"不是------少一个副作用就少一类意外)
state.write_text(json.dumps({"done": []}), encoding="utf-8")
「删除」是副作用------文件被别的进程占着会失败,删错了目录会误伤。「覆盖」是幂等的。这种小选择,累积起来就是一个「不需要人盯着」的脚本。
五、顺手把配置也外置
第 11 讲真正想给你的一个观念,藏在脚本开头的注释里:
python
# ---------------------------------------------------------------- 配置外置
# 真实项目里这些东西应该放 config.json / 环境变量,而不是散落在代码里。
# 这样换目标站、调频率就不用改代码、不用重新测试。
CONFIG = {
"base_url": "", # 运行时由靶场填空
"timeout": 8,
"retries": 3,
"state_file": str(STATE_FILE),
}
为什么这重要? 因为爬虫的参数(目标站、超时、重试次数、间隔)会天天变。如果它们散落在代码里,每改一次你都得担心「改错了别的地方」、还得重新测一遍。抽成一份配置,改配置就像拧旋钮,不碰逻辑。
换成真实站点时要动的地方
本讲的 base_url 一直是靶场填的 127.0.0.1。换成真实站点时:
- 重试次数别贪多。 3 次足够。设成 10 次,遇到一个永久 403 的接口,你只是陪它耗。
- 超时要按站点调。 靶场
timeout=8,慢站可能要 20~30s,快站给 5s 就够。 state_file要区分任务。 两个不同站共用一份进度文件,会互相「以为对方做过」。- 限速要放慢。 靶场随便打,真实站建议
random.uniform(0.8, 1.5)起步。 - 日志级别适时调整。 长期运行时控制台压到
WARNING,文件保留全量。
本讲小结
| 能力 | 一句话要点 |
|---|---|
| 日志 | 控制台按级别过滤、文件全量留档;三件套是「第几次/哪个 URL/什么状态码」 |
| 重试 | 只重试 429/5xx 和连接异常;优先读 Retry-After,否则指数退避 |
| 退避的边界 | 退避只缓解限流,治不了限流;根子是降频 |
| 限速 | 只在「请求快过间隔」时生效;单请求比间隔慢时,参数等于没有 |
| 限速的价值 | 拿一点速度换「不被封」;固定间隔是可识别特征,生产要随机化 |
| 断点续爬 | 状态「边做边存」,不是「做完再存」;进度更适合存数据库 |
| 配置外置 | 目标站/超时/次数抽成配置,改旋钮不碰逻辑 |
下一讲
前面十一讲,我们的爬虫一直是串行的:发一个请求,等它回来,再发下一个。
可以算一笔账------一个爬虫 90% 的时间到底在干什么?答案是等。等 TCP 握手、等服务器算完、等数据回来。你花大价钱买的 CPU,一直在摸鱼。
下一讲把「等」重叠起来:asyncio + aiohttp 。
实测里 12 个请求,串行要 1.94s、并发只要 0.68s。但并发不是免费的------
并发度开太大就是压测、asyncio.run() 套在事件循环里会直接报错、忘了复用 ClientSession 可能比串行还慢。