第三次作业:网站图片采集与 Scrapy 数据入库

姓名:张佩琪  学号:102402102

实验时间:2026 年 11 月 20 日

仓库地址:https://gitee.com/novavespera/python-crawler-assignments/tree/master/作业3

学号后两位是 02,因此爬取页面上限为 2 个;后三位是 102,因此图片下载总量上限为 102 张。两个限制都写进了程序参数与运行逻辑,而不是只在报告里口头说明。

一、作业①:中国天气网图片的单线程与多线程采集

1. 作业代码、实现过程与运行结果

(1)目标与范围。 选择中国天气网,抓取首页和北京天气页这两个页面中 img、source 标签公开给出的图片:首页负责站内各频道的图片,北京天气页负责具体城市页面中的天气图与资讯图。程序只请求这 2 个 HTML 页面,不做全站遍历;候选图片按 URL 去重后取前 51 条,单线程和多线程各下载一次,合计最多保存 102 张。

(2)实现方法。 用 requests 取页面,用 lxml 的 XPath 同时解析 src、data-src、data-original、data-lazy-src 以及 srcset,把相对地址补全为绝对地址并按 URL 去重。下载部分写成独立函数 download_image,单线程直接顺序调用,多线程用 ThreadPoolExecutor(max_workers=4) 分发同一批任务。每张图片限制 12 MB、最多重试 2 次,下载完成后先用 Pillow 解码校验,再以“临时文件 + 原子替换”的方式写入 images/<运行时间>/single 或 multi,避免留下半截文件。控制台逐条打印成功或失败的 URL,同时生成 manifest.json 记录文件名、字节数、SHA-256,便于复核。

(3)运行命令。 在 PyCharm 的“作业1 图片采集”运行配置中执行:

python 1.py --pages 2 --max-images 102 --workers 4

(4)本次运行结果。 两个页面共解析出 79 条去重后的图片 URL,各取前 51 条参与下载:

方式 成功 失败 耗时 保存位置
单线程 49 2 30.271 秒 images/20261120_005121/single
多线程(4 线程) 49 2 9.555 秒 images/20261120_005121/multi

两种方式合计保存 98 / 102 张,没有超过学号规定的上限。失败的 2 条都是网页上已经过期的雷达产品图,服务器返回 404;程序把它们记为 FAIL 而不是补空文件凑数。单线程耗时约为多线程的 3.2 倍,说明线程池确实让网络等待重叠了起来;但这一数字只代表本次网络状况,不能当成固定的加速比。

(5)运行截图。 下面是在 PyCharm 中真实运行 1.py 的连续截图:由于每条图片 URL 都单独输出,控制台较长,按滚动位置分为三张(上、中、下),最后一张保留“进程已结束,退出代码为 0”。

01_任务1_PyCharm运行_1

图1:PyCharm 运行面板:两个页面、去重后 79 条 URL、单线程逐条下载。

02_任务1_PyCharm运行_2

图2:单线程 49 成功、2 失败、30.27 秒,随后开始多线程下载。

03_任务1_PyCharm运行_3

图3:多线程 49 成功、2 失败、9.56 秒,合计 98/102,退出代码为 0。

04_任务1_图片预览

图4:从本次 images 目录抽取的 12 张图片拼成的预览图,其余图片随目录一并提交。

05_任务1_天气网首页

图5:浏览器实际打开的中国天气网首页(抓取页面之一),地址栏可见。

06_任务1_北京天气页

图6:浏览器实际打开的北京天气页(抓取页面之二)。

(6)完整代码:1.py

"""作业①:中国天气网图片采集,分别用单线程和多线程下载。

在 PyCharm 直接运行本文件。最多请求 2 个 HTML 页面;两种方式合计
最多保存 102 张图片(学号 102402102),同一批 URL 各下载一次以便比较。
图片范围为所选页面 img/source 标签公开列出的图片,不无限遍历全站。
"""

from concurrent.futures import ThreadPoolExecutor
from io import BytesIO
from pathlib import Path
from urllib.parse import urldefrag, urljoin, urlparse
import argparse
import hashlib
import json
import time

from lxml import html
from PIL import Image
import requests

ROOT = Path(__file__).resolve().parent
PAGES = [
    'http://www.weather.com.cn/',
    'http://www.weather.com.cn/weather1d/101010100.shtml',
]
HEADERS = {'User-Agent': 'Mozilla/5.0 (student image assignment)'}
MAX_BYTES = 12 * 1024 * 1024

def fetch_image_urls(page_limit):
    """提取普通图片和懒加载图片,补全相对路径并按 URL 去重。"""
    found = {}
    session = requests.Session()
    session.trust_env = False
    session.headers.update(HEADERS)
    try:
        for index, page_url in enumerate(PAGES[:page_limit], 1):
            response = session.get(page_url, timeout=(10, 25))
            response.raise_for_status()
            tree = html.fromstring(response.content)
            for node in tree.xpath('//img | //source'):
                values = [node.get(key, '') for key in
                          ('src', 'data-src', 'data-original', 'data-lazy-src')]
                for key in ('srcset', 'data-srcset'):
                    values.extend(part.strip().split()[0]
                                  for part in node.get(key, '').split(',')
                                  if part.strip())
                for value in values:
                    url = urldefrag(urljoin(response.url, value.strip()))[0]
                    if value and urlparse(url).scheme in ('http', 'https'):
                        found.setdefault(url, response.url)
            print(f'页面 {index}/{page_limit}:{response.url}', flush=True)
            time.sleep(0.3)
    finally:
        session.close()
    return list(found.items())

