Python 爬虫
系统实战教程

01爬虫基础认知与合规边界 入门

爬虫（Web Crawler / Spider）的本质只有一句话：用代码模拟浏览器发出 HTTP 请求，把服务器返回的数据结构化地保存下来。搜索引擎、价格监控、舆情分析、数据日报，背后都是爬虫。它不神秘，本身也不违法——关键在于爬什么、怎么爬、用来做什么。

1.1 爬虫的四个基本环节

这四个环节循环往复。一个成熟的爬虫，就是在每个环节上不断加固：请求要能突破拦截，解析要能从脏 HTML 里精准提取，存储要能扛住数据量和中断。

1.2 爬虫的分类

本教程聚焦聚焦爬虫与深层爬虫——这是个人和中小团队最常用的两类，也是投入产出比最高的方向。

1.3 合规边界（务必先读）

合法场景依然很宽广：公开数据采集、学术研究、市场分析、自用工具、SEO 监测。把力气花在技术上、把边界记在心里，才是这一行能长期做下去的前提。

02开发环境搭建 入门

工欲善其事，必先利其器。本章搭建一套可长期使用的爬虫开发环境。

2.1 Python 与包管理

推荐使用 Python 3.12+（3.11 仍受支持，也够用）。包管理用 venv、conda 或 uv 均可，关键是把爬虫依赖装进隔离环境，避免污染系统 Python。uv 是近两年最流行的新选择，装库快很多。

# 查看 Python 版本（建议 3.11+）
python --version

# 创建隔离环境（conda 示例）
conda create -n crawl python=3.11 -y
conda activate crawl

2.2 安装核心库

# 一站式安装（按需求选择）
pip install scrapling           # 一体化抓取框架（本教程主力）
pip install requests            # 经典请求库
pip install httpx               # 现代请求库（HTTP/2 + 异步）
pip install beautifulsoup4 lxml # 解析库
pip install parsel              # Scrapy 同款选择器库
pip install playwright          # 浏览器渲染
pip install scrapy              # 爬虫框架（进阶）

python -m playwright install chromium
python -m patchright install chromium

2.3 开发工具清单

2.4 验证环境

跑通下面这段最小示例，环境就算就绪：

from scrapling.fetchers import Fetcher

page = Fetcher.get('https://example.com')
print('状态码:', page.status)          # 200
print('标题:', page.css('h1::text').get())  # Example Domain

03HTTP 协议深度解析 入门

爬虫工程师 90% 的时间不是在写代码，而是在理解"数据是怎么从服务器到页面的"。HTTP 是这一切的底层，必须吃透。

3.1 一次请求的生命周期

3.2 URL 的结构

一个 URL 拆解后，每一段对爬虫都有意义：

https://demo-site.com:443/browse?finished=1&sort=release_date#page2
└─┬─┘   └──────┬──────┘└┬┘└─┬──┘└──────────┬──────────┘└─┬──┘
 协议        域名      端口  路径        查询参数         锚点

3.3 请求方法

爬虫主要用 GET。遇到登录、搜索、复杂查询时才会用 POST（数据放在请求体里，常见 JSON 或表单格式）。

3.4 请求头详解

请求头是反爬攻防的第一战场。关键字段逐个说：

import requests

headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
    'Referer': 'https://www.google.com/',
    'Accept': 'text/html,application/xhtml+xml',
    'Accept-Language': 'zh-CN,zh;q=0.9',
}
r = requests.get('https://example.com', headers=headers, timeout=10)
print(r.status_code)

3.5 状态码大全

3.6 Cookie 与 Session 原理

HTTP 本身无状态，服务器靠 Cookie 记住"你是谁"。理解这个机制，才能处理登录态。

对应到爬虫：登录一次拿到 Cookie 后，用会话对象保持它，后续请求就都是"已登录"状态。requests 的 Session、scrapling 的会话都自动处理了 Cookie 的存取。

3.7 HTTPS 与 TLS 指纹

现在的网站基本都是 HTTPS。加密握手时，客户端会暴露一组特征（支持的加密套件、扩展、顺序等），即 TLS 指纹。普通 Python 请求的 TLS 指纹和真实浏览器完全不同——这就是为什么有些站点 requests 一请求就 403，而浏览器正常。

3.8 实战：看清一个请求的完整面貌

import requests

