数据采集第三次作业

数据采集与融合技术-第三次作业

项目 内容
课程 2026数据采集与融合技术实践
作业要求 作业三
我的 Git 仓库 aarctic
学号姓名 102402110 姜思源

一、作业1代码与图片:

Gitee文件夹链接:作业1

1.1 作业代码与运行结果

(1)实现思路

  1. 需求参数

题目给的限制:学号是 102402110,所以:

  • 页面上限 MAX_PAGES = 10;
  • 图片上限 MAX_IMAGES = 110。

站点选中国气象网 http://www.weather.com.cn/。做法是从首页开始按广度优先顺序往外走,边走边收集图片地址,收集够了再统一下载。

  1. 两个版本

两个独立脚本:

脚本 下载方式
image_spider_single.py 主循环里逐张请求、逐张写盘
image_spider_multi.py 先用 ThreadPoolExecutor 并发下载,再用主会话串行补漏

两个版本共用同样的 URL 收集逻辑:用 BeautifulSoup 找 <img> 的 src / data-src / data-original,用 urljoin 补成绝对地址,再按扩展名过滤并用集合去重。文件名用「序号 + URL 的 MD5 前 10 位」,避免不同地址同名互相覆盖。

多线程版本有个坑:并发数开到 8 时,图片服务器大量返回 403。我把并发降到 4,并在 download_image 里对 403/429 做退避重试;即便如此仍可能不足 110 张,所以并发结束后用主会话串行补齐剩余部分。

(2)单线程和多线程的对比以及关键代码分析

单线程版:朴素但清晰

下载阶段就是一个 for 循环
# 阶段 2:串行下载
saved = 0
for idx, url in enumerate(image_urls, start=1):
    if saved >= MAX_IMAGES:
        break
    if download_image(url, idx, session):
        saved += 1

实现一个一个下载,download_image 内部同步阻塞,前一张下完才轮到下一张。逻辑清晰、调试容易,但 110 张图串行下来耗时较长。

单线程的 download_image:没有重试
def download_image(url: str, index: int, session: requests.Session) -> bool:
    try:
        resp = session.get(url, headers={**HEADERS, "Referer": START_URL},
                           timeout=TIMEOUT)
        resp.raise_for_status()
        if len(resp.content) < 1024:              # 过滤占位小图
            return False
        name = build_filename(index, url, resp.headers.get("Content-Type", ""))
        with open(os.path.join(SAVE_DIR, name), "wb") as fh:
            fh.write(resp.content)
        print(f"[{index:03d}/{MAX_IMAGES}] {url}")
        return True
    except Exception as exc:
        print(f"[图片失败] {url} -> {exc}")
        return False

单线程下请求压力小,站点基本不会限流,所以这里没有重试逻辑:一次失败就放弃,靠"多取候选 URL"(image_urls[:MAX_IMAGES * 2])来兜底。数量不够时,后面的候选地址自然顶上。


多线程版:并发带来的三个问题

引入线程池后,代码没有变简单,反而多了三处必须处理的细节。这一节按"问题 → 解法"来组织。

问题一:站点限流

单线程时站点懒得理,并发一上来,图片服务器立刻回 403/429。解法是指数式退避重试:

def download_image(url: str, index: int, session: requests.Session) -> bool:
    try:
        # 站点有限流:遇到 403/429 稍等后重试
        for attempt in range(3):
            resp = session.get(url, headers={**HEADERS, "Referer": START_URL},
                               timeout=TIMEOUT)
            if resp.status_code in (403, 429) and attempt < 2:
                time.sleep(0.6 * (attempt + 1))
                continue
            resp.raise_for_status()
            break
        if len(resp.content) < 1024:
            return False
        name = build_filename(index, url, resp.headers.get("Content-Type", ""))
        with open(os.path.join(SAVE_DIR, name), "wb") as fh:
            fh.write(resp.content)
        with _print_lock:                      # 关键:保护 print
            print(f"[{index:03d}/{MAX_IMAGES}] {url}")
        return True
    except Exception as exc:
        with _print_lock:
            print(f"[图片失败] {url} -> {exc}")
        return False