def download_image(job):
    """每个下载任务使用独立连接;校验图片后再原子保存。"""
    index, url, referer, folder = job
    error = None
    for attempt in range(2):
        try:
            with requests.Session() as session:
                session.trust_env = False
                with session.get(url, headers={**HEADERS, 'Referer': referer},
                                 stream=True, timeout=(10, 25)) as response:
                    response.raise_for_status()
                    content = bytearray()
                    for chunk in response.iter_content(65536):
                        content.extend(chunk)
                        if len(content) > MAX_BYTES:
                            raise ValueError('超过单图 12MB 限制')
            with Image.open(BytesIO(content)) as picture:
                image_format = picture.format
                picture.verify()
            extension = {'JPEG': '.jpg', 'PNG': '.png', 'GIF': '.gif',
                         'WEBP': '.webp', 'BMP': '.bmp'}.get(image_format)
            if extension is None:
                raise ValueError(f'不支持的图片格式:{image_format}')
            filename = f'{index:03d}_{hashlib.sha256(url.encode()).hexdigest()[:10]}{extension}'
            destination = folder / filename
            temporary = destination.with_suffix('.part')
            temporary.write_bytes(content)
            temporary.replace(destination)
            print(f'[{folder.name} {index:03d}] OK {url}', flush=True)
            return {'url': url, 'file': str(destination.relative_to(ROOT)),
                    'bytes': len(content), 'sha256': hashlib.sha256(content).hexdigest()}
        except (requests.RequestException, OSError, ValueError) as exc:
            error = str(exc)
            if attempt == 0:
                time.sleep(0.5)
    print(f'[{folder.name} {index:03d}] FAIL {url} {error}', flush=True)
    return {'url': url, 'error': error}

def run_downloads(candidates, mode, workers, run_dir):
    """在同一批 URL 上比较串行和线程池;失败数单独记录。"""
    folder = run_dir / mode
    folder.mkdir(parents=True, exist_ok=True)
    jobs = [(index, url, referer, folder)
            for index, (url, referer) in enumerate(candidates, 1)]
    started = time.perf_counter()
    if mode == 'single':
        results = [download_image(job) for job in jobs]
    else:
        with ThreadPoolExecutor(max_workers=workers) as executor:
            results = list(executor.map(download_image, jobs))
    elapsed = time.perf_counter() - started
    success = sum('file' in item for item in results)
    print(f'{mode}:成功 {success},失败 {len(jobs)-success},耗时 {elapsed:.2f}s', flush=True)
    return {'mode': mode, 'success': success, 'seconds': round(elapsed, 3),
            'results': results}