r = requests.get('https://httpbin.org/headers', headers={'User-Agent': 'MyBot/1.0'})
print('请求头回显:')
print(r.json())                      # 服务器收到的所有请求头
print('响应状态:', r.status_code)
print('响应头:', dict(r.headers))
print('编码:', r.encoding)

httpbin.org 是一个专门用于测试 HTTP 的公开服务，会把你的请求头原样返回——用它练习观察请求头是绝佳方式。

04HTML 与选择器 入门

拿到 HTML 后，怎么精准定位到想要的那一小块数据？靠选择器。这是爬虫的"手术刀"。

4.1 HTML 是一棵树（DOM）

HTML 本质是嵌套的标签树。浏览器 F12 → Elements 面板看到的就是这棵树的实时渲染。爬虫要做的就是：从根节点出发，用选择器定位到目标节点，取出它的文本或属性。

4.2 CSS 选择器完全指南

4.3 XPath 完全指南

XPath 是另一种定位语言，在处理按文本内容匹配、向上查找父节点、复杂条件时比 CSS 更强大。

4.4 CSS vs XPath 怎么选

4.5 正则表达式（兜底方案）

当数据混在 JS 代码里、或 HTML 结构极不规则时，正则是最后的兜底手段。

import re

html = '价格：￥1299 元，库存：42 件'
price = re.search(r'￥(\d+)', html).group(1)     # 1299
stock = re.search(r'库存：(\d+)', html).group(1)   # 42

# 常用正则片段
# \d+ 数字   \w+ 字母数字   .* 任意   \s+ 空白   [^"]+ 非引号

4.6 DevTools 实战技巧

05请求库详解 核心

请求库负责"发出请求、拿回响应"。选对库、用对方法，能省掉一大半反爬的麻烦。

5.1 四大请求库怎么选

5.2 requests 全面用法

import requests

# GET 带参数（自动拼到 URL）
r = requests.get('https://httpbin.org/get',
                 params={'page': 2, 'sort': 'date'},
                 headers={'User-Agent': 'Mozilla/5.0'},
                 timeout=10)
print(r.url)          # https://httpbin.org/get?page=2&sort=date
print(r.status_code)  # 200
print(r.text[:100])   # 文本内容
print(r.json())       # 若响应是 JSON 直接转字典

# POST 提交表单 / JSON
requests.post(url, data={'user': 'a'})        # 表单格式
requests.post(url, json={'user': 'a'})        # JSON 格式

5.3 会话保持（Session）—— 处理登录态

用 Session 对象，它会自动在多次请求间保持 Cookie：

s = requests.Session()

# 第一步：登录（Cookie 自动存入 Session）
s.post('https://site.com/login', data={'user': 'a', 'pwd': 'b'})

# 第二步：之后的请求都带着登录态
r = s.get('https://site.com/profile')   # 已登录，能看到私密数据

5.4 超时与重试

from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

s = requests.Session()
retries = Retry(total=3, backoff_factor=1,
                status_forcelist=[429, 500, 502, 503])
s.mount('https://', HTTPAdapter(max_retries=retries))
r = s.get(url, timeout=10)   # 超 10 秒自动放弃，遇 5xx/429 自动重试 3 次

5.5 代理配置

proxies = {
    'http':  'http://127.0.0.1:7890',
    'https': 'http://127.0.0.1:7890',
}
r = requests.get(url, proxies=proxies, timeout=10)

5.6 scrapling 请求（本教程推荐）

scrapling 把请求和解析合在一起，且自动处理 TLS 指纹。三种 Fetcher 对应三种场景：

from scrapling.fetchers import Fetcher, DynamicFetcher, StealthyFetcher

# ① 静态：用 get，不是 fetch！
page = Fetcher.get('https://example.com')

# ② 动态渲染
page = DynamicFetcher.fetch('https://spa-site.com', headless=True)

# ③ 强反爬
page = StealthyFetcher.fetch('https://protected.com', headless=True,
                             network_idle=True)

5.7 curl_cffi 指纹伪装

from curl_cffi import requests as creq

# impersonate 指定模拟哪个浏览器的 TLS 指纹
r = creq.get('https://example.com', impersonate='chrome')
print(r.status_code)

06解析库详解 核心

拿到 HTML 后，用解析库把数据"抠"出来。主流四个：BeautifulSoup、lxml、parsel、正则。

6.1 BeautifulSoup（最易上手）

from bs4 import BeautifulSoup

