数据采集作业三
一、作业实现:代码与运行结果
实验环境:Windows 11 · Python 3.13 · Scrapy 2.20 · requests / BeautifulSoup4 · MySQL(本机使用完全兼容的 MariaDB 11.4)· pymysql
完整代码已上传 Gitee:
作业1/1.py、作业2/(Scrapy 工程)、作业3/(Scrapy 工程),目录结构与要求一致。
https://gitee.com/zyj102402147/spider/tree/main/数据采集博客园作业/数据采集作业三
(一)作业1:中国气象网全站图片爬取(单线程 / 多线程)
https://gitee.com/zyj102402147/spider/tree/main/数据采集博客园作业/数据采集作业三/作业1
1. 设计思路
- 入口为中国气象网首页
http://www.weather.com.cn/,采用 广度优先(BFS) 遍历站内页面,只跟随同域名链接,避免爬到站外; - 严格落实两道爬取上限:总页数 = 学号尾数两位 47 页,总图片数 = 学号后三位 147 张;
- 图片地址除了常规
<img src>,还兼容懒加载属性data-src/data-original和行内样式background-image:url(...),并按 URL 去重; - 下载分两轮:单线程(for 循环顺序下载)与 多线程(
ThreadPoolExecutor8 线程并发),两轮开始前都清空images目录,保证耗时对比公平; - 控制台输出每张图片的来源 URL、保存文件名与体积;所有请求带 0.2s 间隔,做一个有礼貌的爬虫。
2. 作业代码(作业1/1.py)
# -*- coding: utf-8 -*-
"""
作业1:爬取指定网站(中国气象网 http://www.weather.com.cn )中的全部图片。
实现要点
1. 采用广度优先(BFS)遍历站内页面,只跟随同域名链接,避免爬到站外;
2. 必须限制爬取规模:总页数 = 学号尾数两位(147 的尾数两位为 47)→ 47 页;
总图片数 = 学号后三位(147)→ 147 张;
3. 图片分别用「单线程」和「多线程」两种方式下载到脚本同级的 images 子目录;
4. 控制台输出每张图片的来源 URL、保存文件名与体积,便于核对。
运行方式
python 1.py # 依次执行单线程、多线程两轮下载
python 1.py --mode serial # 只跑单线程
python 1.py --mode thread # 只跑多线程
"""
import argparse
import os
import re
import shutil
import threading
import time
from collections import deque
from concurrent.futures import ThreadPoolExecutor, as_completed
from urllib.parse import unquote, urljoin, urlparse
import requests
from bs4 import BeautifulSoup
# --------------------------------------------------------------------------- #
# 全局配置
# --------------------------------------------------------------------------- #
# 爬取入口:中国气象网首页
START_URL = "http://www.weather.com.cn/"
# 爬取规模限制:总页数取学号尾数两位(147 的尾数两位为 47),总图片数取学号后三位(147)
MAX_PAGES = 47
MAX_IMAGES = 147
# 图片保存目录:与本脚本同级,便于随作业文件夹一起提交
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
IMAGE_DIR = os.path.join(BASE_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"
),
"Accept": "text/html,application/xhtml+xml,image/webp,image/apng,*/*;q=0.8",
"Accept-Language": "zh-CN,zh;q=0.9",
}
# 页面请求超时时间(秒)与页面之间的访问间隔(秒),后者用于降低对方服务器压力
TIMEOUT = 10
PAGE_DELAY = 0.2
# 单张图片下载失败后的重试次数
DOWNLOAD_RETRY = 2
# 多线程下载的线程数
MAX_WORKERS = 8
# 认定为图片的后缀名
IMAGE_SUFFIXES = (".jpg", ".jpeg", ".png", ".gif", ".webp", ".bmp", ".svg", ".ico")
# 明显不是网页的后缀名,BFS 时直接跳过,避免浪费页数配额
SKIP_SUFFIXES = (
".pdf", ".zip", ".rar", ".7z", ".doc", ".docx", ".xls", ".xlsx",
".ppt", ".pptx", ".mp3", ".mp4", ".avi", ".exe", ".apk",
)
# 打印进度时使用的互斥锁,防止多线程同时写控制台导致输出错乱
PRINT_LOCK = threading.Lock()
# --------------------------------------------------------------------------- #
# 通用工具函数
# --------------------------------------------------------------------------- #
def build_session():
"""创建带默认请求头的 requests.Session 对象,复用 TCP 连接以提升速度。"""
session = requests.Session()
session.headers.update(HEADERS)
return session
def human_size(num_bytes):
"""把字节数转换成便于阅读的单位(B / KB / MB)。"""
if num_bytes < 1024:
return "{} B".format(num_bytes)
if num_bytes < 1024 * 1024:
return "{:.1f} KB".format(num_bytes / 1024)
return "{:.1f} MB".format(num_bytes / 1024 / 1024)
def normalize_url(page_url, href):
"""
把页面中的相对链接补全为绝对链接。
参数:
page_url: 当前页面的 URL
href: 页面中提取到的原始链接
返回:
规范化后的绝对 URL;若该链接不应被访问(锚点、脚本、空链接等)则返回 None
"""
if not href:
return None
href = href.strip()
# 过滤锚点、JavaScript 伪链接与空链接
if href.startswith(("#", "javascript:", "mailto:", "tel:", "data:")):
return None
absolute = urljoin(page_url, href)
# 去掉 URL 中的锚点部分,避免同一页面被重复计入页数
return absolute.split("#")[0]
def is_crawlable_page(url, host):
"""
判断一个 URL 是否值得当作「网页」去抓取。
参数:
url: 待判断的绝对 URL
host: 入口站点的主机名,用于限制只爬站内页面
返回:
True 表示可以抓取
"""
parsed = urlparse(url)
if parsed.scheme not in ("http", "https"):
return False
# 只抓取与入口同主机的页面,防止爬到站外去
if parsed.netloc and parsed.netloc != host:
return False
# 跳过图片、压缩包、文档等非 HTML 资源
if parsed.path.lower().endswith(SKIP_SUFFIXES):
return False
return True
def extract_image_urls(soup, page_url):
"""
从已解析的页面中提取所有图片地址。
除了常规的 <img src>,还兼容前端懒加载常用的 data-src / data-original 属性,
以及写在 style="background-image:url(...)" 中的背景图。
参数:
soup: BeautifulSoup 解析对象
page_url: 当前页面 URL,用于补全相对路径
返回:
去重后的图片绝对 URL 列表
"""
found = []
# 1. 常规 <img> 标签及其懒加载属性
for img in soup.find_all("img"):
for attr in ("src", "data-src", "data-original", "data-lazy-src"):
value = img.get(attr)
if value:
found.append(urljoin(page_url, value.strip()))
# 2. 行内样式中的背景图片:background-image: url("xxx.jpg")
for tag in soup.find_all(style=True):
for match in re.findall(r"url\((['\"]?)(.*?)\1\)", tag["style"]):
found.append(urljoin(page_url, match[1].strip()))
# 3. 只保留图片后缀的链接,并按出现顺序去重
image_urls = []
seen = set()
for url in found:
url = url.split("?")[0] if url.lower().endswith(IMAGE_SUFFIXES) else url
path = urlparse(url).path.lower()
if not path.endswith(IMAGE_SUFFIXES):
continue
if url in seen:
continue
seen.add(url)
image_urls.append(url)
return image_urls
def make_filename(image_url, index):
"""
根据图片 URL 生成保存用的文件名,形如 001_logo2.png。
参数:
image_url: 图片地址
index: 图片序号,从 1 开始,保证同名文件不会互相覆盖
返回:
安全的文件名
"""
raw_name = unquote(os.path.basename(urlparse(image_url).path)) or "image"
# 去掉文件名中的非法字符(Windows 不允许 \ / : * ? " < > |)
raw_name = re.sub(r'[\\/:*?"<>|\s]+', "_", raw_name)
# 限制文件名长度,避免路径过长导致保存失败
raw_name = raw_name[:40]
return "{:03d}_{}".format(index, raw_name)
# --------------------------------------------------------------------------- #
# 第一阶段:采集页面 URL 与图片 URL(单线程,只爬一次,供两种下载方式复用)
# --------------------------------------------------------------------------- #
def collect_pages_and_images(start_url, max_pages, max_images):
"""
广度优先遍历站内页面,收集页面列表与图片列表。
参数:
start_url: 入口地址
max_pages: 最多访问的页面数量
max_images: 最多收集的图片数量
返回:
(pages, image_urls) 二元组
"""
host = urlparse(start_url).netloc
session = build_session()
queue = deque([start_url]) # 待访问队列
visited = set() # 已访问页面,防止重复与死循环
pages = [] # 已成功访问的页面 URL
image_urls = [] # 收集到的图片 URL
image_seen = set() # 图片 URL 去重集合
while queue and len(pages) < max_pages and len(image_urls) < max_images:
page_url = queue.popleft()
if page_url in visited or not is_crawlable_page(page_url, host):
continue
visited.add(page_url)
try:
response = session.get(page_url, timeout=TIMEOUT)
# 只解析 HTML 页面,图片等资源直接跳过
if "html" not in response.headers.get("Content-Type", ""):
continue
response.encoding = response.apparent_encoding
soup = BeautifulSoup(response.text, "html.parser")
except requests.RequestException as error:
print(" [!] 页面请求失败: {} ({})".format(page_url, error))
continue
pages.append(page_url)
# 提取本页图片,按上限截断
new_images = extract_image_urls(soup, page_url)
for url in new_images:
if len(image_urls) >= max_images:
break
if url in image_seen:
continue
image_seen.add(url)
image_urls.append(url)
print("[页面 {:02d}/{}] {} 本页图片 {} 张,累计 {} 张".format(
len(pages), max_pages, page_url, len(new_images), len(image_urls)))
# 把本页中新的站内链接加入队列
for link in soup.find_all("a", href=True):
next_url = normalize_url(page_url, link["href"])
if next_url and next_url not in visited and is_crawlable_page(next_url, host):
queue.append(next_url)
# 控制访问频率,做个有礼貌的爬虫
time.sleep(PAGE_DELAY)
session.close()
return pages, image_urls
# --------------------------------------------------------------------------- #
# 第二阶段:图片下载(单线程 / 多线程两种实现)
# --------------------------------------------------------------------------- #
def download_image(session, image_url, index, save_dir):
"""
下载单张图片并保存到本地。
参数:
session: requests.Session 对象
image_url: 图片地址
index: 图片序号,用于生成文件名
save_dir: 保存目录
返回:
(是否成功, 文件名, 字节数, 错误信息)
"""
filename = make_filename(image_url, index)
file_path = os.path.join(save_dir, filename)
for attempt in range(1, DOWNLOAD_RETRY + 2):
try:
response = session.get(image_url, timeout=TIMEOUT, stream=True)
response.raise_for_status()
content = response.content
if not content:
raise ValueError("响应内容为空")
with open(file_path, "wb") as file:
file.write(content)
return True, filename, len(content), ""
except (requests.RequestException, ValueError, OSError) as error:
# 最后一次重试仍失败才返回错误
if attempt > DOWNLOAD_RETRY:
return False, filename, 0, str(error)
time.sleep(0.5)
return False, filename, 0, "未知错误"
def clear_image_dir(save_dir):
"""清空图片目录,保证两轮下载从同一状态开始,耗时对比才有意义。"""
if os.path.isdir(save_dir):
shutil.rmtree(save_dir)
os.makedirs(save_dir, exist_ok=True)
def download_serial(image_urls, save_dir):
"""
单线程下载:按顺序逐张下载。
参数:
image_urls: 图片 URL 列表
save_dir: 保存目录
返回:
统计字典(成功数、失败数、总字节、耗时)
"""
session = build_session()
total_bytes = 0
success = 0
failure = 0
start_time = time.time()
for index, url in enumerate(image_urls, start=1):
ok, filename, size, error = download_image(session, url, index, save_dir)
if ok:
success += 1
total_bytes += size
print("[{:3d}/{}] {} {} {}".format(
index, len(image_urls), filename, human_size(size), url))
else:
failure += 1
print("[{:3d}/{}] 下载失败 {} ({})".format(index, len(image_urls), url, error))
session.close()
elapsed = time.time() - start_time
return {"success": success, "failure": failure,
"bytes": total_bytes, "elapsed": elapsed}
def download_thread(image_urls, save_dir, max_workers=MAX_WORKERS):
"""
多线程下载:用线程池并发下载,显著缩短总耗时。
参数:
image_urls: 图片 URL 列表
save_dir: 保存目录
max_workers: 线程池大小
返回:
统计字典(成功数、失败数、总字节、耗时)
"""
total_bytes = 0
success = 0
failure = 0
finished = 0
start_time = time.time()
# 每个线程使用独立的 Session,避免共享连接池带来的线程安全问题
local = threading.local()
def worker(index, url):
"""线程池任务函数:下载一张图片并在返回后统一打印。"""
if not hasattr(local, "session"):
local.session = build_session()
return index, url, download_image(local.session, url, index, save_dir)
with ThreadPoolExecutor(max_workers=max_workers) as executor:
futures = [executor.submit(worker, index, url)
for index, url in enumerate(image_urls, start=1)]
for future in as_completed(futures):
index, url, (ok, filename, size, error) = future.result()
finished += 1
if ok:
success += 1
total_bytes += size
message = "[{:3d}/{}] {} {} {}".format(
finished, len(image_urls), filename, human_size(size), url)
else:
failure += 1
message = "[{:3d}/{}] 下载失败 {} ({})".format(
finished, len(image_urls), url, error)
# 多线程并发打印时加锁,避免多行输出混在一起
with PRINT_LOCK:
print(message)
elapsed = time.time() - start_time
return {"success": success, "failure": failure,
"bytes": total_bytes, "elapsed": elapsed}
# --------------------------------------------------------------------------- #
# 主流程
# --------------------------------------------------------------------------- #
def run(mode, start_url):
"""
执行一次完整流程:采集链接 → 单线程下载 → 多线程下载 → 打印对比结果。
参数:
mode: "both" 两种方式都跑;"serial" 只跑单线程;"thread" 只跑多线程
start_url: 本次爬取的入口地址
"""
print("=" * 78)
print("目标站点:{}".format(start_url))
print("爬取上限:最多 {} 个页面 / 最多 {} 张图片".format(MAX_PAGES, MAX_IMAGES))
print("=" * 78)
pages, image_urls = collect_pages_and_images(start_url, MAX_PAGES, MAX_IMAGES)
print("-" * 78)
print("共访问页面 {} 个,提取到去重后的图片 URL {} 条".format(len(pages), len(image_urls)))
print("-" * 78)
results = {}
if mode in ("both", "serial"):
clear_image_dir(IMAGE_DIR)
print("\n>>> 单线程下载开始(顺序逐张下载)")
results["serial"] = download_serial(image_urls, IMAGE_DIR)
if mode in ("both", "thread"):
clear_image_dir(IMAGE_DIR)
print("\n>>> 多线程下载开始(线程池 {} 个线程并发下载)".format(MAX_WORKERS))
results["thread"] = download_thread(image_urls, IMAGE_DIR)
# 汇总对比,方便在实验心得中分析两种方式的差异
print("\n" + "=" * 78)
print("下载结果汇总")
print("-" * 78)
for name, label in (("serial", "单线程"), ("thread", "多线程")):
if name in results:
stat = results[name]
print("{:<6} 成功 {:>3} 张 失败 {:>2} 张 总计 {:>9} 耗时 {:>6.2f} 秒".format(
label, stat["success"], stat["failure"],
human_size(stat["bytes"]), stat["elapsed"]))
if "serial" in results and "thread" in results:
speedup = results["serial"]["elapsed"] / max(results["thread"]["elapsed"], 0.01)
print("多线程相对单线程提速约 {:.2f} 倍".format(speedup))
print("图片保存目录:{}".format(IMAGE_DIR))
print("=" * 78)
def main():
"""解析命令行参数并启动爬虫。"""
global MAX_PAGES, MAX_IMAGES
parser = argparse.ArgumentParser(description="中国气象网图片爬虫(单线程 / 多线程)")
parser.add_argument("--mode", choices=("both", "serial", "thread"), default="both",
help="下载方式:both=两种都跑(默认),serial=单线程,thread=多线程")
parser.add_argument("--pages", type=int, default=MAX_PAGES, help="最多爬取的页面数")
parser.add_argument("--images", type=int, default=MAX_IMAGES, help="最多下载的图片数")
parser.add_argument("--url", default=START_URL, help="爬取入口地址,默认为中国气象网首页")
args = parser.parse_args()
# 允许通过命令行临时调整上限,默认值仍是学号对应的 47 页 / 147 张
MAX_PAGES, MAX_IMAGES = args.pages, args.images
run(args.mode, args.url)
if __name__ == "__main__":
main()
3. 运行结果
页面采集阶段(47 页上限生效,城市页共用同一批图片资源,去重后得到 79 个不同图片 URL):