重试间隔 0.6s、1.2s,给站点喘息时间。resp.status_code 的检查必须在 raise_for_status() 之前,否则 403 会直接抛异常,重试逻辑根本不会执行。

问题二:多线程 print 会互相穿插

多个线程同时 print,控制台输出会交错成一团乱麻。解法是用一把全局锁:

_print_lock = Lock()                  # 保证控制台输出不串行错乱

凡是线程函数里的 print,都包在 with _print_lock: 里。代价是输出略慢,但日志可读性大幅提升——排查问题时这点代价完全值得。

问题三:Session 不是线程安全的

requests.Session 官方并不保证线程安全。直接让 4 个线程共用一个 Session,轻则 Cookie 错乱,重则偶发异常。解法是每个任务独立建 Session,并继承主会话的 Cookie:

cookies = session.cookies.get_dict()
# ...
thread_session = requests.Session()
thread_session.cookies.update(cookies)
task = pool.submit(download_image, url, idx, thread_session)

这样既避免了共享状态竞争,又保证了图片服务器看到的请求带着有效 Cookie,不会因"无 Cookie"被拒。


多线程的主循环:

# 阶段 2:线程池并发下载(复制主会话 Cookie,避免图片服务器 403)
success_urls: list[str] = []
cookies = session.cookies.get_dict()
cursor = 0
with ThreadPoolExecutor(max_workers=WORKERS) as pool:
    while len(success_urls) < MAX_IMAGES and cursor < len(image_urls):
        batch = []
        for _ in range(WORKERS):             # 每批提交 4 个任务,降低限流概率
            if cursor >= len(image_urls):
                break
            url = image_urls[cursor]
            idx = cursor + 1
            cursor += 1
            thread_session = requests.Session()
            thread_session.cookies.update(cookies)
            task = pool.submit(download_image, url, idx, thread_session)
            batch.append((task, url))
        for task, url in batch:
            if task.result() and len(success_urls) < MAX_IMAGES:
                success_urls.append(url)

没有一次性把 110 个任务全丢进线程池,而是"每批提交 WORKERS 个,等这批全部 result() 完再提交下一批"。

对比总结

维度 单线程版 多线程版
阶段 1(BFS 收集 URL) 串行 串行(相同)
阶段 2(下载) for 循环逐个下 ThreadPoolExecutor,max_workers=4
并发控制 无 分批提交,每批 4 个,等结果再下一批
Session 全局共用一个 每任务复制 Cookie 新建 Session
限流应对 无(靠多取候选 URL) 403/429 退避重试 ×3
输出保护 不需要 threading.Lock 保护 print
精确控制数量 saved 计数器 success_urls 列表 + 主线程收集
兜底 无 并发后未满则串行补漏
适用场景 请求少、调试方便 图片多、站点可承受并发

(3)运行结果

单线程的运行结果:

终端:
c9798c2910bb6d5fb3c557b8295a0853
爬取输出,共110个项目:
image
url输出:
image

多线程的运行结果:

终端:
c0667c4be340d0c2ef8ba660702ee265
爬取输出,共110个项目,与单线程相同:
image
url输出:
image

1.2 作业心得

这次作业最大的收获,是明白了爬虫的难点不在"爬",而在"稳定地爬满、爬对"。

动手前我先想清楚"哪里该并行":BFS 收集 URL 依赖有序队列和页面间链接依赖,适合串行;110 张图片彼此独立,才适合并发。所以多线程版只改了下载阶段,BFS 逻辑一字未动。并行的第一步不是写线程池,而是判断任务是否真的独立,为多线程而多线程只会把简单问题复杂化。

并发一上来,问题也跟着来了:并发数开到 8 时站点大量返回 403,我降到 4 并加了退避重试;多线程 print 会互相穿插,用一把锁解决;requests.Session 不保证线程安全,改成每个任务独立建 Session 并继承 Cookie。这里还踩了个典型的坑——status_code 检查必须放在 raise_for_status() 之前,否则 403 直接抛异常,重试逻辑等于没写。

