数据采集第三次作业

实验3:图片与结构化数据采集

3-1 中国气象网图片爬虫

3-1.1 作业代码与运行结果

(1)单线程版本:1.py

实现思路:

  1. 使用 requests 请求中国气象网页面;
  2. 使用正则表达式提取所有 <img src="..."> 图片地址;
  3. 使用 urljoin 将相对地址补全为绝对地址;
  4. 按学号限制页数和图片数量;
  5. 按顺序下载图片,并保存到 images 文件夹。

核心代码:

"""中国气象网图片爬虫(单线程版本)。"""

import os
import re
from urllib.parse import urljoin

import requests

# 学号后 2 位、后 3 位,用来限制翻页数和下载数量
MAX_PAGES = 37
MAX_IMAGES = 137

# 中国气象网首页和图片频道,后面拼接分页地址
PAGE_URLS = [
    "http://www.weather.com.cn/",
    "http://www.weather.com.cn/photo/",
]
PAGE_URLS += [
    "http://www.weather.com.cn/photo/index_%d.shtml" % i
    for i in range(1, 50)
]

# 图片保存目录
IMAGE_DIR = "images"

# 请求头,模拟浏览器访问
HEADERS = {
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
                  "AppleWebKit/537.36 (KHTML, like Gecko) "
                  "Chrome/120.0.0.0 Safari/537.36",
    "Referer": "http://www.weather.com.cn/",
}

# 保存下载成功的图片序号
ok = []


def get_images(page_url):
    """请求页面,并用正则表达式提取页面中的图片地址。"""
    response = requests.get(page_url, headers=HEADERS)

    # 匹配 <img ... src="图片地址">,同时兼容单引号
    src_list = re.findall(
        r'<img[^>]+src=["\']([^"\']+)["\']',
        response.content.decode("utf-8"),
        re.I
    )

    images = []
    for src in src_list:
        # 跳过 base64 内嵌图片
        if src.startswith("data:"):
            continue
        # 把相对路径补全成完整 URL
        images.append(urljoin(page_url, src))
    return images


def download(index, url):
    """下载单张图片,按序号命名并保存到 images 目录。"""
    response = requests.get(url, headers=HEADERS)

    # 从 URL 中取扩展名,取不到就默认 .jpg
    ext = os.path.splitext(url.split("?")[0])[1] or ".jpg"
    path = os.path.join(IMAGE_DIR, str(index) + ext)

    # 图片是二进制文件,所以用 wb 模式写入
    with open(path, "wb") as f:
        f.write(response.content)

    print(index, url)
    ok.append(index)


def main():
    """采集图片地址,限制页数和数量,然后逐张下载。"""
    os.makedirs(IMAGE_DIR, exist_ok=True)

    all_images = []

    # 只访问前 MAX_PAGES 页,并对图片地址去重
    for page_url in PAGE_URLS[:MAX_PAGES]:
        for image_url in get_images(page_url):
            if image_url not in all_images:
                all_images.append(image_url)

    image_urls = all_images[:MAX_IMAGES]
    for index, url in enumerate(image_urls, start=1):
        download(index, url)

    print("下载完成,成功", len(ok), "张")


if __name__ == "__main__":
    main()

单线程版本的执行过程可以拆成四步:

  1. 准备页面地址:PAGE_URLS 先放首页和图片频道第一页,再用列表推导式生成 index_1.shtml 到 index_49.shtml。
  2. 提取图片地址:get_images() 请求一个页面,用 re.findall() 找到所有 src,再用 urljoin() 把 /images/a.jpg 这样的相对路径补全。
  3. 限制数量:PAGE_URLS[:MAX_PAGES] 只取前 37 页,all_images[:MAX_IMAGES] 只保留前 137 张。
  4. 逐张下载:download() 请求图片,根据扩展名生成文件名,用 "wb" 二进制模式写入 images/。