单线程 / 多线程下载对比(同一批 79 个 URL,各下载一轮):

- 单线程:成功 76 张、失败 3 张(2 张站点已下线的卫星/雷达图返回 404,1 个已停用的第三方统计域名解析失败),耗时 10.11 秒;
- 多线程(8 线程):同样 76 张成功,耗时 2.74 秒,提速约 3.69 倍;
- 图片全部保存在
作业1/images/子目录:

4.作业1心得:并发收益与「有礼貌」的爬虫
这次最直观的体会是多线程对 IO 密集型任务的收益:同一批 79 个图片 URL(成功下载 76 张),单线程 10 秒,8 线程只用了 2.7 秒。图片下载的绝大部分时间都花在等待网络响应上,CPU 几乎空闲,所以线程池能把这段等待重叠起来;但提速 3.7 倍而不是 8 倍,是因为带宽和对方服务器成了新瓶颈。另外我在设计时把「采集页面」和「下载图片」拆成两个阶段,页面只爬一次、两种下载方式复用同一份 URL 清单,这样对比才公平;两轮下载前都清空 images 目录也是同样的道理。最后是限制措施:47 页 / 147 张的上限、0.2 秒的请求间隔、失败重试,都是为了让爬虫在完成任务的同时不给对方服务器添麻烦。实验中 3 张图片下载失败,排查后发现 2 张是站点已下线的卫星云图/雷达图(返回 404),1 个是早已停用的第三方访问统计域名(DNS 都解析不到)——这也提醒我,网页上的 <img> 不都是真正的内容。
(二)作业2:东方财富股票行情(Scrapy + Item/Pipeline + MySQL)
https://gitee.com/zyj102402147/spider/tree/main/数据采集博客园作业/数据采集作业三/作业2
1. 思路与数据源选择
东方财富的行情列表页由 JavaScript 动态渲染,Scrapy 直接请求只能拿到空表格骨架,因此抓取页面背后的行情数据接口,接口字段与作业要求的表头一一对应:
| 接口字段 | f12 | f14 | f2 | f3 | f4 | f5 | f7 | f15 | f16 | f17 | f18 |
|---|---|---|---|---|---|---|---|---|---|---|---|
| 作业表头 | 股票代码 | 股票名称 | 最新报价 | 涨跌幅 | 涨跌额 | 成交量 | 振幅 | 最高 | 最低 | 今开 | 昨收 |
该接口对短时间高频请求有频控,为保证任何网络环境下都能跑通,爬虫做了双数据源:东方财富接口无数据时,自动切换到新浪财经「行情中心」接口(字段一致,振幅由 最高/最低/昨收 计算),运行日志中会明确提示切换原因。
Item、Pipeline 的序列化输出体现在两处:StockJsonPipeline 把每条 Item 序列化成 JSON 行写入 stock_quotes.json;StockMySQLPipeline 用 pymysql 写入 MySQL 表 stock_quote(自动建库建表,按股票代码唯一键去重更新)。本次运行抓取涨幅榜前 100 只股票。
2. 工程结构与代码
作业2/
├── 2.py # 启动入口:python 2.py
├── scrapy.cfg
├── db.sql # 建库建表脚本(Pipeline 中也会自动执行)
└── stock_spider/
├── items.py # Item:定义 12 个字段
├── pipelines.py # JSON 序列化 + MySQL 存储
├── settings.py # 并发、延迟、请求头、Pipeline 顺序
└── spiders/stock.py # 爬虫:东方财富接口 + 新浪兜底
Item 定义(items.py):
# -*- coding: utf-8 -*-
"""
Item 定义:声明东方财富股票行情需要采集的字段。
字段说明(对应作业要求的表头,采用 b 前缀 + 小驼峰命名)
bRank 序号(在涨幅榜中的排名,入库后由 MySQL 的 id 字段再生成一次自增序号)
bStockNo 股票代码
bStockName 股票名称
bLatestPrice 最新报价
bChangePercent 涨跌幅(%)
bChangeAmount 涨跌额
bVolume 成交量(手)
bAmplitude 振幅(%)
bHigh 最高价
bLow 最低价
bOpen 今开
bPrevClose 昨收
bSpiderTime 抓取时间
"""
import scrapy
class StockItem(scrapy.Item):
"""股票行情 Item。"""
bRank = scrapy.Field() # 序号
bStockNo = scrapy.Field() # 股票代码
bStockName = scrapy.Field() # 股票名称
bLatestPrice = scrapy.Field() # 最新报价
bChangePercent = scrapy.Field() # 涨跌幅
bChangeAmount = scrapy.Field() # 涨跌额
bVolume = scrapy.Field() # 成交量
bAmplitude = scrapy.Field() # 振幅
bHigh = scrapy.Field() # 最高
bLow = scrapy.Field() # 最低
bOpen = scrapy.Field() # 今开
bPrevClose = scrapy.Field() # 昨收
bSpiderTime = scrapy.Field() # 抓取时间
Pipeline(pipelines.py):
# -*- coding: utf-8 -*-
"""
Pipeline 定义:
1. StockJsonPipeline —— 把 Item 序列化成 JSON 行,写入 stock_quotes.json;
2. StockMySQLPipeline —— 把 Item 写入 MySQL(自动建库、建表,按股票代码去重更新)。
"""
import json
import logging
import os
from datetime import datetime
import pymysql
# MySQL 连接配置:默认本机 root/123456,可通过环境变量覆盖,便于换机器运行
DB_CONFIG = {
"host": os.getenv("MYSQL_HOST", "127.0.0.1"),
"port": int(os.getenv("MYSQL_PORT", "3306")),
"user": os.getenv("MYSQL_USER", "root"),
"password": os.getenv("MYSQL_PASSWORD", "123456"),
"charset": "utf8mb4",
"autocommit": False,
}
DATABASE_NAME = os.getenv("MYSQL_DATABASE", "spider")
# 建表语句:字段与 Item 一一对应,bStockNo 建唯一索引,重复抓取时只更新不重复插入
CREATE_TABLE_SQL = """
CREATE TABLE IF NOT EXISTS stock_quote (
id INT UNSIGNED NOT NULL AUTO_INCREMENT COMMENT '序号',
bRank INT DEFAULT NULL COMMENT '涨幅榜排名',
bStockNo VARCHAR(10) NOT NULL COMMENT '股票代码',
bStockName VARCHAR(32) NOT NULL COMMENT '股票名称',
bLatestPrice DECIMAL(10, 2) DEFAULT NULL COMMENT '最新报价',
bChangePercent DECIMAL(10, 2) DEFAULT NULL COMMENT '涨跌幅(%)',
bChangeAmount DECIMAL(10, 2) DEFAULT NULL COMMENT '涨跌额',
bVolume BIGINT DEFAULT NULL COMMENT '成交量(手)',
bAmplitude DECIMAL(10, 2) DEFAULT NULL COMMENT '振幅(%)',
bHigh DECIMAL(10, 2) DEFAULT NULL COMMENT '最高',
bLow DECIMAL(10, 2) DEFAULT NULL COMMENT '最低',
bOpen DECIMAL(10, 2) DEFAULT NULL COMMENT '今开',
bPrevClose DECIMAL(10, 2) DEFAULT NULL COMMENT '昨收',
bSpiderTime DATETIME DEFAULT NULL COMMENT '抓取时间',
PRIMARY KEY (id),
UNIQUE KEY uniq_stock_no (bStockNo)
) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4 COMMENT = '东方财富股票行情';
"""
# 插入语句:唯一键冲突时更新行情字段,保证多次运行不产生重复记录
INSERT_SQL = """
INSERT INTO stock_quote
(bRank, bStockNo, bStockName, bLatestPrice, bChangePercent, bChangeAmount,
bVolume, bAmplitude, bHigh, bLow, bOpen, bPrevClose, bSpiderTime)
VALUES (%(bRank)s, %(bStockNo)s, %(bStockName)s, %(bLatestPrice)s, %(bChangePercent)s,
%(bChangeAmount)s, %(bVolume)s, %(bAmplitude)s, %(bHigh)s, %(bLow)s,
%(bOpen)s, %(bPrevClose)s, %(bSpiderTime)s)
ON DUPLICATE KEY UPDATE
bRank = VALUES(bRank), bStockName = VALUES(bStockName),
bLatestPrice = VALUES(bLatestPrice), bChangePercent = VALUES(bChangePercent),
bChangeAmount = VALUES(bChangeAmount), bVolume = VALUES(bVolume),
bAmplitude = VALUES(bAmplitude), bHigh = VALUES(bHigh), bLow = VALUES(bLow),
bOpen = VALUES(bOpen), bPrevClose = VALUES(bPrevClose), bSpiderTime = VALUES(bSpiderTime)
"""
class StockJsonPipeline:
"""把每个 Item 序列化成一行 JSON,追加写入 stock_quotes.json。"""
def open_spider(self, spider=None):
"""爬虫启动时打开文件(utf-8 编码,保证中文股票名称可读)。"""
file_path = os.path.join(os.path.dirname(os.path.dirname(
os.path.abspath(__file__))), "stock_quotes.json")
self.file = open(file_path, "w", encoding="utf-8")
self.count = 0
def process_item(self, item, spider=None):
"""将 Item 转成字典后序列化为一行 JSON 并写入文件。"""
record = dict(item)
self.file.write(json.dumps(record, ensure_ascii=False, default=str) + "\n")
self.count += 1
return item
def close_spider(self, spider=None):
"""爬虫结束时关闭文件并输出统计。"""
self.file.close()
logging.getLogger("stock_spider").info("JSON 序列化输出完成:%d 条 -> stock_quotes.json", self.count)
class StockMySQLPipeline:
"""把 Item 写入 MySQL,自动建库建表,批量提交。"""
def open_spider(self, spider=None):
"""爬虫启动时连接 MySQL、建库建表;连不上则跳过入库,不影响 JSON 导出。"""
self.connection = None # 先置空,连接失败时 close_spider 也要能安全退出
self.count = 0
try:
self.connection = pymysql.connect(**DB_CONFIG)
self.cursor = self.connection.cursor()
# 库不存在则创建,换电脑运行也不用先手工建库
self.cursor.execute(
"CREATE DATABASE IF NOT EXISTS `{}` DEFAULT CHARACTER SET utf8mb4".format(DATABASE_NAME))
self.cursor.execute("USE `{}`".format(DATABASE_NAME))
self.cursor.execute(CREATE_TABLE_SQL)
self.connection.commit()
logging.getLogger("stock_spider").info("已连接 MySQL %s:%s,数据库 %s",
DB_CONFIG["host"], DB_CONFIG["port"], DATABASE_NAME)
except Exception as exc:
# 数据库未启动时只降级跳过入库,爬虫继续抓数据并导出 JSON
logging.getLogger("stock_spider").warning(
"MySQL 连接失败,跳过入库(数据仍会导出到 JSON):%s", exc)
self.connection = None
def process_item(self, item, spider=None):
"""执行插入/更新语句;数字字段统一转成字符串后交给 MySQL 隐式转换。"""
if self.connection is None: # 数据库不可用时直接放行,交给后续 Pipeline 处理
return item
params = dict(item)
# 抓取时间统一由 Pipeline 补全,避免各爬虫重复处理
params["bSpiderTime"] = params.get("bSpiderTime") or datetime.now()
self.cursor.execute(INSERT_SQL, params)
self.count += 1
# 每 20 条提交一次,减少事务开销
if self.count % 20 == 0:
self.connection.commit()
return item
def close_spider(self, spider=None):
"""爬虫结束时提交剩余数据、关闭连接;未连接时安全跳过。"""
if self.connection is None:
logging.getLogger("stock_spider").warning("MySQL 未连接,本次未入库")
return
self.connection.commit()
self.cursor.close()
self.connection.close()
logging.getLogger("stock_spider").info("MySQL 入库完成:本次处理 %d 条 -> 表 %s.stock_quote",
self.count, DATABASE_NAME)
爬虫(spiders/stock.py):
# -*- coding: utf-8 -*-
"""东方财富网股票行情爬虫(Scrapy + Item/Pipeline + MySQL)。
数据来源说明
1. 东方财富的行情列表页( https://quote.eastmoney.com/center/gridlist.html )
由 JavaScript 动态渲染,Scrapy 直接请求只能拿到空表格骨架,
因此改为请求页面背后真正提供数据的行情接口 push2.eastmoney.com;
2. 该接口对短时间内的高频请求有频控(无数据或直接断连),为保证
任何网络环境下都能跑通,当东方财富接口无数据时自动切换到
新浪财经「行情中心」接口( https://vip.stock.finance.sina.com.cn ),
两者字段一致;新浪接口没有直接给出振幅,由 最高/最低/昨收 计算补齐。
字段对应(东方财富 -> 作业表头)
f12 股票代码 / f14 股票名称 / f2 最新报价 / f3 涨跌幅 / f4 涨跌额
f5 成交量 / f7 振幅 / f15 最高 / f16 最低 / f17 今开 / f18 昨收
"""
import os
from urllib.parse import urlencode
import scrapy
from stock_spider.items import StockItem
# 数据源 1:东方财富行情接口
EM_API_URL = "https://push2.eastmoney.com/api/qt/clist/get"
# 数据源 2:新浪财经行情中心接口(兜底,涨跌幅降序 = 涨幅榜)
SINA_API_URL = ("https://vip.stock.finance.sina.com.cn/quotes_service/api/"
"json_v2.php/Market_Center.getHQNodeData")
class StockQuoteSpider(scrapy.Spider):
"""抓取沪深 A 股涨幅榜前 N 只股票的基本行情。"""
name = "stock_quote"
allowed_domains = ["eastmoney.com", "sina.com.cn"]
# 按涨跌幅降序,一次取满 100 条。行情接口对高频请求敏感,
# 因此尽量减少请求次数;需要更多数据时可分页(page 调大)
page_size = 100
max_pages = 1
# ---------------------------------------------------------------- #
# 初始请求(兼容新旧版本 Scrapy)
# ---------------------------------------------------------------- #
def start_requests(self):
"""按页生成东方财富接口请求(Scrapy 2.13 之前的版本走这里)。"""
for page in range(1, self.max_pages + 1):
yield self.eastmoney_request(page)
async def start(self):
"""
初始请求入口(Scrapy 2.13 起由同步 start_requests 改为异步 start)。
直接复用 start_requests 的生成逻辑,新旧版本的 Scrapy 都能正常运行。
"""
for request in self.start_requests():
yield request
def eastmoney_request(self, page):
"""构造东方财富行情接口请求。"""
params = {
"pn": page, # 页码
"pz": self.page_size, # 每页条数
"po": 1, # 1 表示降序
"np": 1,
"fltt": 2, # 价格保留两位小数
"invt": 2,
"fid": "f3", # 按涨跌幅排序
# 沪深 A 股市场代码组合:深市主板/创业板 + 沪市主板/科创板
"fs": "m:0+t:6,m:0+t:80,m:1+t:2,m:1:t:23",
"fields": "f2,f3,f4,f5,f7,f12,f14,f15,f16,f17,f18",
}
meta = {"page": page}
# 部分网络环境需经由代理访问外网,此处按环境变量可选启用
proxy = os.getenv("HTTPS_PROXY") or os.getenv("https_proxy")
if proxy:
meta["proxy"] = proxy
return scrapy.Request(
"{}?{}".format(EM_API_URL, urlencode(params, safe=",:+")),
callback=self.parse_eastmoney,
meta=meta,
headers={"Referer": "https://quote.eastmoney.com/"},
dont_filter=True,
)
def sina_request(self, page):
"""构造新浪财经行情中心接口请求(东方财富无数据时的兜底)。"""
params = {
"page": page,
"num": self.page_size,
"sort": "changepercent", # 按涨跌幅排序
"asc": 0, # 降序 = 涨幅榜
"node": "hs_a", # 沪深 A 股
}
return scrapy.Request(
"{}?{}".format(SINA_API_URL, urlencode(params)),
callback=self.parse_sina,
meta={"page": page},
headers={"Referer": "https://finance.sina.com.cn/"},
dont_filter=True,
)
# ---------------------------------------------------------------- #
# 解析逻辑
# ---------------------------------------------------------------- #
def parse_eastmoney(self, response):
"""解析东方财富接口返回的 JSON;无数据时自动切换到新浪接口。"""
payload = response.json()
data = payload.get("data") or {}
rows = data.get("diff") or []
if not rows:
self.logger.warning(
"东方财富接口第 %s 页未返回数据(可能触发频控),"
"自动切换到新浪财经行情中心接口", response.meta["page"])
yield self.sina_request(response.meta["page"])
return
rank_base = (response.meta["page"] - 1) * self.page_size
for offset, row in enumerate(rows, start=1):
yield self.make_item(
rank=rank_base + offset,
stock_no=row.get("f12"),
stock_name=row.get("f14"),
latest_price=self.to_float(row.get("f2")),
change_percent=self.to_float(row.get("f3")),
change_amount=self.to_float(row.get("f4")),
volume=row.get("f5") if isinstance(row.get("f5"), int) else None,
amplitude=self.to_float(row.get("f7")),
high=self.to_float(row.get("f15")),
low=self.to_float(row.get("f16")),
open_price=self.to_float(row.get("f17")),
prev_close=self.to_float(row.get("f18")),
)
self.logger.info("东方财富第 %s 页解析完成,共 %d 条",
response.meta["page"], len(rows))
def parse_sina(self, response):
"""
解析新浪财经行情中心接口返回的 JSON(兜底数据源)。
接口直接给出 最新价/涨跌幅/涨跌额/成交量/最高/最低/今开/昨收,
仅「振幅」需要按 (最高-最低)/昨收*100 自行计算。
"""
rows = response.json() or []
rank_base = (response.meta["page"] - 1) * self.page_size
for offset, row in enumerate(rows, start=1):
high = self.to_float(row.get("high"))
low = self.to_float(row.get("low"))
prev_close = self.to_float(row.get("settlement"))
# 振幅(%) = (最高价 - 最低价) / 昨收盘价 * 100
amplitude = None
if high is not None and low is not None and prev_close:
amplitude = round((high - low) / prev_close * 100, 2)
yield self.make_item(
rank=rank_base + offset,
stock_no=row.get("code"),
stock_name=row.get("name"),
latest_price=self.to_float(row.get("trade")),
change_percent=self.to_float(row.get("changepercent")),
change_amount=self.to_float(row.get("pricechange")),
volume=row.get("volume") if isinstance(row.get("volume"), int) else None,
amplitude=amplitude,
high=high,
low=low,
open_price=self.to_float(row.get("open")),
prev_close=prev_close,
)
self.logger.info("新浪财经第 %s 页解析完成,共 %d 条",
response.meta["page"], len(rows))
# ---------------------------------------------------------------- #
# 工具函数
# ---------------------------------------------------------------- #
@staticmethod
def make_item(rank, stock_no, stock_name, latest_price, change_percent,
change_amount, volume, amplitude, high, low, open_price,
prev_close):
"""把一行行情数据组装成 StockItem,避免两处解析逻辑重复。"""
item = StockItem()
item["bRank"] = rank
item["bStockNo"] = stock_no
item["bStockName"] = stock_name
item["bLatestPrice"] = latest_price
item["bChangePercent"] = change_percent
item["bChangeAmount"] = change_amount
item["bVolume"] = volume
item["bAmplitude"] = amplitude
item["bHigh"] = high
item["bLow"] = low
item["bOpen"] = open_price
item["bPrevClose"] = prev_close
return item
@staticmethod
def to_float(value):
"""接口在股票停牌等情况下会返回字符串 '-',统一转换成 None。"""
if value in (None, "-", ""):
return None
try:
return float(value)
except (TypeError, ValueError):
return None
全局配置(settings.py)与启动入口(2.py):
# -*- coding: utf-8 -*-
"""Scrapy 全局配置:并发、下载延迟、请求头与 Pipeline 启用顺序。"""
BOT_NAME = "stock_spider"
SPIDER_MODULES = ["stock_spider.spiders"]
NEWSPIDER_MODULE = "stock_spider.spiders"
# 遵守 robots.txt 会屏蔽行情接口,课程实验中关闭该项
ROBOTSTXT_OBEY = False
# 并发与延迟:适度并发 + 固定下载间隔,避免对数据接口造成压力
CONCURRENT_REQUESTS = 1
DOWNLOAD_DELAY = 2
COOKIES_ENABLED = False
RETRY_ENABLED = True
RETRY_TIMES = 3
# 伪装成浏览器访问
DEFAULT_REQUEST_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"
),
"Accept": "application/json, text/plain, */*",
"Accept-Language": "zh-CN,zh;q=0.9",
}
ITEM_PIPELINES = {
# 先做 JSON 序列化输出,再写数据库
"stock_spider.pipelines.StockJsonPipeline": 100,
"stock_spider.pipelines.StockMySQLPipeline": 300,
}
# 日志级别与中文输出
MEMUSAGE_ENABLED = False # Windows 下无 resource 模块,关闭内存监控扩展
LOG_LEVEL = "INFO"
FEED_EXPORT_ENCODING = "utf-8"
# -*- coding: utf-8 -*-
"""
作业2:Scrapy + Pipeline + MySQL 爬取东方财富网股票行情。
工程结构
作业2/
├── scrapy.cfg # Scrapy 工程配置(指定默认 settings 模块)
├── 2.py # 启动入口:python 2.py 即可运行
├── db.sql # 建库建表语句(Pipeline 中也会自动执行)
└── stock_spider/
├── items.py # Item:定义要抓取的字段
├── pipelines.py # Pipeline:JSON 序列化输出 + MySQL 存储
├── settings.py # 全局配置:并发、延迟、启用哪些 Pipeline
└── spiders/
└── eastmoney.py # 爬虫:请求行情接口并解析成 Item
"""
import os
import sys
from scrapy.crawler import CrawlerProcess
from scrapy.utils.project import get_project_settings
# 保证无论在哪个目录下执行,都能正确找到工程内的 settings 与爬虫包
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
if BASE_DIR not in sys.path:
sys.path.insert(0, BASE_DIR)
os.environ.setdefault("SCRAPY_SETTINGS_MODULE", "stock_spider.settings")
from stock_spider.spiders.stock import StockQuoteSpider # noqa: E402
def main():
"""启动爬虫,运行结束后打印本次抓取的统计信息。"""
process = CrawlerProcess(get_project_settings())
crawler = process.create_crawler(StockQuoteSpider)
process.crawl(crawler)
process.start() # 阻塞直到爬虫结束
stats = crawler.stats.get_stats()
print("=" * 70)
print("爬虫结束:抓取条目 {} 条,请求 {} 次,耗时 {:.2f} 秒".format(
stats.get("item_scraped_count", 0),
stats.get("downloader/request_count", 0),
(stats.get("elapsed_time_seconds", 0.0)),
))
print("数据已写入 MySQL 表 stock_quote,同时导出 stock_quotes.json")
print("=" * 70)
if __name__ == "__main__":
main()
3. 运行结果
运行日志(100 条全部入库):