即便这样,并发阶段仍可能凑不满 110 张,所以最后保留了"并发为主、串行补漏"的兜底:不够就用主会话补齐剩余候选。工程上保证结果往往比追求极致速度更重要,这种"主路径快、兜底路径稳"的结构在实际项目里很常见。

最后两个版本跑完保存的 110 张图片和 URL 日志基本一致,这本身就是对多线程正确性的交叉验证——能在并发下得到和串行相同的结果,才算真正跑对了,比单纯"跑得更快"更让人踏实。

二、作业2代码与图片:

Gitee文件夹链接:作业2

2.1 作业代码与运行结果

(1)实现思路

先去行情中心页面,但服务端返回的 HTML 里根本没有股票数值——那张表是浏览器执行 JS 之后才填进去的,直接写 XPath 只会拿到一堆空标签。
于是按 F12 → Network 找真实数据来源,定位到公开行情接口:

https://push2.eastmoney.com/api/qt/clist/get

它返回 JSON,字段号和作业要求的列一一对应:

接口字段 含义 Item 字段
f12 股票代码 bStockNo
f14 股票名称 sStockName
f2 最新报价 fLatestPrice
f3 涨跌幅 fChangePercent
f4 涨跌额 fChangeAmount
f5 成交量 fVolume
f7 振幅 fAmplitude
f15 最高 fHigh
f16 最低 fLow
f17 今开 fOpen
f18 昨收 fPreClose

fltt=2 让价格直接以小数返回,省去自己除以 100。停牌股的价格是 "-",统一转成 0 再入库。

(2)关键代码以及分析

stock_spider/spiders/eastmoney_spider.py:

from __future__ import annotations

from datetime import datetime

import scrapy

from stock_spider.items import StockItem

API_URL = "https://push2.eastmoney.com/api/qt/clist/get"
API_FIELDS = ("f12,f14,f2,f3,f4,f5,f7,f15,f16,f17,f18")
MARKETS = "m:1+t:2,m:1+t:23,m:0+t:6,m:0+t:80"   # 沪深 A 股

PARAMS = {
    "pn": "1",          # 页码,由 start_requests 覆盖
    "pz": "50",         # 每页条数
    "po": "1",
    "np": "1",
    "fltt": "2",        # 价格按小数返回
    "invt": "2",
    "fid": "f12",       # 按股票代码排序
    "fs": MARKETS,
    "fields": API_FIELDS,
}


def to_number(value) -> str:
    """把接口中的 '-' / None 转为 '0',避免入库时类型报错。"""
    if value in (None, "-", ""):
        return "0"
    return str(value)


def format_volume(value) -> str:
    """成交量(手)转为‘万手 / 亿手’便于阅读。"""
    try:
        num = float(value)
    except (TypeError, ValueError):
        return str(value)
    if num >= 1e8:
        return f"{num / 1e8:.2f}亿"
    if num >= 1e4:
        return f"{num / 1e4:.2f}万"
    return str(int(num))


class EastmoneyStockSpider(scrapy.Spider):
    """抓取沪深 A 股行情列表前两页。"""

    name = "eastmoney_stock"
    allowed_domains = ["push2.eastmoney.com", "eastmoney.com"]
    custom_settings = {"CONCURRENT_REQUESTS": 2}

    def start_requests(self):
        """按页码构造行情接口请求。"""
        for page in (1, 2):
            params = dict(PARAMS, pn=str(page))
            yield scrapy.Request(
                f"{API_URL}?{self._query(params)}",
                callback=self.parse,
                cb_kwargs={"page": page},
                headers={"Referer": "https://quote.eastmoney.com/center/gridlist.html"},
            )

    @staticmethod
    def _query(params: dict) -> str:
        """把参数字典拼成查询串(冒号、加号需保留)。"""
        from urllib.parse import urlencode
        return urlencode(params, safe=":+,")

    def parse(self, response, page: int):
        """解析接口返回的 JSON,逐条封装为 StockItem。"""
        payload = response.json()
        rows = (payload.get("data") or {}).get("diff") or []
        self.logger.info(f"第 {page} 页获取到 {len(rows)} 条股票数据")

        for offset, row in enumerate(rows, start=1):
            item = StockItem()
            item["id"] = (page - 1) * int(PARAMS["pz"]) + offset
            item["bStockNo"] = row.get("f12", "")
            item["sStockName"] = row.get("f14", "")
            item["fLatestPrice"] = to_number(row.get("f2"))
            item["fChangePercent"] = to_number(row.get("f3"))
            item["fChangeAmount"] = to_number(row.get("f4"))
            item["fVolume"] = format_volume(row.get("f5"))
            item["fAmplitude"] = to_number(row.get("f7"))
            item["fHigh"] = to_number(row.get("f15"))
            item["fLow"] = to_number(row.get("f16"))
            item["fOpen"] = to_number(row.get("f17"))
            item["fPreClose"] = to_number(row.get("f18"))
            item["crawl_time"] = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
            yield item