def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument('--pages', type=int, choices=(1, 2), default=2)
    parser.add_argument('--max-images', type=int, default=102,
                        help='两种方式合计的保存上限,范围 2~102')
    parser.add_argument('--workers', type=int, choices=range(2, 5), default=4)
    args = parser.parse_args()
    if not 2 <= args.max_images <= 102:
        parser.error('--max-images 必须在 2~102 之间')
    candidates = fetch_image_urls(args.pages)
    print(f'去重图片 URL:{len(candidates)};两种方式总预算:{args.max_images}')
    candidates = candidates[:args.max_images // 2]
    if not candidates:
        raise RuntimeError('页面中没有找到图片,不将空结果视为采集成功')
    run_dir = ROOT / 'images' / time.strftime('%Y%m%d_%H%M%S')
    run_dir.mkdir(parents=True, exist_ok=False)
    reports = [run_downloads(candidates, mode, args.workers, run_dir)
               for mode in ('single', 'multi')]
    (run_dir / 'manifest.json').write_text(
        json.dumps(reports, ensure_ascii=False, indent=2), encoding='utf-8')
    print(f'本次总保存数:{sum(report["success"] for report in reports)} / {args.max_images}')
    print(f'图片目录:{run_dir}')
    if any(report['success'] == 0 for report in reports):
        raise RuntimeError('至少一种方式未下载成功,请查看 FAIL 记录')

if __name__ == '__main__':
    main()

2. 作业心得

这次实验最直接的体会是:“发出了请求”不等于“拿到了图片”。页面上列出的 URL 有一部分已经失效,返回 404;如果不做解码校验,只按响应状态计数,就会把坏文件当成成功。程序因此把成功、失败、耗时分别记录,并要求至少一种方式真的保存到文件才判定运行成功。

第二个体会是限制要落在代码里。总页数限制体现在 PAGES[:page_limit],总量限制体现在候选列表截断到 max_images // 2;如果只限制线程数而不限制任务数,仍然可能提交几百个下载任务。单线程与多线程使用同一批 URL,比较才有意义。

第三个体会是多线程的收益来自等待重叠。图片下载大部分时间花在等网络响应上,4 个线程能同时等 4 张图,所以本次从 33 秒降到 9.5 秒;但线程并不是越多越好,还要配合超时、重试和文件校验,否则失败会被放大。后续如果要做更严谨的性能对比,可以交替运行多次取中位数,而不是只看一次结果。

二、作业②与作业③:Scrapy、XPath 与 MySQL 数据采集

1. 作业代码、数据库存储与运行结果

(1)技术路线。 两个任务使用同一条链路:Scrapy Spider 负责请求与 XPath 提取,字段封装为 Item;Pipeline 用参数化 SQL 写入 MySQL;Scrapy 的 Feed Export 同时输出 CSV 与 JSONL,便于脱离数据库复核。金额统一用 Decimal 校验、数据库用 DECIMAL 保存,避免浮点误差;网页上没有报价时保存 NULL,绝不用 0 代替。每次运行生成一个 runId,提交后按 runId 查询入库条数,出现异常则整批回滚。

(2)股票采集(东方财富)。 目标页是东方财富行情中心第一页的前 20 条。这个页面的表格由 JavaScript 动态渲染,普通 HTTP 响应里没有 <tr>,因此下载中间件用无头 Edge 打开页面并等待“最新价”表头出现,再把渲染后的 DOM 包装成 HtmlResponse 交给 Spider;真正提取字段的仍然是 XPath,而不是手工抄数据或用 JSON 拼一张假表格。网页列中夹着“相关链接”和“成交额”,代码按列位置跳过相关链接,并保留成交额,避免后面字段整体错位。

字段 含义与单位
id / runId 自增序号 / 采集批次
bStockNo / bStockName 六位股票代码(保留前导零)/ 股票名称
bLatestPrice 最新价(元)
bChangePercent / bChangeAmount 涨跌幅(%)/ 涨跌额(元)
bVolumeHand / bTurnover 成交量(手)/ 成交额(元)
bAmplitude 振幅(%)
bHigh / bLow / bOpen / bPreviousClose 最高 / 最低 / 今开 / 昨收(元)
collectedAt 采集时间(UTC)

本次入库并回查 20 条,和网页第一页的 20 行一一对应。下表是从 stocks.csv 还原的入库内容(成交额换算为亿元,方便阅读;数据库里保存的是元):

序号 代码 名称 最新价 涨跌幅% 涨跌额 成交量(手) 成交额(亿元) 振幅% 最高 最低 今开 昨收
1 301348 蓝箭电子 21.66 20.00 3.61 375,500.00 7.84 20.78 21.66 17.91 18.07 18.05
2 301030 *ST仕净 2.88 20.00 0.48 211,100.00 0.59 19.58 2.88 2.41 2.41 2.40
3 301391 卡莱特 55.98 19.97 9.32 153,800.00 8.18 12.52 55.99 50.15 50.90 46.66
4 688691 灿芯股份 61.27 15.30 8.13 209,000.00 12.58 15.73 63.77 55.41 55.41 53.14
5 688172 燕东微 37.51 11.37 3.83 442,500.00 16.86 14.01 40.42 35.70 35.73 33.68
6 688419 耐科装备 37.71 10.75 3.66 64,000.00 2.38 20.88 40.86 33.75 34.67 34.05
7 688630 芯碁微装 228.00 10.62 21.89 98,600.00 21.74 14.24 236.60 207.24 209.00 206.11
8 920178 锐翔智能 65.73 10.47 6.23 25,100.00 1.69 22.12 72.66 59.50 60.00 59.50
9 688249 晶合集成 29.98 10.26 2.79 692,900.00 20.43 12.28 30.64 27.30 28.00 27.19
10 002418 康盛股份 4.02 10.14 0.37 599,900.00 2.36 11.23 4.02 3.61 3.62 3.65
11 000838 *ST发展 1.20 10.09 0.11 89,500.00 0.11 0.00 1.20 1.20 1.20 1.09
12 000610 *ST西旅 7.33 10.06 0.67 86,900.00 0.62 10.21 7.33 6.65 6.74 6.66
13 000711 京蓝科技 3.83 10.06 0.35 2,661,100.00 9.59 11.78 3.83 3.42 3.57 3.48
14 603928 兴业股份 12.38 10.04 1.13 528,000.00 6.27 12.98 12.38 10.92 11.05 11.25
15 002579 中京电子 12.17 10.04 1.11 777,600.00 9.15 11.84 12.17 10.86 11.00 11.06
16 600520 三佳科技 22.17 10.02 2.02 112,100.00 2.43 8.14 22.17 20.53 20.78 20.15
17 002771 真视通 14.38 10.02 1.31 42,600.00 0.61 0.00 14.38 14.38 14.38 13.07
18 001358 兴欣新材 28.55 10.02 2.60 156,000.00 4.28 16.42 28.55 24.29 24.71 25.95
19 600156 华升股份 8.90 10.01 0.81 675,300.00 5.97 4.82 8.90 8.51 8.73 8.09
20 002242 九阳股份 31.21 10.01 2.84 1,808,200.00 51.29 20.02 31.21 25.53 25.53 28.37

07_任务2_东方财富网页

图7:浏览器实际打开的东方财富行情中心,表格由 JavaScript 渲染。

08_任务2_PyCharm运行

图8:PyCharm 中运行 2.py:20 条股票逐条打印、MySQL 回查 20 条,退出代码为 0。

09_任务2_MySQL股票表

图9:在 MySQL 客户端中查询 stock_quotes 的结果(序号、代码、名称、最新价、涨跌幅、涨跌额、成交量、振幅、最高、最低、今开、昨收)。

(3)外汇采集(中国银行)。 目标页是中国银行外汇牌价。页面是服务端渲染的静态表格,XPath 优先定位 priceTable,找不到时退化为按“货币名称”表头定位,避免依赖表格序号。每行读取货币名称、现汇买入价(TBP)、现钞买入价(CBP)、现汇卖出价(TSP)、现钞卖出价(CSP)和发布时间;Time 只保留时分秒,同时额外保存完整的 publishedAt,防止不同日期的同一时刻混淆。牌价单位是人民币元 / 100 外币,网页上没有的报价保存为 NULL。

本次共入库 45 条。下表选取常用币种展示,完整 45 条见 forex.csv、forex.jsonl 与 homework3.sql:

Currency TBP CBP TSP CSP Time
美元 667.96 667.96 670.77 670.77 01:02:09
欧元 731.92 731.92 737.28 737.28 01:02:09
英镑 874.02 874.02 880.51 880.51 01:02:09
日元 4.1718 4.1718 4.204 4.204 01:02:09
港币 85.13 85.13 85.47 85.47 01:02:09
阿联酋迪拉姆 180.87 180.87 183.41 183.41 01:02:09
澳大利亚元 444.74 444.74 448.28 448.28 01:02:09
加拿大元 465.85 465.85 469.51 469.51 01:02:09
新加坡元 516.08 516.08 519.96 519.96 01:02:09
泰国铢 19.63 19.63 19.79 19.79 01:02:09

10_任务3_中行外汇网页

图10:浏览器实际打开的中国银行外汇牌价页面。

11_任务3_PyCharm运行_1

图11:PyCharm 中运行 3.py,逐条打印牌价(前 33 条)。

12_任务3_PyCharm运行_2

图12:最后一页输出:MySQL 回查 45 条、外汇采集完成、退出代码为 0。

13_任务3_MySQL外汇表

图13:在 MySQL 客户端中查询 forex_quotes 的完整 45 条结果。

(4)完整代码:2.py

"""作业②:Scrapy + XPath + MySQL 采集东方财富 A 股行情。

先安装 requirements.txt,并安装 Microsoft Edge 与 MySQL 8。
在 PyCharm 运行配置中设置 MYSQL_HOST、MYSQL_PORT、MYSQL_USER、
MYSQL_PASSWORD(必填)、MYSQL_DATABASE;默认数据库名 homework3。
如 Selenium Manager 无法自动获取驱动,可设置 EDGE_DRIVER 为驱动路径。
直接运行本文件,仅采集行情列表第一页的前 20 条;--limit 可调为 1~20。
"""

import argparse
from datetime import datetime, timezone
from decimal import Decimal
import os
from pathlib import Path
import re
import uuid

import pymysql
import scrapy
from scrapy.crawler import CrawlerProcess
from scrapy.http import HtmlResponse
from selenium import webdriver
from selenium.webdriver.edge.options import Options
from selenium.webdriver.edge.service import Service
from selenium.webdriver.support.ui import WebDriverWait

URL = 'https://quote.eastmoney.com/center/gridlist.html#hs_a_board'
ROOT = Path(__file__).resolve().parent
FIELDS = ('bStockNo', 'bStockName', 'bLatestPrice', 'bChangePercent',
          'bChangeAmount', 'bVolumeHand', 'bTurnover', 'bAmplitude',
          'bHigh', 'bLow', 'bOpen', 'bPreviousClose', 'collectedAt')

class StockItem(scrapy.Item):
    """金额为元、涨幅和振幅为百分数、成交量为手。"""
    bStockNo = scrapy.Field()
    bStockName = scrapy.Field()
    bLatestPrice = scrapy.Field()
    bChangePercent = scrapy.Field()
    bChangeAmount = scrapy.Field()
    bVolumeHand = scrapy.Field()
    bTurnover = scrapy.Field()
    bAmplitude = scrapy.Field()
    bHigh = scrapy.Field()
    bLow = scrapy.Field()
    bOpen = scrapy.Field()
    bPreviousClose = scrapy.Field()
    collectedAt = scrapy.Field()

def numeric(text):
    """保留 Decimal 精度,将万/亿换算为基础单位,缺失值存为 NULL。"""
    text = text.strip().replace(',', '').replace('%', '')
    if text in ('', '-', '--', '—'):
        return None
    multiplier = Decimal(1)
    if text[-1:] in ('万', '亿'):
        multiplier = Decimal('10000' if text[-1] == '万' else '100000000')
        text = text[:-1]
    return str(Decimal(text) * multiplier)

class RenderMiddleware:
    """只为标记的行情请求加载真实 DOM,Scrapy 回调仍用 XPath 提取。"""
    def process_request(self, request, spider=None):
        if not request.meta.get('render'):
            return None
        options = Options()
        options.add_argument('--headless=new')
        options.add_argument('--disable-gpu')
        options.add_argument('--no-proxy-server')
        options.add_argument('--disable-dev-shm-usage')
        options.add_argument('--window-size=1600,1000')
        driver_path = request.meta['driver']
        service = Service(driver_path) if driver_path else Service()
        driver = webdriver.Edge(service=service, options=options)
        try:
            driver.set_page_load_timeout(45)
            driver.get(request.url)
            row_xpath = '//table[.//th[contains(.,"最新价")]]//tbody/tr[td]'
            WebDriverWait(driver, 45).until(
                lambda browser: len(browser.find_elements('xpath', row_xpath)) >= 1)
            # 页面可能自动弹出登录提示,关闭提示即可查看公开表格,无需登录。
            for close_button in driver.find_elements(
                    'css selector', 'img[src$="/fullscreengg/ic_close.png"]'):
                if close_button.is_displayed():
                    close_button.click()
            driver.save_screenshot(str(request.meta['snapshot_path'].with_suffix('.png')))
            body = driver.page_source
            request.meta['snapshot_path'].write_text(body, encoding='utf-8')
            return HtmlResponse(driver.current_url, body=body.encode('utf-8'),
                                encoding='utf-8', request=request)
        finally:
            driver.quit()

class StockPipeline:
    """参数化写入 MySQL;整批提交成功后才记录入库成功状态。"""
    @classmethod
    def from_crawler(cls, crawler):
        instance = cls()
        instance.crawler = crawler
        return instance

    def open_spider(self, spider=None):
        database = os.getenv('MYSQL_DATABASE', 'homework3')
        if not re.fullmatch(r'[A-Za-z0-9_]+', database):
            raise ValueError('MYSQL_DATABASE 只能包含英文字母、数字和下划线')
        password = os.environ.get('MYSQL_PASSWORD')
        if password is None:
            raise ValueError('请在运行配置中设置 MYSQL_PASSWORD,不把密码写进仓库')
        self.connection = pymysql.connect(
            host=os.getenv('MYSQL_HOST', '127.0.0.1'),
            port=int(os.getenv('MYSQL_PORT', '3306')),
            user=os.getenv('MYSQL_USER', 'root'), password=password,
            charset='utf8mb4', connect_timeout=10, autocommit=False)
        with self.connection.cursor() as cursor:
            cursor.execute(f'CREATE DATABASE IF NOT EXISTS `{database}` CHARACTER SET utf8mb4')
            self.connection.select_db(database)
            cursor.execute('''CREATE TABLE IF NOT EXISTS stock_quotes (
                id BIGINT PRIMARY KEY AUTO_INCREMENT,
                runId CHAR(32) NOT NULL,
                bStockNo CHAR(6) NOT NULL,
                bStockName VARCHAR(64) NOT NULL,
                bLatestPrice DECIMAL(18,4), bChangePercent DECIMAL(18,4),
                bChangeAmount DECIMAL(18,4), bVolumeHand DECIMAL(24,4),
                bTurnover DECIMAL(24,4), bAmplitude DECIMAL(18,4),
                bHigh DECIMAL(18,4), bLow DECIMAL(18,4),
                bOpen DECIMAL(18,4), bPreviousClose DECIMAL(18,4),
                collectedAt VARCHAR(40) NOT NULL,
                UNIQUE KEY uq_stock_run (runId, bStockNo)
            ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4''')
        self.count = 0
        self.failed = False

    def process_item(self, item, spider=None):
        columns = ('runId',) + FIELDS
        values = (self.crawler.settings['RUN_ID'],) + tuple(item[field] for field in FIELDS)
        sql = ('INSERT INTO stock_quotes (' + ','.join(columns) + ') VALUES ('
               + ','.join(['%s'] * len(columns)) + ')')
        try:
            with self.connection.cursor() as cursor:
                cursor.execute(sql, values)
        except Exception:
            self.failed = True
            raise
        self.count += 1
        print(f'[{self.count:02d}] {item["bStockNo"]} {item["bStockName"]} '
              f'最新={item["bLatestPrice"]} 涨幅={item["bChangePercent"]}%', flush=True)
        return item

    def close_spider(self, spider=None):
        try:
            stats = self.crawler.stats.get_stats()
            if (self.failed or stats.get('log_count/ERROR', 0)
                    or stats.get('item_error_count', 0)):
                self.connection.rollback()
                raise RuntimeError('本批次发生错误,已回滚数据库写入')
            self.connection.commit()
            with self.connection.cursor() as cursor:
                cursor.execute('SELECT COUNT(*) FROM stock_quotes WHERE runId=%s',
                               (self.crawler.settings['RUN_ID'],))
                count = cursor.fetchone()[0]
            self.crawler.stats.set_value('mysql/verified_count', count)
            print(f'MySQL stock_quotes 本批次查询验证:{count} 条', flush=True)
        finally:
            self.connection.close()

class StockSpider(scrapy.Spider):
    name = 'eastmoney_stocks'

    def __init__(self, limit=20, driver='', output='', **kwargs):
        super().__init__(**kwargs)
        self.limit, self.driver, self.output = int(limit), driver, Path(output)

    async def start(self):
        yield scrapy.Request(URL, callback=self.parse, meta={
            'render': True, 'driver': self.driver,
            'snapshot_path': self.output / 'source.html'})

    def parse(self, response):
        rows = response.xpath('//table[.//th[contains(.,"最新价")]]//tbody/tr[td]')
        if not rows:
            raise ValueError('未找到真实行情表格,检查动态加载或网站结构')
        collected_at = datetime.now(timezone.utc).isoformat()
        for row in rows[:self.limit]:
            cells = [cell.xpath('normalize-space(.)').get() for cell in row.xpath('./td')]
            if len(cells) < 14 or not re.fullmatch(r'\d{6}', cells[1]):
                raise ValueError(f'行情行结构改变:{cells}')
            values = [cells[1], cells[2]]
            # 跳过“相关链接”列,并保留成交额,因此振幅取第 10 列。
            values += [numeric(cells[i]) for i in range(4, 14)]
            values.append(collected_at)
            yield StockItem(dict(zip(FIELDS, values)))

def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument('--limit', type=int, choices=range(1, 21), default=20)
    parser.add_argument('--driver', default=os.getenv('EDGE_DRIVER', ''))
    args = parser.parse_args()
    run_id = uuid.uuid4().hex
    output = ROOT / 'data' / ('stocks_' + run_id[:12])
    output.mkdir(parents=True)
    process = CrawlerProcess(settings={
        'RUN_ID': run_id, 'ROBOTSTXT_OBEY': True,
        'USER_AGENT': 'Mozilla/5.0 (student stock assignment)',
        'HTTPPROXY_ENABLED': False, 'DOWNLOAD_TIMEOUT': 45,
        'RETRY_TIMES': 1, 'CONCURRENT_REQUESTS': 1, 'DOWNLOAD_DELAY': 0.5,
        'LOG_LEVEL': 'WARNING', 'FEED_EXPORT_ENCODING': 'utf-8',
        'FEED_EXPORT_FIELDS': list(FIELDS),
        'ITEM_PIPELINES': {StockPipeline: 300},
        'DOWNLOADER_MIDDLEWARES': {RenderMiddleware: 543},
        'FEEDS': {str(output / 'stocks.csv'): {'format': 'csv'},
                  str(output / 'stocks.jsonl'): {'format': 'jsonlines'}},
    })
    crawler = process.create_crawler(StockSpider)
    process.crawl(crawler, limit=args.limit, driver=args.driver, output=str(output))
    process.start()
    stats = crawler.stats.get_stats()
    import json
    (output / 'stats.json').write_text(
        json.dumps(stats, ensure_ascii=False, indent=2, default=str), encoding='utf-8')
    count = stats.get('item_scraped_count', 0)
    if (count != args.limit or count != stats.get('mysql/verified_count')
            or stats.get('log_count/ERROR', 0) or stats.get('item_error_count', 0)):
        raise RuntimeError('采集或 MySQL 入库失败,请检查上方错误和数据库配置')
    print(f'股票采集完成:{count} 条;CSV / JSONL / 网页快照:{output}', flush=True)

if __name__ == '__main__':
    main()

(5)完整代码:3.py

"""作业③:Scrapy + XPath + MySQL 采集中国银行外汇牌价。

在 PyCharm 设置 MYSQL_HOST、MYSQL_PORT、MYSQL_USER、MYSQL_PASSWORD
(必填)与 MYSQL_DATABASE 后直接运行本文件。只请求当前第一页。
TBP/CBP/TSP/CSP 依次对应现汇买入、现钞买入、现汇卖出、现钞卖出价。
牌价单位为人民币元/100 外币;网页缺失报价存为 NULL,不能用 0 代替。
"""

from datetime import datetime, timezone
from decimal import Decimal
import os
from pathlib import Path
import re
import uuid

import pymysql
import scrapy
from scrapy.crawler import CrawlerProcess

ROOT = Path(__file__).resolve().parent
URL = 'https://www.boc.cn/sourcedb/whpj/'
FIELDS = ('Currency', 'TBP', 'CBP', 'TSP', 'CSP', 'Time',
          'publishedAt', 'collectedAt')

class ForexItem(scrapy.Item):
    """保留题目要求的六列,并额外保留完整发布日期与采集时间。"""
    Currency = scrapy.Field()
    TBP = scrapy.Field()
    CBP = scrapy.Field()
    TSP = scrapy.Field()
    CSP = scrapy.Field()
    Time = scrapy.Field()
    publishedAt = scrapy.Field()
    collectedAt = scrapy.Field()

def parse_price(text):
    """用十进制定点数校验价格,空白和破折号保留为空值。"""
    text = text.strip().replace(',', '')
    if text in ('', '-', '--', '—'):
        return None
    return str(Decimal(text))

class ForexPipeline:
    """使用参数化 SQL,数据库连接参数通过环境变量提供。"""
    @classmethod
    def from_crawler(cls, crawler):
        instance = cls()
        instance.crawler = crawler
        return instance

    def open_spider(self, spider=None):
        database = os.getenv('MYSQL_DATABASE', 'homework3')
        if not re.fullmatch(r'[A-Za-z0-9_]+', database):
            raise ValueError('MYSQL_DATABASE 只能包含英文字母、数字和下划线')
        password = os.environ.get('MYSQL_PASSWORD')
        if password is None:
            raise ValueError('请设置 MYSQL_PASSWORD,不把密码写进源码或仓库')
        self.connection = pymysql.connect(
            host=os.getenv('MYSQL_HOST', '127.0.0.1'),
            port=int(os.getenv('MYSQL_PORT', '3306')),
            user=os.getenv('MYSQL_USER', 'root'), password=password,
            charset='utf8mb4', connect_timeout=10, autocommit=False)
        with self.connection.cursor() as cursor:
            cursor.execute(f'CREATE DATABASE IF NOT EXISTS `{database}` CHARACTER SET utf8mb4')
            self.connection.select_db(database)
            cursor.execute('''CREATE TABLE IF NOT EXISTS forex_quotes (
                id BIGINT PRIMARY KEY AUTO_INCREMENT,
                runId CHAR(32) NOT NULL,
                Currency VARCHAR(64) NOT NULL,
                TBP DECIMAL(18,4), CBP DECIMAL(18,4),
                TSP DECIMAL(18,4), CSP DECIMAL(18,4),
                Time TIME NOT NULL,
                publishedAt DATETIME NOT NULL,
                collectedAt VARCHAR(40) NOT NULL,
                UNIQUE KEY uq_currency_run (runId, Currency, publishedAt)
            ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4''')
        self.count = 0
        self.failed = False

    def process_item(self, item, spider=None):
        columns = ('runId',) + FIELDS
        values = (self.crawler.settings['RUN_ID'],) + tuple(item[field] for field in FIELDS)
        sql = ('INSERT INTO forex_quotes (`' + '`,`'.join(columns) + '`) VALUES ('
               + ','.join(['%s'] * len(columns)) + ')')
        try:
            with self.connection.cursor() as cursor:
                cursor.execute(sql, values)
        except Exception:
            self.failed = True
            raise
        self.count += 1
        print(f'[{self.count:02d}] {item["Currency"]} '
              f'TBP={item["TBP"]} CBP={item["CBP"]} '
              f'TSP={item["TSP"]} CSP={item["CSP"]} {item["Time"]}', flush=True)
        return item

    def close_spider(self, spider=None):
        try:
            stats = self.crawler.stats.get_stats()
            if (self.failed or stats.get('log_count/ERROR', 0)
                    or stats.get('item_error_count', 0)):
                self.connection.rollback()
                raise RuntimeError('本批次发生错误,已回滚数据库写入')
            self.connection.commit()
            with self.connection.cursor() as cursor:
                cursor.execute('SELECT COUNT(*) FROM forex_quotes WHERE runId=%s',
                               (self.crawler.settings['RUN_ID'],))
                count = cursor.fetchone()[0]
            self.crawler.stats.set_value('mysql/verified_count', count)
            print(f'MySQL forex_quotes 本批次查询验证:{count} 条', flush=True)
        finally:
            self.connection.close()

class ForexSpider(scrapy.Spider):
    name = 'boc_forex'

    def __init__(self, output='', **kwargs):
        super().__init__(**kwargs)
        self.output = Path(output)

    async def start(self):
        yield scrapy.Request(URL, callback=self.parse)

    def parse(self, response):
        # 使用真实响应的 HTML 表格,保存原始字节用于复核。
        (self.output / 'source.html').write_bytes(response.body)
        table = response.xpath('//table[@id="priceTable"]')
        if not table:
            # 兼容旧版网页:按货币表头定位,不依赖表格的固定序号。
            table = response.xpath('//table[.//th[contains(.,"货币名称")]]')
        rows = table.xpath('.//tr[td]')
        if not rows:
            raise ValueError('未找到中行外汇牌价表,不把空结果视为成功')
        seen = set()
        for row in rows:
            cells = [cell.xpath('normalize-space(.)').get() for cell in row.xpath('./td')]
            if len(cells) < 7:
                raise ValueError(f'外汇表格列数变化:{cells}')
            published = cells[6].replace('/', '-')
            # 兼容日期、时间分列与日期列已含完整时间两种结构。
            if not re.search(r'\d{2}:\d{2}:\d{2}', published) and len(cells) >= 8:
                published += ' ' + cells[7]
            published_at = datetime.strptime(published, '%Y-%m-%d %H:%M:%S')
            identity = (cells[0], published_at)
            if identity in seen:
                continue
            seen.add(identity)
            yield ForexItem(
                Currency=cells[0], TBP=parse_price(cells[1]),
                CBP=parse_price(cells[2]), TSP=parse_price(cells[3]),
                CSP=parse_price(cells[4]),
                Time=published_at.strftime('%H:%M:%S'),
                publishedAt=published_at.strftime('%Y-%m-%d %H:%M:%S'),
                collectedAt=datetime.now(timezone.utc).isoformat())

def main():
    run_id = uuid.uuid4().hex
    output = ROOT / 'data' / ('forex_' + run_id[:12])
    output.mkdir(parents=True)
    process = CrawlerProcess(settings={
        'RUN_ID': run_id, 'ROBOTSTXT_OBEY': True,
        'USER_AGENT': 'Mozilla/5.0 (student forex assignment)',
        'HTTPPROXY_ENABLED': False, 'DOWNLOAD_TIMEOUT': 30,
        'RETRY_TIMES': 1, 'CONCURRENT_REQUESTS': 1, 'DOWNLOAD_DELAY': 0.5,
        'LOG_LEVEL': 'WARNING', 'FEED_EXPORT_ENCODING': 'utf-8',
        'FEED_EXPORT_FIELDS': list(FIELDS),
        'ITEM_PIPELINES': {ForexPipeline: 300},
        'FEEDS': {str(output / 'forex.csv'): {'format': 'csv'},
                  str(output / 'forex.jsonl'): {'format': 'jsonlines'}},
    })
    crawler = process.create_crawler(ForexSpider)
    process.crawl(crawler, output=str(output))
    process.start()
    stats = crawler.stats.get_stats()
    import json
    (output / 'stats.json').write_text(
        json.dumps(stats, ensure_ascii=False, indent=2, default=str), encoding='utf-8')
    count = stats.get('item_scraped_count', 0)
    if (count == 0 or count != stats.get('mysql/verified_count')
            or stats.get('log_count/ERROR', 0) or stats.get('item_error_count', 0)):
        raise RuntimeError('采集或 MySQL 入库失败,请检查上方错误和数据库配置')
    print(f'外汇采集完成:{count} 条;CSV / JSONL / 网页快照:{output}', flush=True)

if __name__ == '__main__':
    main()

(6)运行与核验。 交付数据对应的依赖版本记录在 requirements-lock.txt(Scrapy 2.13.4、Selenium 4.38.0、PyMySQL 1.1.2,MySQL 8);本机重新运行验证时使用 Python 3.14.5、Scrapy 2.19.0、Selenium 4.27.1 和 MySQL 8.0.28(3306 端口),同样能完成采集与入库。数据库连接参数全部通过环境变量传入:

$env:MYSQL_HOST = "127.0.0.1"
$env:MYSQL_PORT = "3306"
$env:MYSQL_USER = "root"
$env:MYSQL_PASSWORD = "本机数据库密码"
$env:MYSQL_DATABASE = "homework3"
python 2.py
python 3.py
python verify.py

verify.py 不访问外网,直接对交付包做交叉验证:万/亿换算、负数、空值和非法值,图片 SHA-256 与解码,两个模式 URL 顺序一致、总量不超过 102,重新解析保存的 HTML 与 JSONL 一致,Scrapy 统计中的入库条数与文件条数一致;加上 --mysql 后还会逐条逐字段比对数据库。

2. 作业心得

股票实验让我第一次认真区分“浏览器里看得到”和“HTTP 响应里有”。东方财富的行情表是脚本渲染出来的,直接用 requests 只能拿到空壳,所以必须先用 Selenium 等表格出现,再把 DOM 交给 Scrapy 解析。渲染只解决“页面有没有数据”,字段提取仍然由 XPath 完成,Item 和 Pipeline 的分工没有被绕过。按列下标取值虽然直观,但很依赖网页结构,因此代码在列数不足、代码不是六位数字时直接报错,宁可失败也不把错位的数据写进库。

外汇实验的难点在“空值”和“时间”。没有现汇报价时如果写 0,就把“没有数据”改成了“价格为零”,含义完全变了,所以统一保存 NULL;只保留时分秒又会丢掉日期,因此另外保存完整的 publishedAt。这两点看起来是细节,但直接决定数据能不能用。

最后是验证的价值。爬虫打印“完成”只说明流程走完,不能说明数据对。把原始 HTML、CSV/JSONL、MySQL 导出和查询结果都留下来,再用 verify.py 做逐字段比对,才能确认入库没有错列、没有丢精度。网站结构随时可能变化,以后再运行时仍要重点看失败日志和字段检查,而不是只看最后一行“完成”。

posted @ 2026-11-20 00:58  NovaVespera  阅读(3)  评论(0)    收藏  举报
愿你抬头有星光,低头有代码 ✨