同时导出 stock_quotes.json,每行一条股票记录,字段与 MySQL 表一一对应(前 27 行 / 后 23 行):


MySQL 查询 stock_quote 表(序号、代码、名称、最新报价、涨跌幅、涨跌额、成交量、振幅、最高、最低、今开、昨收):

4.作业2心得:动态页面与数据管道
作业2最大的障碍是页面由 JS 渲染:请求行情中心页面拿到的 HTML 里只有空表格骨架。我的处理办法是打开浏览器开发者工具,找到页面背后真正承载数据的行情接口,让 Scrapy 直接请求接口并解析 JSON。这次还遇到了接口频控(短时间内高频请求会被断连),所以我把分页请求合并为一次取 100 条,并加了双数据源兜底:东方财富接口无数据时自动切换新浪行情中心接口,两个数据源的字段映射写在一个 make_item 里,解析逻辑不重复。通过写 Pipeline 我理解了 Scrapy「爬取与处理解耦」的设计:Item 只负责声明字段,序列化输出(JSON 文件)和持久化存储(MySQL)各自是独立的 Pipeline,用优先级控制先后;入库时用「唯一键 + ON DUPLICATE KEY UPDATE」保证脚本反复运行也不会产生重复数据。
(三)作业3:中国银行外汇牌价(Scrapy + XPath + MySQL)
https://gitee.com/zyj102402147/spider/tree/main/数据采集博客园作业/数据采集作业三/作业3
1. 思路
中国银行外汇牌价页面 https://www.boc.cn/sourcedb/whpj/ 是服务端渲染的静态表格,直接用 XPath 定位:先按表头文字「货币名称」精确定位牌价表格(页面里还有导航等无关表格),再取所有含 td 的数据行,逐格提取货币名称、现汇买入价(TBP)、现钞买入价(CBP)、现汇卖出价(TSP)、现钞卖出价(CSP)、中行折算价与发布时间。现钞价为空(如部分币种只公布汇价)时存 NULL,发布日期 发布时间 合并成 DATETIME 入库。
2. 作业代码
Item 定义(items.py):
# -*- coding: utf-8 -*-
"""
Item 定义:中国银行外汇牌价。
字段对应网站表格列(作业要求的 Currency / TBP / CBP / TSP / CSP / Time)
currency 货币名称
tbp 现汇买入价(TBP = Telegraphic Buying Price)
cbp 现钞买入价(CBP = Cash Buying Price)
tsp 现汇卖出价(TSP = Telegraphic Selling Price)
csp 现钞卖出价(CSP = Cash Selling Price)
midRate 中行折算价
publishTime 发布时间(由发布日期与发布时间合并而成)
"""
import scrapy
class ForexItem(scrapy.Item):
"""外汇牌价 Item。"""
currency = scrapy.Field() # 货币名称
tbp = scrapy.Field() # 现汇买入价
cbp = scrapy.Field() # 现钞买入价
tsp = scrapy.Field() # 现汇卖出价
csp = scrapy.Field() # 现钞卖出价
midRate = scrapy.Field() # 中行折算价
publishTime = scrapy.Field() # 发布时间
爬虫(spiders/boc.py):
# -*- coding: utf-8 -*-
"""
中国银行外汇牌价爬虫(Scrapy + XPath)。
目标页面:https://www.boc.cn/sourcedb/whpj/
页面为服务端渲染的静态表格,因此直接用 XPath 定位表格行与单元格即可,
无需借助接口或浏览器渲染。
"""
from datetime import datetime
import scrapy
from forex_spider.items import ForexItem
# 牌价页面地址(人民币外汇牌价,全部货币在同一页展示)
START_URL = "https://www.boc.cn/sourcedb/whpj/"
class BocForexSpider(scrapy.Spider):
"""抓取中国银行外汇牌价表格。"""
name = "boc_forex"
allowed_domains = ["boc.cn"]
# 表头中出现的文字,用来精确定位牌价表格(页面中还有其它无关表格)
TABLE_HEADER = "货币名称"
async def start(self):
"""初始请求入口(Scrapy 2.13+ 使用异步 start)。"""
yield scrapy.Request(START_URL, callback=self.parse, dont_filter=True)
def start_requests(self):
"""兼容 Scrapy 2.13 之前版本的入口。"""
yield scrapy.Request(START_URL, callback=self.parse, dont_filter=True)
def parse(self, response):
"""
用 XPath 逐行解析牌价表格。
页面中第 1 个表格为导航、第 2 个表格才是牌价数据,因此先按表头文字定位表格,
再取其中所有包含 td 的行(表头行只有 th,会被自动排除)。
"""
rows = response.xpath(
"//table[.//th[contains(normalize-space(.), '{}')]]//tr[td]".format(self.TABLE_HEADER)
)
self.logger.info("定位到牌价数据行 %d 条", len(rows))
for row in rows:
# 依次取出 8 个单元格的文本:货币名称、现汇买入、现钞买入、现汇卖出、
# 现钞卖出、中行折算价、发布日期、发布时间
cells = [cell.xpath("normalize-space(.)").get() for cell in row.xpath("./td")]
if len(cells) < 8 or not cells[0]:
continue
item = ForexItem()
item["currency"] = cells[0]
item["tbp"] = self.to_decimal(cells[1])
item["cbp"] = self.to_decimal(cells[2])
item["tsp"] = self.to_decimal(cells[3])
item["csp"] = self.to_decimal(cells[4])
item["midRate"] = self.to_decimal(cells[5])
item["publishTime"] = self.to_datetime(cells[6], cells[7])
yield item
@staticmethod
def to_decimal(text):
"""把价格文本转成浮点数;现钞价为空时返回 None。"""
text = (text or "").strip()
if not text:
return None
try:
return float(text)
except ValueError:
return None
@staticmethod
def to_datetime(date_text, time_text):
"""
把「发布日期」与「发布时间」合并成 datetime。
网站给出的发布日期本身就带时分秒(如 2026/11/16 09:19:50),
这里兼容「只有日期」的情况,最后再退化为「日期 + 时间」拼接。
"""
date_text = (date_text or "").strip()
time_text = (time_text or "").strip()
candidates = (
(date_text, "%Y/%m/%d %H:%M:%S"),
(date_text, "%Y/%m/%d"),
("{} {}".format(date_text, time_text), "%Y/%m/%d %H:%M:%S"),
)
for text, fmt in candidates:
if not text.strip():
continue
try:
return datetime.strptime(text.strip(), fmt)
except ValueError:
continue
return None
Pipeline(pipelines.py):
# -*- coding: utf-8 -*-
"""
Pipeline 定义:
1. ForexJsonPipeline —— Item 序列化成 JSON 行写入 forex_quotes.json;
2. ForexMySQLPipeline —— 写入 MySQL 表 forex_quote(按货币名称 + 发布时间去重)。
"""
import json
import logging
import os
from datetime import datetime
import pymysql
LOG = logging.getLogger("forex_spider")
# MySQL 连接配置,可用环境变量覆盖
DB_CONFIG = {
"host": os.getenv("MYSQL_HOST", "127.0.0.1"),
"port": int(os.getenv("MYSQL_PORT", "3306")),
"user": os.getenv("MYSQL_USER", "root"),
"password": os.getenv("MYSQL_PASSWORD", "123456"),
"charset": "utf8mb4",
"autocommit": False,
}
DATABASE_NAME = os.getenv("MYSQL_DATABASE", "spider")
CREATE_TABLE_SQL = """
CREATE TABLE IF NOT EXISTS forex_quote (
id INT UNSIGNED NOT NULL AUTO_INCREMENT COMMENT '序号',
currency VARCHAR(32) NOT NULL COMMENT '货币名称',
tbp DECIMAL(12, 4) DEFAULT NULL COMMENT '现汇买入价',
cbp DECIMAL(12, 4) DEFAULT NULL COMMENT '现钞买入价',
tsp DECIMAL(12, 4) DEFAULT NULL COMMENT '现汇卖出价',
csp DECIMAL(12, 4) DEFAULT NULL COMMENT '现钞卖出价',
midRate DECIMAL(12, 4) DEFAULT NULL COMMENT '中行折算价',
publishTime DATETIME DEFAULT NULL COMMENT '发布时间',
crawledAt DATETIME DEFAULT NULL COMMENT '抓取时间',
PRIMARY KEY (id),
UNIQUE KEY uniq_currency_time (currency, publishTime)
) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4 COMMENT = '中国银行外汇牌价';
"""
INSERT_SQL = """
INSERT INTO forex_quote
(currency, tbp, cbp, tsp, csp, midRate, publishTime, crawledAt)
VALUES (%(currency)s, %(tbp)s, %(cbp)s, %(tsp)s, %(csp)s, %(midRate)s,
%(publishTime)s, %(crawledAt)s)
ON DUPLICATE KEY UPDATE
tbp = VALUES(tbp), cbp = VALUES(cbp), tsp = VALUES(tsp),
csp = VALUES(csp), midRate = VALUES(midRate), crawledAt = VALUES(crawledAt)
"""
class ForexJsonPipeline:
"""把外汇牌价 Item 序列化为 JSON 行,保存到 forex_quotes.json。"""
def open_spider(self, spider=None):
"""爬虫启动时创建输出文件。"""
file_path = os.path.join(os.path.dirname(os.path.dirname(
os.path.abspath(__file__))), "forex_quotes.json")
self.file = open(file_path, "w", encoding="utf-8")
self.count = 0
def process_item(self, item, spider=None):
"""序列化为 JSON 并写入一行。"""
self.file.write(json.dumps(dict(item), ensure_ascii=False, default=str) + "\n")
self.count += 1
return item
def close_spider(self, spider=None):
"""爬虫结束时关闭文件。"""
self.file.close()
LOG.info("JSON 序列化输出完成:%d 条 -> forex_quotes.json", self.count)
class ForexMySQLPipeline:
"""把外汇牌价写入 MySQL,自动建库建表。"""
def open_spider(self, spider=None):
"""连接 MySQL 并建库建表;连不上则跳过入库,不影响 JSON 导出。"""
self.connection = None # 先置空,连接失败时 close_spider 也要能安全退出
self.count = 0
try:
self.connection = pymysql.connect(**DB_CONFIG)
self.cursor = self.connection.cursor()
self.cursor.execute(
"CREATE DATABASE IF NOT EXISTS `{}` DEFAULT CHARACTER SET utf8mb4".format(DATABASE_NAME))
self.cursor.execute("USE `{}`".format(DATABASE_NAME))
self.cursor.execute(CREATE_TABLE_SQL)
self.connection.commit()
LOG.info("已连接 MySQL %s:%s,数据库 %s",
DB_CONFIG["host"], DB_CONFIG["port"], DATABASE_NAME)
except Exception as exc:
# 数据库未启动时只降级跳过入库,爬虫继续抓数据并导出 JSON
LOG.warning("MySQL 连接失败,跳过入库(数据仍会导出到 JSON):%s", exc)
self.connection = None
def process_item(self, item, spider=None):
"""写入一条牌价数据,抓取时间由 Pipeline 统一补全。"""
if self.connection is None: # 数据库不可用时直接放行,交给后续 Pipeline 处理
return item
params = dict(item)
params["crawledAt"] = datetime.now()
self.cursor.execute(INSERT_SQL, params)
self.count += 1
if self.count % 20 == 0:
self.connection.commit()
return item
def close_spider(self, spider=None):
"""提交并关闭连接;未连接时安全跳过。"""
if self.connection is None:
LOG.warning("MySQL 未连接,本次未入库")
return
self.connection.commit()
self.cursor.close()
self.connection.close()
LOG.info("MySQL 入库完成:本次处理 %d 条 -> 表 %s.forex_quote",
self.count, DATABASE_NAME)
全局配置(settings.py)与启动入口(3.py):
# -*- coding: utf-8 -*-
"""Scrapy 全局配置:并发、下载延迟、请求头与 Pipeline 启用顺序。"""
BOT_NAME = "forex_spider"
SPIDER_MODULES = ["forex_spider.spiders"]
NEWSPIDER_MODULE = "forex_spider.spiders"
# 中国银行网站未在 robots.txt 中禁止抓取牌价页面,此处按要求关闭 robots 检查
ROBOTSTXT_OBEY = False
# 单页面即可取到全部牌价,不需要高并发;保留适度延迟
CONCURRENT_REQUESTS = 2
DOWNLOAD_DELAY = 1.0
COOKIES_ENABLED = False
RETRY_ENABLED = True
RETRY_TIMES = 2
DEFAULT_REQUEST_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"
),
"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
"Accept-Language": "zh-CN,zh;q=0.9",
}
ITEM_PIPELINES = {
"forex_spider.pipelines.ForexJsonPipeline": 100,
"forex_spider.pipelines.ForexMySQLPipeline": 300,
}
MEMUSAGE_ENABLED = False # Windows 下无 resource 模块,关闭内存监控扩展
LOG_LEVEL = "INFO"
FEED_EXPORT_ENCODING = "utf-8"
# -*- coding: utf-8 -*-
"""
作业3:Scrapy + XPath + MySQL 爬取中国银行外汇牌价。
工程结构
作业3/
├── scrapy.cfg
├── 3.py # 启动入口:python 3.py
├── db.sql # 建库建表语句
└── forex_spider/
├── items.py # Item:货币名称、买入价、卖出价、发布时间等
├── pipelines.py # Pipeline:JSON 序列化 + MySQL 存储
├── settings.py
└── spiders/
└── boc.py # 爬虫:用 XPath 解析牌价表格
"""
import os
import sys
from scrapy.crawler import CrawlerProcess
from scrapy.utils.project import get_project_settings
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
if BASE_DIR not in sys.path:
sys.path.insert(0, BASE_DIR)
os.environ.setdefault("SCRAPY_SETTINGS_MODULE", "forex_spider.settings")
from forex_spider.spiders.boc import BocForexSpider # noqa: E402
def main():
"""启动爬虫,结束后打印统计信息。"""
process = CrawlerProcess(get_project_settings())
crawler = process.create_crawler(BocForexSpider)
process.crawl(crawler)
process.start()
stats = crawler.stats.get_stats()
print("=" * 70)
print("爬虫结束:抓取条目 {} 条,请求 {} 次,耗时 {:.2f} 秒".format(
stats.get("item_scraped_count", 0),
stats.get("downloader/request_count", 0),
stats.get("elapsed_time_seconds", 0.0),
))
print("数据已写入 MySQL 表 forex_quote,同时导出 forex_quotes.json")
print("=" * 70)
if __name__ == "__main__":
main()
3. 运行结果
45 种货币一次请求全部抓取入库:

MySQL 查询 forex_quote 表(Currency / TBP / CBP / TSP / CSP / Time):

4.作业3心得:XPath 解析与数据落地
作业3的页面是静态表格,正好完整练习了 XPath:页面里有 4 个 <table>,直接按行号取很容易踩坑,我改用「表头文字定位」——找包含「货币名称」表头的表格再取数据行,页面改版时也更稳健。解析时遇到了两类脏数据:部分币种的现钞买入/卖出价为空(要用 normalize-space() 取文本并判断空串,入库转 NULL),以及发布日期本身已带时分秒(要与「日期 + 时间」拼接的情况兼容)。存储层复用了作业②的 Pipeline 思路,以「货币 + 发布时间」为唯一键去重。三个作业做完,我对「采集 → 解析成 Item → Pipeline 序列化/入库」这条链路的每个环节都有了实操层面的理解,也体会到:爬虫的难点往往不在某一行代码,而在于对目标页面结构、接口行为和异常数据的处理。
二、实验总结
本次实验围绕网络爬虫的数据采集与持久化展开,完成了从页面请求、数据提取到结构化入库的完整流程。过程中,我分别练习了单线程与多线程的图片批量下载、基于 Scrapy 框架的动态接口数据抓取,以及静态表格的 XPath 解析,并将最终结果同时导出为 JSON 文件和存入 MySQL 数据库,对"采集—解析—存储"这条链路的每个环节都有了实操层面的理解。 实验让我认识到,爬虫的核心难点并不在某一行代码,而在于对目标页面结构、接口行为和异常数据的分析判断。静态页面可以直接用 XPath 解析,动态渲染页面则要借助开发者工具找到背后真正承载数据的接口;面对接口频控,需要通过合并请求、增加延迟和双数据源兜底来保证稳定运行。在并发下载中,我体会到多线程对 IO 密集型任务的收益,也理解了提速并非随线程数线性增长,带宽与服务器响应会成为新的瓶颈。此外,通过编写独立的 Item 和 Pipeline,我掌握了 Scrapy"爬取与处理解耦"的设计思想,并利用唯一键与更新语句保证数据反复抓取时不产生重复。 这次实验也让我意识到代码健壮性的重要:采集规模要受学号上限约束、请求要有间隔和重试、数据库不可用时爬虫应优雅降级而非直接崩溃。这些经验让我对数据采集工程有了更完整、更贴近实战的认识,也为后续处理更复杂的爬取任务打下了基础。

浙公网安备 33010602011771号