soup = BeautifulSoup(html, 'lxml')
title = soup.find('h1').get_text()                 # 按标签找
items = soup.select('.item a')                     # CSS 选择器
for a in items:
    print(a.get_text(), a['href'])               # 文本 + 属性

# 按文本找（BeautifulSoup 也支持）
tag = soup.find('a', string='登录')

6.2 lxml（速度最快）

from lxml import etree

tree = etree.HTML(html)
titles = tree.xpath('//h1/text()')                # XPath
links = tree.xpath('//a[@class="item"]/@href')    # 取属性

6.3 parsel（Scrapy 同款，功能最全）

from parsel import Selector

sel = Selector(html)
sel.css('h1::text').get()                        # CSS 取文本
sel.xpath('//a/@href').getall()                  # XPath 取属性
sel.css('a').re(r'href="(.*?)"')                # 甚至能套正则

6.4 JSON 解析（接口数据）

import json

data = r.json()                    # requests 直接转
# 或
data = json.loads(text)            # 字符串转字典
title = data['data']['list'][0]['title']   # 按层级取值

# 嵌套深时用 jmespath 更优雅
import jmespath
titles = jmespath.search('data.list[*].title', data)

6.5 四大解析方式对比

6.6 实战：解析一个列表页

from scrapling.fetchers import Fetcher

page = Fetcher.get('https://demo-site.com/')
# 一次抓取多个字段，组合成结构化数据
for card in page.css('a[href^="/anime/"]'):
    href = card.attrib.get('href')
    name = card.css('img::attr(alt)').get()
    if name:
        print(name, href)

07数据存储方案 核心

数据抓下来要落地。按数据量和查询需求选存储方式。

7.1 文件类（轻量数据）

import csv, json

# CSV：表格数据，Excel 直接打开（utf-8-sig 防乱码）
with open('data.csv', 'w', newline='', encoding='utf-8-sig') as f:
    w = csv.DictWriter(f, fieldnames=['title', 'price'])
    w.writeheader()
    w.writerows(rows)

# JSON：结构化、嵌套数据
json.dump(data, open('data.json', 'w', encoding='utf-8'),
          ensure_ascii=False, indent=2)

# JSONL：一行一条，适合大数据量逐条追加
with open('data.jsonl', 'a', encoding='utf-8') as f:
    f.write(json.dumps(item, ensure_ascii=False) + '\n')

7.2 SQLite（单机爬虫最佳归宿）

零配置、单文件、支持 SQL，个人爬虫首选。

import sqlite3

conn = sqlite3.connect('data.db')
conn.execute('''CREATE TABLE IF NOT EXISTS anime(
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    title TEXT, url TEXT UNIQUE, meta TEXT)''')

# 插入（UNIQUE 约束 + INSERT OR IGNORE 自动去重）
conn.execute('INSERT OR IGNORE INTO anime(title,url,meta) VALUES (?,?,?)',
             (title, url, meta))
conn.commit()

# 查询
for row in conn.execute('SELECT title, url FROM anime LIMIT 5'):
    print(row)

7.3 其他数据库对比

7.4 Redis 做去重与队列（进阶）

import redis

r = redis.Redis(host='localhost', port=6379, db=0)

# 集合去重：sadd 返回 1=新增，0=已存在
if r.sadd('crawled', url):
    # 新 URL，加入待抓队列
    r.lpush('todo', url)

# 从队列取任务
task = r.rpop('todo')

08并发与异步提速 进阶

串行抓 1 万条可能要几小时，并发能压到几分钟。但并发是把双刃剑——提速的同时也更容易被封。

8.1 并发模型总览

8.2 多线程（ThreadPoolExecutor，最常用）

网络请求是 I/O 密集型，多线程提速明显、代码改动最小：

from concurrent.futures import ThreadPoolExecutor
from scrapling.fetchers import Fetcher

urls = [f'https://site.com/anime/{i}' for i in range(100, 130)]

def fetch(url):
    try:
        return url, Fetcher.get(url).css('title::text').get()
    except Exception as e:
        return url, f'ERR: {e}'

with ThreadPoolExecutor(max_workers=5) as ex:   # 5 并发，别贪多
    results = list(ex.map(fetch, urls))

for url, title in results:
    print(title)

8.3 协程异步（asyncio + aiohttp，性能最强）

import asyncio, aiohttp

async def fetch(session, url):
    async with session.get(url) as resp:
        return url, await resp.text()