我在 ITEM_PIPELINES 里挂了三个管道,分别负责 JSON、CSV 和数据库。前两个演示 Item 的序列化输出,第三个负责入库。

stock_spider/pipelines.py(MySQL 部分):

class StockMySQLPipeline:
    """把 Item 写入 MySQL 的 stocks 表;可选 SQLite 便于本机验证。"""

    CREATE_SQL = """
        CREATE TABLE IF NOT EXISTS stocks (
            id             INT AUTO_INCREMENT PRIMARY KEY COMMENT '序号',
            bStockNo       VARCHAR(16)  NOT NULL UNIQUE COMMENT '股票代码',
            sStockName     VARCHAR(64)  COMMENT '股票名称',
            fLatestPrice   DECIMAL(10,2) COMMENT '最新报价',
            fChangePercent DECIMAL(10,2) COMMENT '涨跌幅',
            fChangeAmount  DECIMAL(10,2) COMMENT '涨跌额',
            fVolume        VARCHAR(32)  COMMENT '成交量',
            fAmplitude     DECIMAL(10,2) COMMENT '振幅',
            fHigh          DECIMAL(10,2) COMMENT '最高',
            fLow           DECIMAL(10,2) COMMENT '最低',
            fOpen          DECIMAL(10,2) COMMENT '今开',
            fPreClose      DECIMAL(10,2) COMMENT '昨收',
            crawl_time     DATETIME     COMMENT '入库时间'
        ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
    """

    def _connect_sqlite(self, spider, reason: str) -> None:
        """连接 SQLite 并建表;作为 MySQL 不可用时的兜底方案。"""
        settings = spider.settings
        out_dir = os.path.join(os.path.dirname(os.path.dirname(
            os.path.abspath(__file__))), "output")
        os.makedirs(out_dir, exist_ok=True)
        db_path = settings.get("SQLITE_DB") or os.path.join(out_dir, "stocks.db")
        self.use_sqlite = True
        self.conn = sqlite3.connect(db_path)
        self.conn.execute("""
            CREATE TABLE IF NOT EXISTS stocks (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                bStockNo TEXT NOT NULL UNIQUE,
                sStockName TEXT, fLatestPrice REAL, fChangePercent REAL,
                fChangeAmount REAL, fVolume TEXT, fAmplitude REAL,
                fHigh REAL, fLow REAL, fOpen REAL, fPreClose REAL,
                crawl_time TEXT
            )
        """)
        spider.logger.warning(f"{reason},已自动切换到 SQLite:{db_path}")

    def open_spider(self, spider):
        """优先连 MySQL;连不上就自动降级 SQLite,保证爬虫不中断。"""
        settings = spider.settings
        self.conn = None
        if settings.getbool("USE_SQLITE_FALLBACK", False):
            self._connect_sqlite(spider, "按配置使用 SQLite")
        elif pymysql is None:
            self._connect_sqlite(spider, "未安装 PyMySQL")
        else:
            try:
                self.conn = pymysql.connect(
                    host=settings.get("MYSQL_HOST", "127.0.0.1"),
                    port=settings.getint("MYSQL_PORT", 3306),
                    user=settings.get("MYSQL_USER", "root"),
                    password=settings.get("MYSQL_PASSWORD", "123456"),
                    database=settings.get("MYSQL_DB", "data_crawl_hw3"),
                    charset="utf8mb4",
                    connect_timeout=5,          # 连不上时快速失败,不长时间卡住
                )
                self.conn.cursor().execute(self.CREATE_SQL)
                self.use_sqlite = False
                spider.logger.info("数据库模式:MySQL")
            except Exception as exc:
                if self.conn is not None:
                    try:
                        self.conn.close()
                    except Exception:
                        pass
                self._connect_sqlite(
                    spider, f"MySQL 连接失败({type(exc).__name__}: {exc})")
        self.conn.commit()
        self.cursor = self.conn.cursor()

    def process_item(self, item, spider):
        adapter = ItemAdapter(item)
        values = tuple(adapter.get(field, "") for field in FIELDS)
        placeholders = ",".join(["?"] * len(FIELDS)) if self.use_sqlite \
            else ",".join(["%s"] * len(FIELDS))
        if self.use_sqlite:
            sql = f"INSERT OR REPLACE INTO stocks ({','.join(FIELDS)}) VALUES ({placeholders})"
        else:
            updates = ",".join(
                f"{f}=VALUES({f})" for f in FIELDS if f not in ("id", "bStockNo"))
            sql = (f"INSERT INTO stocks ({','.join(FIELDS)}) VALUES ({placeholders}) "
                   f"ON DUPLICATE KEY UPDATE {updates}")
        self.cursor.execute(sql, values)
        self.conn.commit()
        return item

    def close_spider(self, spider):
        if getattr(self, "conn", None) is not None:
            self.conn.close()
        spider.logger.info("数据库连接已关闭")