正则表达式 r'<img[^>]+src=["\']([^"\']+)["\']' 的含义:

  • <img[^>]+:匹配 <img 开头,后面至少有一个不是 > 的字符;
  • src=:定位 src 属性;
  • ["\']:双引号或单引号;
  • ([^"\']+):用括号捕获引号中的图片地址;
  • re.I:忽略大小写。

(2)多线程版本:1_multi.py

多线程版本使用 Thread 分批下载,每批最多启动 5 个线程,避免一次性创建过多线程。

"""中国气象网图片爬虫(多线程版本)。"""

import os
import re
from threading import Thread
from urllib.parse import urljoin

import requests

# 学号后 2 位、后 3 位,以及每批并发线程数
MAX_PAGES = 37
MAX_IMAGES = 137
THREADS = 5

# 中国气象网首页和图片频道,后面拼接分页地址
PAGE_URLS = [
    "http://www.weather.com.cn/",
    "http://www.weather.com.cn/photo/",
]
PAGE_URLS += [
    "http://www.weather.com.cn/photo/index_%d.shtml" % i
    for i in range(1, 50)
]

# 图片保存目录(放在当前脚本所在目录)
IMAGE_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "images")

# 请求头,模拟浏览器访问
HEADERS = {
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
                  "AppleWebKit/537.36 (KHTML, like Gecko) "
                  "Chrome/120.0.0.0 Safari/537.36",
}

# 保存下载成功的图片序号
ok = []


def get_images(page_url):
    """请求页面,并用正则表达式提取页面中的图片地址。"""
    response = requests.get(page_url, headers=HEADERS)
    html = response.content.decode("utf-8")

    # 匹配 <img ... src="图片地址">,同时兼容单引号
    src_list = re.findall(
        r'<img[^>]+src=["\']([^"\']+)["\']',
        html,
        re.I
    )

    images = []
    for src in src_list:
        # 跳过 base64 内嵌图片
        if src.startswith("data:"):
            continue
        # 把相对路径补全成完整 URL
        images.append(urljoin(page_url, src))
    return images


def download(index, url):
    """下载单张图片,按序号命名并保存到 images 目录。"""
    response = requests.get(url, headers=HEADERS, timeout=20)

    # 从 URL 中取扩展名,取不到就默认 .jpg
    ext = os.path.splitext(url.split("?")[0])[1] or ".jpg"
    path = os.path.join(IMAGE_DIR, str(index) + ext)

    # 图片是二进制文件,所以用 wb 模式写入
    with open(path, "wb") as f:
        f.write(response.content)

    print(index, url)
    ok.append(index)


def main():
    """采集图片地址,限制页数和数量,再分批启动线程下载。"""
    os.makedirs(IMAGE_DIR, exist_ok=True)

    all_images = []

    # 只访问前 MAX_PAGES 页,并对图片地址去重
    for page_url in PAGE_URLS[:MAX_PAGES]:
        for image_url in get_images(page_url):
            if image_url not in all_images:
                all_images.append(image_url)

    image_urls = all_images[:MAX_IMAGES]
    print("共找到", len(all_images), "张,本次下载", len(image_urls), "张")

    # 每批最多启动 THREADS 个线程,等这一批结束后再启动下一批
    for start in range(0, len(image_urls), THREADS):
        threads = []

        for index in range(start, min(start + THREADS, len(image_urls))):
            thread = Thread(
                target=download,
                args=(index + 1, image_urls[index])
            )
            threads.append(thread)
            thread.start()

        for thread in threads:
            thread.join()

    print("下载完成,成功", len(ok), "张")


if __name__ == "__main__":
    main()

多线程版本和单线程版本前面采集 URL 的过程完全一样,区别只在下载部分:

  • range(0, len(image_urls), THREADS):每 5 张图片分成一组;
  • Thread(target=download, args=(index + 1, image_urls[index])):创建一个线程,target 是下载函数,args 是传给函数的参数;
  • thread.start():启动线程;
  • thread.join():等待这一批线程全部结束,再开始下一批。

如果一次性启动 137 个线程,虽然速度可能更快,但会给网站和本机都带来较大压力,也容易出现连接被重置。所以这里采用“分批并发”的方式,把并发数量控制在 5 个。

运行结果:
屏幕截图 2026-11-16 135808
屏幕截图 2026-11-16 135858

gitee:https://gitee.com/wqwabc/data-collection-and-fusion/tree/main/作业3/1

3-1.2 作业心得

这次图片爬虫让我第一次完整地接触了“请求页面、提取链接、下载文件”的流程。最开始我使用 BeautifulSoup 解析 <img> 标签,后来按照老师的要求改成正则表达式。正则的写法是 <img[^>]+src=["\']([^"\']+)["\'],它的含义是:先找到 <img,再匹配到 src=,最后用括号把引号中的地址提取出来。

通过这次作业,我理解了单线程和多线程的区别:单线程实现简单、顺序稳定;多线程下载速度更快,但需要注意线程数量和执行顺序。图片下载虽然逻辑不复杂,但异常情况很多,例如 404、网络超时、文件名重复等,实际写代码时要多做检查。

3-2 东方财富股票行情

3-2.1 作业代码与运行结果

股票爬虫位于 作业3/2/eastmoney_scrapy。东方财富的 clist 接口在当前网络下会直接断开 Python 连接,因此这里使用东方财富的涨停板池接口获取股票数据。

Scrapy 程序的运行流程是:

  1. start() 构造请求参数并生成 scrapy.Request;
  2. Scrapy 下载器请求接口;
  3. 响应交给 parse() 回调;
  4. parse() 把每条股票封装成 EastmoneyScrapyItem;
  5. Pipeline 把 Item 写入 SQLite。

stocks.py 的核心代码:

"""东方财富股票行情爬虫(涨停板池接口)。"""

import json
from datetime import datetime
from urllib.parse import urlencode

import scrapy

from eastmoney_scrapy.items import EastmoneyScrapyItem


class StocksSpider(scrapy.Spider):
    """东方财富沪深 A 股行情爬虫(涨停板池接口)。"""

    name = "stocks"
    allowed_domains = ["eastmoney.com"]

    pool_url = "https://push2ex.eastmoney.com/getTopicZTPool"

    async def start(self):
        # Scrapy 2.13+ 用异步 start() 取代了 start_requests(),2.19 已移除后者
        today = datetime.now().strftime("%Y%m%d")
        params = {
            "ut": "7eea3edcaed734bea9cbfc24409ed989",
            "dpt": "wz.ztzt",
            "Pageindex": 0,   # 第 1 页
            "pagesize": 50,   # 每页 50 只
            "sort": "fbt:asc",
            "date": today,
        }
        yield scrapy.Request(
            self.pool_url + "?" + urlencode(params),
            callback=self.parse,
        )

    def parse(self, response):
        # 接口返回 UTF-8 编码的 JSON,data.pool 是股票列表
        data = json.loads(response.text)
        pool = data["data"]["pool"]
        self.logger.info("接口返回 %s 只股票", len(pool))

        for row in pool:
            item = EastmoneyScrapyItem()
            item["stock_code"] = row["c"]
            item["stock_name"] = row["n"]

            # 涨停板池里的价格放大了 1000 倍,例如 5010 表示 5.01
            price = self.to_number(row["p"])
            if price is not None:
                price = price / 1000

            change_pct = self.to_number(row["zdp"])

            # 用价格和涨跌幅反推昨收、涨跌额(clist/K 线接口不可用,拿不到今开高低量)
            prev_close = None
            change_amount = None
            if price is not None and change_pct is not None:
                prev_close = round(price / (1 + change_pct / 100), 2)
                change_amount = round(price - prev_close, 2)

            item["latest_price"] = price
            item["change_pct"] = change_pct
            item["change_amount"] = change_amount
            item["prev_close"] = prev_close

            # 存 NULL
            item["volume"] = None
            item["amplitude"] = None
            item["high"] = None
            item["low"] = None
            item["open_price"] = None

            yield item

    @staticmethod
    def to_number(value):
        """接口里的 '-'、空值表示没有数据,转成 None。"""
        if value is None or value == "-" or value == "":
            return None
        return float(value)
  • name = "stocks":爬虫名称,运行时使用 scrapy crawl stocks;
  • allowed_domains:限制只访问东方财富域名;
  • pool_url:涨停板池接口地址;
  • start():Scrapy 2.13 之后推荐使用异步 start(),不再使用旧的 start_requests();
  • urlencode(params):把字典参数编码成 URL 查询字符串;
  • json.loads(response.text):把返回文本解析成字典;
  • item["stock_code"]、item["stock_name"]:把 JSON 字段映射成 Item 字段。

Pipeline 负责把 Item 写入 SQLite。使用 ON CONFLICT ... DO UPDATE,保证重复运行不会产生重复股票:

"""Scrapy Pipeline:把东方财富股票行情写入 SQLite。"""

import sqlite3
from datetime import datetime

from itemadapter import ItemAdapter


class EastmoneyScrapyPipeline:
    """把 Scrapy Item 写入 SQLite。"""

    def open_spider(self, spider):
        """连接 SQLite,并重建 stocks 表。"""
        # 数据库路径写在 settings.py 中,默认 stocks.db
        db_path = spider.settings.get("SQLITE_DB", "stocks.db")

        self.conn = sqlite3.connect(db_path)
        self.cursor = self.conn.cursor()

        # 每次运行重建表,保证保存的是最新一次采集结果
        self.cursor.execute("DROP TABLE IF EXISTS stocks")
        self.cursor.execute("""
            CREATE TABLE stocks (
                stock_code TEXT PRIMARY KEY,  -- 股票代码
                stock_name TEXT,              -- 股票名称
                latest_price REAL,            -- 最新价
                change_pct REAL,              -- 涨跌幅
                change_amount REAL,           -- 涨跌额
                volume REAL,                  -- 成交量
                amplitude REAL,               -- 振幅
                high REAL,                    -- 最高价
                low REAL,                     -- 最低价
                open_price REAL,              -- 今开
                prev_close REAL,              -- 昨收
                crawl_time TEXT               -- 采集时间
            )
        """)
        self.conn.commit()
        spider.logger.info("SQLite 数据库:%s,表:stocks", db_path)

    def process_item(self, item, spider):
        """把一条股票行情写入 stocks 表。"""
        # ItemAdapter 可以把 Item 当成字典来读取字段
        data = ItemAdapter(item)
        sql = """
            INSERT INTO stocks (
                stock_code, stock_name, latest_price, change_pct,
                change_amount, volume, amplitude, high, low,
                open_price, prev_close, crawl_time
            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
            ON CONFLICT (stock_code) DO UPDATE SET
                stock_name = excluded.stock_name,
                latest_price = excluded.latest_price,
                change_pct = excluded.change_pct,
                change_amount = excluded.change_amount,
                volume = excluded.volume,
                amplitude = excluded.amplitude,
                high = excluded.high,
                low = excluded.low,
                open_price = excluded.open_price,
                prev_close = excluded.prev_close,
                crawl_time = excluded.crawl_time
        """
        values = (
            data.get("stock_code"),
            data.get("stock_name"),
            data.get("latest_price"),
            data.get("change_pct"),
            data.get("change_amount"),
            data.get("volume"),
            data.get("amplitude"),
            data.get("high"),
            data.get("low"),
            data.get("open_price"),
            data.get("prev_close"),
            datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
        )
        # 使用参数化查询,避免 SQL 注入
        self.cursor.execute(sql, values)
        self.conn.commit()

        spider.logger.info("已保存股票:%s %s",
                           data.get("stock_code"), data.get("stock_name"))
        return item

    def close_spider(self, spider):
        if self.conn is not None:
            self.conn.close()

Pipeline 的作用是把“解析数据”和“保存数据”分开。Spider 只负责产出 Item,Pipeline 负责建表、插入和更新。这样做的好处是,如果以后要把 SQLite 换成 MySQL,只需要修改 Pipeline,不需要改爬虫的解析逻辑。

SQLite 表使用 stock_code 作为主键,同一只股票重复抓取时会执行 UPDATE,不会产生重复记录。DROP TABLE 在每次启动时清空旧表,保证数据库里保存的是本次运行的最新结果。

运行结果:

屏幕截图 2026-11-16 142231
image

gitee : https://gitee.com/wqwabc/data-collection-and-fusion/tree/main/作业3/2/eastmoney_scrapy

3-2.2 作业心得

这次东方财富股票爬虫让我对 Scrapy 的 Item、Spider 和 Pipeline 有了更直观的理解。最开始我直接请求东方财富的行情接口,但程序无法稳定获取数据,请求经常被服务器断开。排查后我发现,问题不在参数,而是接口在当前网络环境下不适合直接调用。后来我改用东方财富提供的另一组股票数据接口,虽然返回的字段没有原来那么完整,但能够稳定拿到股票代码、名称、最新价、涨跌幅等基础行情。

在解析数据时,我发现接口里的价格放大了 1000 倍,例如 5010 实际表示 5.01,所以需要除以 1000 才能得到真实价格。接口也没有直接给出昨收和涨跌额,我就根据最新价和涨跌幅反推:先计算昨收,再计算涨跌额。这个过程让我意识到,爬虫不只是把数据取下来,还要理解每个字段的含义,并做必要的单位转换和数据计算。

Scrapy 的分层结构让我体会很深。Spider 负责发送请求和解析数据,Item 负责定义字段,Pipeline 负责写入数据库和打印结果。这样如果以后要把 SQLite 换成 MySQL,只需要修改 Pipeline,不需要改动爬虫的解析逻辑。分页时使用 Pageindex 从 0 开始请求,当前页数据不足一页时提前结束,避免发送无效请求;不同页可能出现重复股票,因此又用股票代码做了一次去重。

3-3 中国银行外汇牌价

3-3.1 作业代码与运行结果

外汇牌价爬虫位于 作业3/3/boc_scrapy,使用 Selector.xpath 解析中国银行牌价表,Pipeline 使用 SQLite 保存。

中国银行牌价页面的数据在 <table id="priceTable"> 中,表头是“货币名称、现汇买入价、现钞买入价、现汇卖出价、现钞卖出价、中行折算价、发布日期、发布时间”。每个货币对应一个 <tr>,里面有 8 个 <td>。因此可以用 //table[@id="priceTable"]//tr[td] 只选有数据的行,再用 tds[0] 到 tds[7] 按位置取值。

exchange_rate.py 的核心代码:

"""中国银行外汇牌价爬虫:使用 Selector.xpath 解析 HTML 表格。"""

import scrapy
from scrapy import Selector

from boc_scrapy.items import BocScrapyItem


class ExchangeRateSpider(scrapy.Spider):
    """抓取中国银行外汇牌价页面,并逐行解析货币价格。"""

    name = "exchange_rate"
    allowed_domains = ["boc.cn"]
    start_urls = ["https://www.boc.cn/sourcedb/whpj/"]

    def parse(self, response):
        selector = Selector(text=response.body.decode("utf-8"))

        # 用 selector.xpath 解析 id=priceTable 的外汇牌价表
        rows = selector.xpath('//table[@id="priceTable"]//tr[td]')
        self.logger.info("找到 %s 条外汇牌价", len(rows))

        for row in rows:
            tds = row.xpath("./td")
            if len(tds) < 8:
                continue

            currency = tds[0].xpath("./text()").get()
            if not currency:
                continue

            tbp = tds[1].xpath("./text()").get()   # 现汇买入价
            cbp = tds[2].xpath("./text()").get()   # 现钞买入价
            tsp = tds[3].xpath("./text()").get()   # 现汇卖出价
            csp = tds[4].xpath("./text()").get()   # 现钞卖出价
            publish_date = tds[6].xpath("./text()").get()
            publish_time = tds[7].xpath("./text()").get()

            item = BocScrapyItem()
            item["currency"] = currency.strip()
            item["tbp"] = tbp.strip() if tbp else None
            item["cbp"] = cbp.strip() if cbp else None
            item["tsp"] = tsp.strip() if tsp else None
            item["csp"] = csp.strip() if csp else None
            item["publish_date"] = publish_date.strip() if publish_date else ""
            item["publish_time"] = publish_time.strip() if publish_time else ""
            yield item

XPath 解析的关键点:

  • Selector(text=response.body.decode("utf-8")):先按 UTF-8 解码,再交给 Selector;
  • //table[@id="priceTable"]:定位 id=priceTable 的表格;
  • //tr[td]:只选包含 <td> 的行,跳过表头等没有 <td> 的行;
  • row.xpath("./td"):取当前行下的所有单元格;
  • tds[1].xpath("./text()").get():取第 2 个 <td> 的直接文本,get() 返回第一段文本;
  • if tbp else None:如果价格为空,就保存 NULL,避免把空字符串写入数据库。

页面的响应头写的是 ISO-8859-1,但实际内容是 UTF-8。如果不显式解码,货币名称“阿联酋迪拉姆”“澳大利亚元”等会变成乱码,这是本次实验中遇到的一个典型编码问题。

SQLite Pipeline 的核心代码:

# Define your item pipelines here
#
# See documentation in:
# https://docs.scrapy.org/en/latest/topics/item-pipeline.html

"""Scrapy Pipeline:把中国银行外汇牌价写入 SQLite。"""

import sqlite3
from datetime import datetime

from itemadapter import ItemAdapter


class BocScrapyPipeline:
    """把中国银行外汇牌价 Item 写入 SQLite。"""

    def open_spider(self, spider):
        """连接 SQLite,并重建 exchange_rates 表。"""
        # 数据库路径写在 settings.py 中,默认 boc_rates.db
        db_path = spider.settings.get("SQLITE_DB", "boc_rates.db")

        self.conn = sqlite3.connect(db_path)
        self.cursor = self.conn.cursor()

        # 每次运行保存最新一版牌价,避免重复累积
        self.cursor.execute("DROP TABLE IF EXISTS exchange_rates")
        self.cursor.execute("""
            CREATE TABLE exchange_rates (
                id INTEGER PRIMARY KEY AUTOINCREMENT,  -- 自增编号
                currency TEXT NOT NULL UNIQUE,         -- 货币名称
                tbp REAL,                              -- 现汇买入价
                cbp REAL,                              -- 现钞买入价
                tsp REAL,                              -- 现汇卖出价
                csp REAL,                              -- 现钞卖出价
                publish_date TEXT,                     -- 发布日期和时间
                publish_time TEXT,                     -- 发布时间
                crawl_time TEXT                        -- 采集时间
            )
        """)
        self.conn.commit()
        spider.logger.info("SQLite 数据库:%s,表:exchange_rates", db_path)

    def process_item(self, item, spider):
        """把一条外汇牌价写入 exchange_rates 表。"""
        # ItemAdapter 用于统一读取 Scrapy Item 的字段
        data = ItemAdapter(item)
        sql = """
            INSERT INTO exchange_rates (
                currency, tbp, cbp, tsp, csp,
                publish_date, publish_time, crawl_time
            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
            ON CONFLICT (currency) DO UPDATE SET
                tbp = excluded.tbp,
                cbp = excluded.cbp,
                tsp = excluded.tsp,
                csp = excluded.csp,
                publish_date = excluded.publish_date,
                publish_time = excluded.publish_time,
                crawl_time = excluded.crawl_time
        """
        values = (
            data.get("currency"),
            data.get("tbp"),
            data.get("cbp"),
            data.get("tsp"),
            data.get("csp"),
            data.get("publish_date"),
            data.get("publish_time"),
            datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
        )
        # 参数化执行 SQL,再把修改提交到数据库
        self.cursor.execute(sql, values)
        self.conn.commit()

        spider.logger.info("已保存外汇牌价:%s %s",
                           data.get("currency"), data.get("publish_time"))
        return item

    def close_spider(self, spider):
        if self.conn is not None:
            self.conn.close()

SQLite 表 exchange_rates 的字段含义:

字段 含义
id 自增主键
currency 货币名称,唯一
tbp 现汇买入价
cbp 现钞买入价
tsp 现汇卖出价
csp 现钞卖出价
publish_date 发布日期和时间
publish_time 发布时间
crawl_time 本次采集时间

currency 设置成唯一键,Pipeline 使用 ON CONFLICT (currency) DO UPDATE,同一个货币重复抓取时会更新价格,而不是插入重复行。

运行结果:
屏幕截图 2026-11-16 142351
屏幕截图 2026-11-16 142431

gitee : https://gitee.com/wqwabc/data-collection-and-fusion/tree/main/作业3/3/boc_scrapy

3-3.2 作业心得

在外汇牌价爬虫中,我重点练习了 XPath。//table[@id="priceTable"]//tr[td] 可以定位到所有包含 <td> 的数据行,tds[1].xpath("./text()").get() 则可以取出单元格中的文字。中国银行页面的响应头写的是 ISO-8859-1,但实际内容是 UTF-8,所以需要先按 UTF-8 解码,否则中文货币名称会变成乱码。

在外汇牌价部分,XPath 的位置写法比较依赖页面结构:tds[1] 表示第 2 个单元格,如果以后银行页面增加或删除一列,索引就会错位。更稳妥的做法是根据表头文字动态计算列的位置,或者用 td[@data-...] 这样的属性定位。当前页面结构稳定,所以使用固定索引是最简单的实现。

总的来说,这次作业不仅让我掌握了 requests、正则、XPath、Scrapy 和 SQLite 的基本用法,也让我体会到数据采集的完整性很重要:请求成功不代表数据一定完整,接口字段、编码、重复数据和异常情况都需要在代码中处理。

posted @ 2026-11-18 08:24  WQWa  阅读(3)  评论(0)    收藏  举报