async def main():
    async with aiohttp.ClientSession() as s:
        tasks = [fetch(s, u) for u in urls]
        return await asyncio.gather(*tasks)

results = asyncio.run(main())

8.4 并发控制：信号量限速

# 限制同时只有 5 个请求在飞，避免瞬间打满
sem = asyncio.Semaphore(5)

async def fetch(session, url):
    async with sem:                      # 拿到令牌才执行
        async with session.get(url) as resp:
            return await resp.text()

8.5 选型建议

09动态页面渲染 进阶

当数据由 JavaScript 动态生成（源码里看不到、Network 里有 XHR），就进入动态渲染的领域。

9.1 第一原则：先找接口，别急着开浏览器

很多"动态站"其实是前端渲染 + 后端 JSON 接口。直接请求 JSON 接口，比开浏览器快一个数量级、省资源、还稳定。

9.2 Playwright 详解

from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch(headless=True)
    page = browser.new_page()
    page.goto('https://spa-site.com')

    # 等待关键元素加载完成（动态页必须）
    page.wait_for_selector('.product-list', timeout=10000)

    # 滚动加载更多（无限滚动页面）
    page.mouse.wheel(0, 3000)
    page.wait_for_timeout(2000)

    html = page.content()              # 拿渲染后的完整 HTML
    page.screenshot(path='shot.png')    # 截图调试用
    browser.close()

9.3 scrapling 动态抓取（更简洁）

from scrapling.fetchers import DynamicFetcher, StealthyFetcher

# Dynamic：JS 渲染后拿页面
page = DynamicFetcher.fetch(
    'https://spa-site.com',
    headless=True,
    network_idle=True,          # 等网络空闲，确保 JS 加载完
    wait_selector='.product',   # 等特定元素出现
)
print(page.css('h1::text').get())

# Stealthy：强反爬（Cloudflare 盾等），真实浏览器指纹
page = StealthyFetcher.fetch(
    'https://protected.com',
    headless=True,
    solve_cloudflare=True,     # 自动过 Turnstile 盾
)

9.4 截获 XHR：绕过渲染直拿数据

scrapling 的 capture_xhr 能拦截页面发出的接口请求——既不用解析渲染后 HTML，也不用自己逆向接口：

page = DynamicFetcher.fetch(
    'https://spa-site.com/products',
    capture_xhr='/api/products',    # 拦截含此关键字的请求
)
for req in page.captured_xhr:
    data = req.json()               # 直接拿到接口返回的 JSON
    print(data)

9.5 Selenium（老方案，了解即可）

Selenium 是浏览器自动化的老前辈，语法啰嗦、速度慢，现在基本被 Playwright 取代。除非维护老项目，否则直接学 Playwright。

10反爬对抗体系 进阶

反爬是猫鼠游戏。理解对方的检测手段，才知道怎么应对。本章按"从轻到重"梳理完整对抗体系。

10.1 反爬对抗金字塔

10.2 各层对抗手段

10.3 频率控制（最重要的自律）

import time, random

for url in urls:
    fetch(url)
    time.sleep(random.uniform(1, 3))   # 随机 1-3 秒，模拟人类

10.4 IP 代理池

proxy_list = [
    'http://1.2.3.4:8080',
    'http://5.6.7.8:8080',
]
proxy = random.choice(proxy_list)
r = requests.get(url, proxies={'http': proxy, 'https': proxy})

自建代理池需维护可用性检测（定期测速、剔除失效 IP），也可用付费代理服务。小规模抓取用本地代理（如 Clash）即可。

10.5 JS 混淆与字体反爬

• JS 混淆：接口参数被 JS 加密。对策：抓包看真实请求，或用 LLM 辅助阅读混淆代码找规律。
• 字体反爬：数字用自定义字体显示（源码里是乱码，页面显示正常）。对策：下载字体文件做映射表，或截图 OCR。

10.6 AI 辅助反爬分析（2026 新趋势）

把抓包结果、混淆 JS、异常响应喂给大模型，让它帮你分析"参数怎么生成的""哪里被拦了"。这是近两年爬虫工作流的重大变化——逆向分析的效率被 AI 大幅拉高。

11Scrapy 框架 进阶

当爬虫需要规模化、规范化、长期维护时，用 Scrapy 框架。它把"请求调度、解析、存储、去重、中间件"都标准化了。

11.1 Scrapy 架构

11.2 创建项目与 Spider