用 ON DUPLICATE KEY UPDATE 是为了重复跑爬虫时按股票代码更新而不是插重复行。

(3)运行结果

终端输出:
e43999ba5da8965ee617cd589888b89e
抓了沪深 A 股前两页共 100 条,日志里 item_scraped_count: 100,JSON、CSV 和 MySQL 三处都有数据。
下面是SQL查询结果,分字段查询:
image
image
image

2.2 作业心得

这次作业最大的收获,是明白了"页面上能看到表格"和"能取到表格数据"是两回事。

动手前我先去看了行情中心页面,服务端返回的 HTML 里根本没有数值,那张表是浏览器执行 JS 之后才填进去的,直接写 XPath 只会拿到一堆空标签。后来按 F12 翻 Network,才定位到 push2.eastmoney.com 的公开接口,字段 f12/f14/f2/f3... 跟作业要求的列刚好一一对应,连 fltt=2 这种让价格按小数返回的细节都省了自己除以 100。遇到"取不到"先别急着换选择器,去看看数据到底从哪来,往往比硬啃 HTML 快得多。

结构上我第一次认真体会 Scrapy 的 Item / Pipeline 分工:Item 集中定义字段,Spider 只管解析产出,落到哪里、怎么落全交给 Pipeline。我在 ITEM_PIPELINES 里挂了三个管道,JSON、CSV、MySQL 各管一摊,想加一种输出就加一个管道,爬虫主体一行不用动。把"取数"和"存数"隔开,是这次最实用的一课。

真正让我记牢的,反倒是两个跟爬虫逻辑无关、却能让爬虫直接跑不起来的坑:一是有次忘了启动 MySQL,spider 刚打开就抛 ConnectionRefusedError,一条都没抓到,后来给连接加了 try/except,连不上就自动切 SQLite 并打日志说明原因;二是 scrapy.cfg 里一行中文注释,在 Windows 的 GBK 解码上翻了车,改成英文注释才正常。环境配置看似与代码无关,却是作业能不能跑起来的第一道门。

另外还有个细节:停牌股的价格是 "-",我统一转成 0 再入库。真实数据永远有例外,先想好脏数据怎么处理,入库时才不会卡住。最后数据库、JSON、CSV 三处条数都对得上(都是 100),才算真的跑通。

三、作业3代码与图片:

Gitee文件夹链接:作业3

3.1 作业代码与运行结果

(1)实现思路

中行这个页面是服务端渲染的,表格结构很规整。id="priceTable" 的表格第一行是表头,从第二行起是 44 个币种的牌价:

//table[@id="priceTable"]//tr[position()>1]

每行 8 个 <td>,我只取需要的 6 个:货币名称、现汇买入价、现钞买入价、现汇卖出价、现钞卖出价、发布时间。字段名直接沿用作业示例的 Currency / TBP / CBP / TSP / CSP / Time。

(2)关键代码以及分析

forex_spider/items.py:

import scrapy

class ForexItem(scrapy.Item):
    """一条外汇牌价记录。"""

    Currency = scrapy.Field()          # 货币名称
    TBP = scrapy.Field()               # 现汇买入价(Telegraphic Buying Price)
    CBP = scrapy.Field()               # 现钞买入价(Cash Buying Price)
    TSP = scrapy.Field()               # 现汇卖出价(Telegraphic Selling Price)
    CSP = scrapy.Field()               # 现钞卖出价(Cash Selling Price)
    Time = scrapy.Field()              # 发布时间
    crawl_time = scrapy.Field()        # 入库时间

forex_spider/spiders/boc_spider.py:

from __future__ import annotations

from datetime import datetime

import scrapy

from forex_spider.items import ForexItem

class BocForexSpider(scrapy.Spider):
    name = "boc_forex"
    allowed_domains = ["boc.cn"]
    start_urls = ["https://www.boc.cn/sourcedb/whpj/"]

    def parse(self, response):
        """用 XPath 定位表格行,逐行封装为 ForexItem。"""
        rows = response.xpath('//table[@id="priceTable"]//tr[position()>1]')
        self.logger.info(f"XPath 共匹配到 {len(rows)} 行外汇数据")

        for row in rows:
            cells = [
                "".join(td.xpath(".//text()").getall()).strip()
                for td in row.xpath("./td")
            ]
            if len(cells) < 8:                
                continue

            item = ForexItem()
            item["Currency"] = cells[0]        # 货币名称
            item["TBP"] = cells[1]             # 现汇买入价
            item["CBP"] = cells[2]             # 现钞买入价
            item["TSP"] = cells[3]             # 现汇卖出价
            item["CSP"] = cells[4]             # 现钞卖出价
            item["Time"] = cells[7]            # 发布时间
            item["crawl_time"] = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
            yield item
class ForexMySQLPipeline:
    """把外汇牌价写入 MySQL 的 forex_rates 表。"""

    CREATE_SQL = """
        CREATE TABLE IF NOT EXISTS forex_rates (
            id         INT AUTO_INCREMENT PRIMARY KEY COMMENT '序号',
            Currency   VARCHAR(64)  NOT NULL COMMENT '货币名称',
            TBP        VARCHAR(32)  COMMENT '现汇买入价',
            CBP        VARCHAR(32)  COMMENT '现钞买入价',
            TSP        VARCHAR(32)  COMMENT '现汇卖出价',
            CSP        VARCHAR(32)  COMMENT '现钞卖出价',
            Time       VARCHAR(32)  COMMENT '发布时间',
            crawl_time DATETIME     COMMENT '入库时间',
            UNIQUE KEY uk_currency_time (Currency, Time)
        ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
    """

    def process_item(self, item, spider):
        adapter = ItemAdapter(item)
        values = tuple(adapter.get(field, "") for field in FIELDS)
        placeholders = ",".join(["?"] * len(FIELDS)) if self.use_sqlite \
            else ",".join(["%s"] * len(FIELDS))
        if self.use_sqlite:
            sql = (f"INSERT OR REPLACE INTO forex_rates ({','.join(FIELDS)}) "
                   f"VALUES ({placeholders})")
        else:
            sql = (f"INSERT INTO forex_rates ({','.join(FIELDS)}) VALUES ({placeholders}) "
                   f"ON DUPLICATE KEY UPDATE TBP=VALUES(TBP),CBP=VALUES(CBP),"
                   f"TSP=VALUES(TSP),CSP=VALUES(CSP),crawl_time=VALUES(crawl_time)")
        self.cursor.execute(sql, values)
        self.conn.commit()
        return item