# 命令行创建项目
scrapy startproject myspider
cd myspider
scrapy genspider anime demo-site.com   # 生成一个 spider
scrapy crawl anime                          # 运行

11.3 Spider 核心代码

import scrapy

class AnimeSpider(scrapy.Spider):
    name = 'anime'
    start_urls = ['https://demo-site.com/']

    def parse(self, response):
        # 解析列表页，提取详情链接并跟进
        for href in response.css('a[href^="/anime/"]::attr(href)').getall():
            yield response.follow(href, self.parse_detail)

    def parse_detail(self, response):
        yield {
            'title': response.css('h1::text').get(),
            'url': response.url,
            'meta': response.css('meta[name="description"]::attr(content)').get(),
        }

11.4 Item 与 Pipeline（存数据）

# pipelines.py · 存入 SQLite
import sqlite3

class SQLitePipeline:
    def open_spider(self, spider):
        self.conn = sqlite3.connect('anime.db')
        self.conn.execute('CREATE TABLE IF NOT EXISTS anime(title TEXT,url TEXT,meta TEXT)')

    def process_item(self, item, spider):
        self.conn.execute('INSERT INTO anime VALUES (?,?,?)',
                          (item['title'], item['url'], item['meta']))
        self.conn.commit()
        return item

11.5 常用配置（settings.py）

USER_AGENT = 'Mozilla/5.0 ...'
DOWNLOAD_DELAY = 1                # 请求间隔（秒），礼貌限速
CONCURRENT_REQUESTS = 8           # 全局并发数
ROBOTSTXT_OBEY = True             # 遵守 robots.txt
ITEM_PIPELINES = {'myspider.pipelines.SQLitePipeline': 300}

12接口抓取与逆向 进阶

很多高价值数据藏在接口里。学会抓包分析接口，是爬虫进阶的分水岭。

12.1 抓包工具

12.2 接口分析四步法

12.3 接口签名（sign）的常见套路

# 常见签名 = md5(参数拼接 + 密钥 + 时间戳)
import hashlib, time

def make_sign(params, secret):
    s = ''.join(f'{k}={v}' for k, v in sorted(params.items()))
    s += secret + str(int(time.time()))
    return hashlib.md5(s.encode()).hexdigest()

params = {'page': 1, 'size': 20}
params['sign'] = make_sign(params, '网站JS里抠出来的密钥')
r = requests.get('https://api.site.com/list', params=params)

12.4 移动端抓取

App 的数据接口往往比网页更干净。用 mitmproxy 抓手机流量（手机设代理指向电脑），分析 App 的接口。注意：现代 App 多有证书绑定（SSL Pinning），需额外手段绕过，门槛较高，学习阶段建议先用网页版练手。

13工程化与部署 进阶

抓几十条不需要工程化；抓几万条还要长期稳定跑，就需要下面这些"基础设施"。

13.1 断点续爬

核心思想：已抓的 URL 存进数据库，启动时先读出来跳过。配合异常捕获，就能跑几天几夜不中断、崩了也不白干。

import sqlite3, time, random

conn = sqlite3.connect('crawl.db')
conn.execute('CREATE TABLE IF NOT EXISTS done(url TEXT PRIMARY KEY)')
conn.execute('CREATE TABLE IF NOT EXISTS anime(url TEXT, title TEXT)')

done = {r[0] for r in conn.execute('SELECT url FROM done')}

for url in urls:
    if url in done: continue            # 断点跳过
    try:
        title = Fetcher.get(url).css('title::text').get()
        conn.execute('INSERT INTO anime VALUES (?,?)', (url, title))
        conn.execute('INSERT INTO done VALUES (?)', (url,))
        conn.commit()                        # 每成功一条立即落库
    except Exception as e:
        print('失败跳过:', url, e)
    time.sleep(random.uniform(0.5, 1.5))

13.2 增量爬取

只抓新增/变更数据，不重复抓全量。常用两种策略：

• 按时间戳：记录上次抓到的最大时间/ID，下次只抓比它新的。
• 按 URL 去重：已抓 URL 存库，新出现的才抓（断点续爬的延伸）。

13.3 日志与监控

import logging

logging.basicConfig(
    level=logging.INFO,
    format='[%(asctime)s] %(levelname)s: %(message)s',
    handlers=[logging.FileHandler('crawl.log', encoding='utf-8'),
              logging.StreamHandler()]
)
log = logging.getLogger('crawl')
log.info('抓取成功 %s', url)
log.warning('第 %d 次重试', attempt)
log.error('失败 %s: %s', url, e)