牌价用 VARCHAR 而不是 DECIMAL,因为部分小币种某些栏位是空的,字符串类型能原样保留空值。

(3)运行结果

终端输出:
d5e84a0be95eb3486d1b44ee33231893
XPath 匹配到 44 行,全部入库。
image
image

3.2 作业心得

这次作业最大的收获,是明白了XPath 本身不难,难的是写之前有没有把页面结构看清楚。

中行外汇页面是服务端渲染的,比东方财富那种 JS 表格老实多了。我没急着写选择器,先用浏览器确认了表格的 id 是 priceTable、第一行是表头、从第二行起是 44 个币种的牌价,然后才写出 //table[@id="priceTable"]//tr[position()>1]。先看清结构再写选择器,比写完再反复调试快得多。

解析时还有个坑:单元格里混着换行和空白,直接用 text() 经常取到空串。我改成 .//text() 把子节点文本全取出来再拼接、strip,才稳定拿到值。字段命名沿用了作业示例的 Currency / TBP / CBP / TSP / CSP / Time,牌价列特意用 VARCHAR 而不是 DECIMAL——因为有些小币种的某些栏位本来就是空的,字符串类型能原样保留,不会在入库时报错。真实数据里的"空"比"有值"更需要照顾。

最有意思的是唯一键那一课。我用「币种 + 发布时间」建了唯一键,本意是重复跑不产生脏数据,结果有次跑了两批,页面上的牌价时间(时分秒)不一样,两批都被当成新记录插进去,表里积到 88 条,最后删掉旧批次才恢复成 44。唯一键建得对不对,要看重复运行之后才知道,光跑一次是测不出来的。

最终 XPath 匹配到 44 行、数据库也是 44 条,跟页面数一致,这张截图才敢贴进博客。数字对得上,是爬虫正确性最朴素也最靠谱的证明。

四、作业总结

三道题做完,最大的体会是先看数据怎么给,再决定用什么工具,别一上来就挑解析器。气象网是普通静态 <img> 标签,BeautifulSoup 就够;中行是服务端渲染好的规整表格,XPath 一击即中;东财表面也是表格,数据却来自 JSON 接口,硬用 XPath 只会白费功夫。同一个"爬"字,背后是三种完全不同的数据供给方式。

第二个体会是关于结构的:Scrapy 的 Item / Pipeline 分工确实能让代码变整齐。Spider 只负责产出结构化数据,落地到 JSON、CSV、MySQL 由不同 Pipeline 各管各的,想加一种输出就加一个管道,不用动爬虫主体。职责切开之后,改哪一块都不慌。

第三个体会来自踩坑,主题是稳定性比速度重要:图片站并发开到 8 就被 403,降到 4、加退避重试、再配串行补漏才稳;MySQL 忘启动会让爬虫在打开阶段就崩,加了自动降级 SQLite 之后才不会白跑;连 scrapy.cfg 一行中文注释都能在 GBK 解码上翻车。这些都不是"跑通之后再说"的细节,而是决定作业能不能交出去的关键。

最后一点是验证。单线程和多线程各保存 110 张、URL 日志基本一致,这本身就是交叉验证——能在并发下得到和串行相同的结果,才算真的跑对了;数据库、JSON、CSV 三处条数也对得上(股票 100、外汇 44)。爬虫的终点不是"抓到了",而是"抓对了、能复现"。

收个尾:按学号限制页数和数量、给并发设上限、遇到 403 退避重试,这些动作看似在给自己设限,其实既是保护对方服务器,也是保护自己的 IP。技术之外,分寸感同样是数据采集的一部分。

posted @ 2026-11-18 21:09  Cactus061  阅读(2)  评论(0)    收藏  举报