13.4 定时调度

# APScheduler 示例（常驻进程内定时）
from apscheduler.schedulers.blocking import BlockingScheduler

sched = BlockingScheduler()
sched.add_job(crawl_task, 'cron', hour=8)   # 每天 8 点跑
sched.start()

13.5 爬虫系统总体架构

14实战项目集 实战

四个由浅入深的完整项目，覆盖本教程所有核心技能。

项目一：动漫站全目录抓取（静态 + 存储 + 断点）

目标：稀饭动漫 Next，抓首页番剧链接 → 详情页 → 存 SQLite。用到：静态抓取、列表解析、翻页、断点续爬、限速。

# crawl_anime.py
import sqlite3, time, random
from scrapling.fetchers import Fetcher

BASE = 'https://demo-site.com'
conn = sqlite3.connect('anime.db')
conn.execute('CREATE TABLE IF NOT EXISTS anime(id INTEGER PRIMARY KEY,title TEXT,url TEXT,meta TEXT)')
conn.execute('CREATE TABLE IF NOT EXISTS done(url TEXT PRIMARY KEY)')

def links_of(page):
    return set(page.css('a[href^="/anime/"]::attr(href)').getall())

def save(href):
    if conn.execute('SELECT 1 FROM done WHERE url=?',(href,)).fetchone(): return
    p = Fetcher.get(BASE+href)
    conn.execute('INSERT INTO anime(title,url,meta) VALUES (?,?,?)',
        (p.css('h1::text').get(), href,
         p.css('meta[name="description"]::attr(content)').get()))
    conn.execute('INSERT INTO done VALUES (?)',(href,)); conn.commit()

links = set()
for i in range(1,4):
    links |= links_of(Fetcher.get(f'{BASE}/browse?page={i}'))
    time.sleep(random.uniform(1,2))
for h in sorted(links):
    try: save(h)
    except Exception as e: print('跳过', h, e)
print('入库:', conn.execute('SELECT COUNT(*) FROM anime').fetchone()[0])

项目二：电商商品价格监控（并发 + 定时）

目标：定时抓商品页价格，入库对比涨跌。用到：多线程、SQLite、定时调度、增量。

import sqlite3, time
from concurrent.futures import ThreadPoolExecutor
from scrapling.fetchers import Fetcher

URLS = ['https://shop.com/item/1', 'https://shop.com/item/2']
conn = sqlite3.connect('price.db')
conn.execute('CREATE TABLE IF NOT EXISTS price(ts REAL,item TEXT,price REAL)')

def grab(u):
    p = Fetcher.get(u)
    price = p.css('.price::text').get()
    conn.execute('INSERT INTO price VALUES (?,?,?)',(time.time(),u,price)); conn.commit()
    return u, price

with ThreadPoolExecutor(3) as ex:
    for u, price in ex.map(grab, URLS): print(u, price)

项目三：图片批量下载（接口 + 文件流）

目标：抓页面所有图片地址并下载。用到：属性提取、文件流写入、并发下载。

import os, requests
from concurrent.futures import ThreadPoolExecutor
from scrapling.fetchers import Fetcher

os.makedirs('imgs', exist_ok=True)
page = Fetcher.get('https://site.com')
imgs = page.css('img::attr(src)').getall()

def dl(src):
    if not src.startswith('http'): return
    name = src.split('/')[-1]
    r = requests.get(src, timeout=15)
    open(f'imgs/{name}', 'wb').write(r.content)

with ThreadPoolExecutor(8) as ex:
    ex.map(dl, imgs)

项目四：动态 SPA 数据抓取（渲染 + XHR 截获）

目标：抓一个前端渲染的列表页，直接截获其接口 JSON。用到：DynamicFetcher、capture_xhr。

from scrapling.fetchers import DynamicFetcher

page = DynamicFetcher.fetch('https://spa-site.com/list',
    headless=True, capture_xhr='/api/list')
for req in page.captured_xhr:
    for item in req.json().get('data', []):
        print(item)

四个项目的技能覆盖

附录常见问题与资源

A. 常见问题排查

B. 学习资源

C. 工具速查

scraplingrequestshttpxcurl_cffi parselBeautifulSouplxmljmespath playwrightscrapyaiohttpsqlite3 redisapschedulermitmproxy