数据采集第三次作业
学号:102580126 姓名:黄喆珺 课程:数据采集与融合技术
运行环境:Windows 10/11、Python 3.14.0、Scrapy 2.13.4、requests 2.34、BeautifulSoup 4、lxml、PyMySQL、MySQL 8.0.45、Chrome 156(截图与页面核对)
本次作业包含三个部分:作业①用 requests 抓取一个图片站点,分别实现单线程与多线程并对比耗时;作业②用 Scrapy + MySQL 采集股票行情;作业③用 Scrapy + XPath + MySQL 采集中国银行外汇牌价。三个任务共用同一个数据库 homework3,方便集中查看结果。
一、作业①:网站图片爬取(单线程 / 多线程)
1.1 需求拆解、代码实现与运行结果
目标站点选择。 题目以中国气象网为例,要求“指定一个网站,爬取这个网站中的所有图片”。我先后试过中国气象网和人民网图片频道:中国气象网首页 26 个页面去重后只有约 80 张图片,达不到学号要求的 126 张上限;人民网图片频道(http://pic.people.com.cn/)以图集为主,单页图片密度高,26 个页面可以稳定取到超过 126 张图片,因此最终选择它作为采集对象。站点选择不影响技术路线,爬虫中的 START_URL 与 ALLOWED_HOST 两个常量即可切换。
学号限制的落地。 学号 102580126:末 2 位 26 作为页面总数上限,末 3 位 126 作为图片下载数量上限。程序里用 MAX_PAGES = int(STUDENT_NO[-2:])、MAX_IMAGES = int(STUDENT_NO[-3:]) 由学号自动计算,避免写死数字。
抓取流程。
- 从首页开始做广度优先遍历(BFS),只跟随
pic.people.com.cn域内的 HTML 链接,跳过图片、压缩包、CSS/JS 等静态资源; - 每取到一个页面,用 BeautifulSoup 解析全部
<img>(同时兼容data-src、data-original等懒加载属性),把相对地址转成绝对地址; - 所有页面解析完成后按出现顺序去重,得到候选图片列表;
- 下载时过滤非图片响应与小于 1KB 的 1×1 统计像素,成功下载满 126 张即停止;
- 单线程版本按顺序逐个下载;多线程版本用
ThreadPoolExecutor(默认 8 线程)分批并发下载,每个线程使用独立的requests.Session,避免连接对象跨线程共享。
这里有一个容易忽略的细节:站内存在 1×1 统计图、失效图等无法下载的地址,如果只收集 126 个候选地址,最终成功数会不足 126。因此
collect_images()额外多收集 60 个候选,边下载边计数,成功满 126 张才停止。
完整代码(image_crawler.py):
"""作业①:爬取人民网图片频道(http://pic.people.com.cn)的图片。
功能说明:
1. 从首页出发,按广度优先(BFS)遍历站内 HTML 页面,页面上限由学号决定;
2. 解析每个页面中的 <img> 标签,得到图片的绝对 URL,按出现顺序去重;
3. 下载图片到 images/ 目录,图片数量上限同样由学号决定;
4. 提供单线程(--mode single)和多线程(--mode multi)两种实现并对运行时间做对比。
学号规则(102580126):
- 学号末 2 位 → 26,表示最多遍历 26 个页面;
- 学号末 3 位 → 126,表示最多下载 126 张图片。
用法:
python image_crawler.py --mode single
python image_crawler.py --mode multi --workers 8
"""
from __future__ import annotations
import argparse
import hashlib
import json
import re
import sys
import time
from collections import deque
from concurrent.futures import ThreadPoolExecutor, as_completed
from pathlib import Path
from urllib.parse import urljoin, urlparse
import requests
from bs4 import BeautifulSoup
# ---------------------------- 全局配置 ----------------------------
STUDENT_NO = "102580126" # 学号
MAX_PAGES = int(STUDENT_NO[-2:]) # 26:最多遍历的页面数
MAX_IMAGES = int(STUDENT_NO[-3:]) # 126:最多下载的图片数
START_URL = "http://pic.people.com.cn/" # 爬取起点:人民网图片频道首页
ALLOWED_HOST = "pic.people.com.cn" # 只在该主机范围内遍历页面
PAGE_DELAY = 0.15 # 每次请求页面后的短暂停顿,避免给服务器造成压力
TIMEOUT = 20 # 单次请求超时时间(秒)
ROOT = Path(__file__).resolve().parent
IMAGE_DIR = ROOT / "images" # 图片保存目录
OUTPUT_DIR = ROOT / "output" # 运行报告目录
HEADERS = {
"User-Agent": (
"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 "
"(KHTML, like Gecko) Chrome/156.0.0.0 Safari/537.36"
),
"Accept": "text/html,application/xhtml+xml,image/avif,image/webp,*/*;q=0.8",
"Accept-Language": "zh-CN,zh;q=0.9",
}
# ---------------------------- 工具函数 ----------------------------
def normalize_url(base: str, href: str) -> str | None:
"""把页面中的相对地址转成绝对地址,并过滤掉非页面的链接。"""
if not href:
return None
href = href.strip()
if href.startswith(("#", "javascript:", "mailto:", "tel:")):
return None
absolute = urljoin(base, href).split("#")[0]
parsed = urlparse(absolute)
if parsed.scheme not in ("http", "https"):
return None
if parsed.netloc.lower() != ALLOWED_HOST:
return None
# 只跟随 HTML 页面,跳过图片、压缩包等静态资源
if re.search(r"\.(jpg|jpeg|png|gif|webp|bmp|ico|pdf|zip|rar|mp4|css|js)$", parsed.path, re.I):
return None
return absolute
def decode_html(response: requests.Response) -> str:
"""按响应头或内容猜测编码,天气网页面以 UTF-8 为主,兼容 GB18030。"""
if response.encoding and response.encoding.lower() not in ("iso-8859-1",):
try:
return response.content.decode(response.encoding, errors="replace")
except LookupError:
pass
for encoding in ("utf-8", "gb18030"):
try:
return response.content.decode(encoding)
except UnicodeDecodeError:
continue
return response.content.decode("utf-8", errors="replace")
def fetch_page(session: requests.Session, url: str) -> tuple[str | None, str | None]:
"""请求一个页面,返回 (HTML, 最终URL);失败时返回 (None, 错误信息)。"""
try:
response = session.get(url, headers=HEADERS, timeout=TIMEOUT)
response.raise_for_status()
content_type = response.headers.get("Content-Type", "")
if "html" not in content_type.lower() and "xml" not in content_type.lower():
return None, f"非HTML内容({content_type})"
return decode_html(response), response.url
except Exception as exc: # 网络异常不影响后续页面
return None, f"{type(exc).__name__}: {exc}"
def extract_image_urls(html: str, base_url: str) -> list[str]:
"""从页面 HTML 中提取 <img> 的图片地址(含常见懒加载属性)。"""
soup = BeautifulSoup(html, "lxml")
urls: list[str] = []
for tag in soup.find_all("img"):
raw = tag.get("src") or tag.get("data-src") or tag.get("data-original") or tag.get("lazy-src")
if not raw:
continue
absolute = urljoin(base_url, raw.strip())
if absolute.startswith("data:"):
continue
urls.append(absolute)
return urls
def extract_page_links(html: str, base_url: str) -> list[str]:
"""从页面 HTML 中提取可继续遍历的站内页面链接。"""
soup = BeautifulSoup(html, "lxml")
links: list[str] = []
for tag in soup.find_all("a"):
absolute = normalize_url(base_url, tag.get("href", ""))
if absolute:
links.append(absolute)
return links
def guess_suffix(content_type: str, url: str) -> str:
"""根据 Content-Type 或 URL 推断图片扩展名。"""
mapping = {"image/jpeg": ".jpg", "image/jpg": ".jpg", "image/png": ".png",
"image/gif": ".gif", "image/webp": ".webp", "image/bmp": ".bmp"}
for key, suffix in mapping.items():
if key in content_type.lower():
return suffix
matched = re.search(r"\.(jpg|jpeg|png|gif|webp|bmp)(?:\?|$)", url, re.I)
return "." + matched.group(1).lower().replace("jpeg", "jpg") if matched else ".jpg"
def build_pages(session: requests.Session, max_pages: int) -> list[dict]:
"""广度优先遍历站内页面,返回页面列表(含每个页面的图片地址)。
注意:页面发现阶段采用固定顺序的 BFS,保证单线程与多线程两次运行
面对的是同一批页面与同一批图片,便于公平比较下载耗时。
"""
visited: set[str] = set()
queue: deque[str] = deque([START_URL])
pages: list[dict] = []
while queue and len(pages) < max_pages:
url = queue.popleft()
if url in visited:
continue
visited.add(url)
html, final_url = fetch_page(session, url)
if html is None:
print(f"[页面失败] {url} -> {final_url}")
continue
page_no = len(pages) + 1
images = extract_image_urls(html, final_url or url)
pages.append({"page_no": page_no, "url": final_url or url, "images": images})
print(f"[页面 {page_no:02d}/{max_pages}] 图片 {len(images):3d} 个 {final_url or url}")
for link in extract_page_links(html, final_url or url):
if link not in visited:
queue.append(link)
time.sleep(PAGE_DELAY)
return pages
def collect_images(pages: list[dict], limit: int, buffer: int = 60) -> list[dict]:
"""汇总各页图片地址,按首次出现顺序去重。
额外多收集 buffer 个候选地址:站内存在 1x1 统计图、失效图等无法下载的地址,
多留候选才能保证最终成功下载的数量达到 limit 张。
"""
seen: set[str] = set()
picked: list[dict] = []
for page in pages:
for url in page["images"]:
if url in seen:
continue
seen.add(url)
picked.append({"index": len(picked) + 1, "url": url, "page_no": page["page_no"]})
if len(picked) >= limit + buffer:
return picked
return picked
def save_image(session: requests.Session, item: dict) -> dict:
"""下载单张图片并保存,返回下载结果。"""
started = time.perf_counter()
try:
response = session.get(item["url"], headers=HEADERS, timeout=TIMEOUT)
response.raise_for_status()
content_type = response.headers.get("Content-Type", "")
if "image" not in content_type.lower():
raise ValueError(f"非图片内容({content_type})")
if len(response.content) < 1024: # 过滤统计用的 1x1 透明图
raise ValueError(f"图片过小({len(response.content)}B)")
suffix = guess_suffix(content_type, item["url"])
digest = hashlib.sha1(item["url"].encode("utf-8")).hexdigest()[:10]
filename = f"{item['index']:03d}_{digest}{suffix}"
(IMAGE_DIR / filename).write_bytes(response.content)
return {
**item,
"file": filename,
"bytes": len(response.content),
"status": response.status_code,
"elapsed": round(time.perf_counter() - started, 3),
}
except Exception as exc:
return {**item, "file": None, "bytes": 0, "status": "FAIL",
"error": f"{type(exc).__name__}: {exc}",
"elapsed": round(time.perf_counter() - started, 3)}
def download_single(session: requests.Session, items: list[dict], limit: int) -> list[dict]:
"""单线程:按顺序逐个下载,成功达到 limit 张即停止。"""
results = []
success = 0
for item in items:
result = save_image(session, item)
results.append(result)
if result["file"]:
success += 1
print(f"[{success:03d}/{limit}] {result['status']} "
f"{result['bytes']/1024:7.1f}KB {result['elapsed']:5.2f}s {item['url']}")
if success >= limit:
break
return results
def download_multi(items: list[dict], workers: int, limit: int) -> list[dict]:
"""多线程:用线程池分批并发下载,成功达到 limit 张即停止。"""
results: list[dict] = []
success = 0
batch_size = workers * 3
started = time.perf_counter()
def task(item: dict) -> dict:
# 每个线程使用独立 Session,避免连接对象跨线程共享
with requests.Session() as local_session:
return save_image(local_session, item)
with ThreadPoolExecutor(max_workers=workers) as pool:
for start in range(0, len(items), batch_size):
batch = items[start:start + batch_size]
futures = [pool.submit(task, item) for item in batch]
for future in as_completed(futures):
result = future.result()
results.append(result)
if result["file"]:
success += 1
print(f"[{min(success, limit):03d}/{limit}] {result['status']} {result['bytes']/1024:7.1f}KB "
f"{result['elapsed']:5.2f}s {result['url']}")
if success >= limit:
break
# 并发批次可能超额完成,这里把超出上限的图片删除并回滚记录,保证恰好保留 limit 张
kept = [item for item in results if item["file"]]
if len(kept) > limit:
for item in kept[limit:]:
target = IMAGE_DIR / item["file"]
if target.exists():
target.unlink()
item["file"] = None
item["error"] = "超出图片上限,未保留"
item["bytes"] = 0
elapsed = time.perf_counter() - started
print(f"[多线程] 并发下载达到上限 {limit} 张,耗时 {elapsed:.2f}s({workers} 个线程)")
return results
# ---------------------------- 主流程 ----------------------------
def run(mode: str, workers: int) -> dict:
"""执行一次完整爬取,返回并保存本次运行报告。"""
IMAGE_DIR.mkdir(parents=True, exist_ok=True)
OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
for old in IMAGE_DIR.glob("*"): # 每次运行前清空,保证两次运行状态一致
if old.is_file():
old.unlink()
print("=" * 84)
print("数据采集与融合技术 第三次作业 作业① 人民网图片频道图片爬取")
print(f"学号:{STUDENT_NO} 页面上限:{MAX_PAGES}(末2位) 图片上限:{MAX_IMAGES}(末3位)")
print(f"运行方式:{'单线程' if mode == 'single' else f'多线程({workers} 线程)'}")
print("=" * 84)
started = time.perf_counter()
with requests.Session() as session:
pages = build_pages(session, MAX_PAGES)
candidates = collect_images(pages, MAX_IMAGES)
print(f"[汇总] 共访问页面 {len(pages)} 个,去重后候选图片 {len(candidates)} 张(目标下载 {MAX_IMAGES} 张)")
download_started = time.perf_counter()
if mode == "single":
results = download_single(session, candidates, MAX_IMAGES)
else:
results = download_multi(candidates, workers, MAX_IMAGES)
download_elapsed = time.perf_counter() - download_started
total_elapsed = time.perf_counter() - started
ok = [item for item in results if item.get("file")]
over_limit = [item for item in results if item.get("error") == "超出图片上限,未保留"]
failed = [item for item in results if not item.get("file") and item.get("error") != "超出图片上限,未保留"]
total_bytes = sum(item["bytes"] for item in ok)
report = {
"student_no": STUDENT_NO,
"mode": mode,
"workers": workers if mode == "multi" else 1,
"pages_limit": MAX_PAGES,
"images_limit": MAX_IMAGES,
"pages_crawled": len(pages),
"images_found": len(candidates),
"images_downloaded": len(ok),
"images_failed": len(failed),
"images_over_limit": len(over_limit),
"total_bytes": total_bytes,
"download_seconds": round(download_elapsed, 3),
"total_seconds": round(total_elapsed, 3),
"image_dir": str(IMAGE_DIR),
"pages": [{"page_no": page["page_no"], "url": page["url"], "image_count": len(page["images"])} for page in pages],
"images": results,
}
report_path = OUTPUT_DIR / f"report_{mode}.json"
report_path.write_text(json.dumps(report, ensure_ascii=False, indent=2), encoding="utf-8")
print("-" * 84)
print(f"页面:{len(pages)} 个(上限 {MAX_PAGES})")
print(f"图片:成功 {len(ok)} 张(上限 {MAX_IMAGES});无效地址 {len(failed)} 个;超出上限未保留 {len(over_limit)} 个")
print(f"总字节:{total_bytes / 1024 / 1024:.2f} MB 下载耗时:{download_elapsed:.2f}s 总耗时:{total_elapsed:.2f}s")
print(f"图片目录:{IMAGE_DIR}")
print(f"报告文件:{report_path}")
print("=" * 84)
return report
def main() -> None:
parser = argparse.ArgumentParser(description="中国气象网图片爬虫(单线程/多线程)")
parser.add_argument("--mode", choices=("single", "multi"), default="single", help="运行模式")
parser.add_argument("--workers", type=int, default=8, help="多线程模式下的线程数")
args = parser.parse_args()
report = run(args.mode, args.workers)
if report["images_downloaded"] < MAX_IMAGES:
print(f"[提示] 实际下载 {report['images_downloaded']} 张,少于上限 {MAX_IMAGES} 张")
sys.exit(2)
if __name__ == "__main__":
main()
运行方式:
python image_crawler.py --mode single
python image_crawler.py --mode multi --workers 8
运行结果。 两次运行都访问 26 个页面、成功下载 126 张图片,差异只在下载方式:
| 运行模式 | 页面数 | 成功下载 | 图片总量 | 下载耗时 | 总耗时 |
|---|---|---|---|---|---|
| 单线程 | 26 | 126 | 63.63 MB | 13.63 s | 20.68 s |
| 多线程(8 线程) | 26 | 126 | 61.71 MB | 5.03 s | 10.29 s |
多线程把下载阶段从 13.63 s 压缩到 5.03 s,约 2.7 倍;总耗时(含页面遍历)从 20.68 s 降到 10.29 s。两次图片总量略有差异,是因为并发批次中先完成的图片进入 126 张,属于正常的调度差异。



控制台按 [序号/126] 状态码 大小 单张耗时 URL 的格式逐行输出下载信息,图片保存在 images/ 子目录中,文件名由“序号 + URL 哈希 + 扩展名”组成,既能保持顺序,又能避免同名覆盖。
1.2 实验心得
这次作业让我第一次直观看到“并发到底快在哪里”。单线程下载 126 张图片用了 13.63 s,而 8 线程只用了 5.03 s,但耗时并没有按 8 倍线性下降——因为瓶颈不只是网络:服务器对同一 IP 的响应速度、TLS 握手、磁盘写入都会限制加速比,线程数加到 16 时收益已经明显变小。所以我最终把线程数定在 8,既能明显提速,又不会给对方站点造成过大压力。
第二个体会是“限制条件要写成代码里的常量”。题目要求按学号控制页数和图片数,如果靠人工数,很容易在多线程乱序时数错。我用 STUDENT_NO[-2:] 和 STUDENT_NO[-3:] 自动算出 26 和 126,并让下载函数在“成功数达到上限”时立即停止,这样无论单线程还是多线程,结果都严格可控。
第三个坑是“候选地址不等于可下载地址”。第一版只收集 126 个 URL,实际只成功 77 张:一部分是 1×1 统计像素,一部分是返回 404 的失效图,还有的是非图片内容。后来改成多收集 60 个候选、边下载边计数、过滤小图和非图片响应,才稳定拿到 126 张。这件事说明爬虫里的“数量限制”应该限制“成功结果”,而不是限制“尝试次数”。
最后是编码与礼貌问题。人民网页面是 GB2312/GBK 编码,解析前必须显式解码,否则中文标题会乱码;爬取时我加了 0.15 s 的页面间隔和正常 User-Agent,只抓公开的图片资源,不做高频请求。
二、作业②③:Scrapy + XPath + MySQL 结构化数据采集
2.1 代码实现与运行结果
两个任务都采用“Scrapy Spider → Item → 双 Pipeline(JSON 序列化 + MySQL 入库)”的结构:Item 定义字段,Pipeline 负责序列化和持久化,settings.py 中通过 ITEM_PIPELINES 按优先级串联两个 Pipeline。数据库统一使用 homework3,股票表 stock_quote、外汇表 forex_rate 由 Pipeline 启动时自动建表。
(一)作业②:股票行情采集
数据源与遇到的问题。 题目给出的候选网站是东方财富网。东方财富行情中心的列表页 quote.eastmoney.com/center/gridlist.html 是 JavaScript 渲染的,直接请求只能拿到页面框架;它背后的行情接口 push2.eastmoney.com/api/qt/clist/get 在本次实验时段持续返回 502 Bad Gateway(多次重试、更换 push 节点、用浏览器访问均相同),因此我在 Spider 里做了“主数据源 + 备用数据源”的设计:
- 主数据源:东方财富行情接口,字段映射为
f2最新价、f3涨跌幅、f4涨跌额、f5成交量、f7振幅、f12代码、f14名称、f15最高、f16最低、f17今开、f18昨收; - 备用数据源:新浪财经沪深 A 股行情接口,字段含义相同;新浪接口没有直接给“振幅”,用
(最高 - 最低) / 昨收 × 100%计算,volume由“股”换算为“手”; - 两个数据源解析出的 Item 字段完全一致,Pipeline 与 MySQL 表结构不受影响;
- 个股页
quote.eastmoney.com/sz000001.html是服务端渲染的 HTML,Spider 会用 XPath 取<title>(形如“平安银行(000001)_最新价格_行情_走势图—东方财富网”),校验名称与代码是否对应,作为名称的二次校验。
Item 定义:
"""作业②:东方财富股票行情数据项定义。
Item 用于在 Spider 与 Pipeline 之间传递结构化数据,字段与作业要求的
“序号 / 股票代码 / 股票名称 / 最新报价 / 涨跌幅 / 涨跌额 / 成交量 /
振幅 / 最高 / 最低 / 今开 / 昨收”一一对应。
"""
import scrapy
class StockItem(scrapy.Item):
"""一只股票的一条行情记录。"""
seq = scrapy.Field() # 序号
stock_no = scrapy.Field() # 股票代码,如 600000
stock_name = scrapy.Field() # 股票名称,如 浦发银行
latest_price = scrapy.Field() # 最新报价
change_percent = scrapy.Field() # 涨跌幅(%)
change_amount = scrapy.Field() # 涨跌额
volume = scrapy.Field() # 成交量(手)
amplitude = scrapy.Field() # 振幅(%)
high = scrapy.Field() # 最高
low = scrapy.Field() # 最低
open_price = scrapy.Field() # 今开
prev_close = scrapy.Field() # 昨收
detail_title = scrapy.Field() # 个股页 <title>,由 XPath 解析得到,用于校验名称
crawl_time = scrapy.Field() # 采集时间
Spider 实现(含主备数据源切换与个股页 XPath 校验):
"""作业②:股票行情爬虫(东方财富优先,接口不可用时自动切换备用行情接口)。
数据源说明:
1. 东方财富行情中心的列表页由 JavaScript 渲染,直接请求 HTML 只能拿到框架,
因此 Spider 请求页面自身调用的行情接口 push2.eastmoney.com/api/qt/clist/get;
2. 行情接口偶发 502(服务端波动),Spider 在 errback 与解析为空时自动切换到
新浪财经的沪深 A 股行情接口作为备用数据源,保证任务可重复运行;
3. 两种数据源解析出的字段完全一致,后续 Pipeline、MySQL 表结构不受影响;
4. 个股页 quote.eastmoney.com/sz000001.html 是服务端渲染的 HTML,
用 XPath 解析 <title> 校验“股票名称(股票代码)”,体现 Scrapy + XPath 的解析方式。
"""
from __future__ import annotations
import json
import re
from datetime import datetime
import scrapy
from stock_scrapy.items import StockItem
# 东方财富行情接口
EM_API = "http://push2.eastmoney.com/api/qt/clist/get"
EM_MARKET = "m:0+t:6,m:0+t:80,m:1+t:2,m:1+t:23"
EM_FIELDS = "f2,f3,f4,f5,f7,f12,f14,f15,f16,f17,f18"
# 备用数据源:新浪财经沪深 A 股行情接口
SINA_API = ("http://vip.stock.finance.sina.com.cn/quotes_service/api/json_v2.php/"
"Market_Center.getHQNodeData?page={page}&num={num}&sort=changepercent&asc=0&node=hs_a")
def market_prefix(code: str) -> str | None:
"""根据股票代码判断交易所前缀,用于拼接个股页地址。"""
if code.startswith(("60", "68", "90")):
return "sh"
if code.startswith(("00", "30", "20")):
return "sz"
return None
def to_float(value, default: float = 0.0) -> float:
"""把接口中的字符串数字转成 float,空值或 '-' 返回默认值。"""
if value in (None, "", "-"):
return default
try:
return float(value)
except (TypeError, ValueError):
return default
class EastmoneyStockSpider(scrapy.Spider):
"""抓取沪深 A 股行情:东方财富接口优先,失败时切换新浪行情接口。"""
name = "eastmoney_stock"
allowed_domains = ["eastmoney.com", "sina.com.cn"]
def __init__(self, pages: int = 3, page_size: int = 20, *args, **kwargs):
super().__init__(*args, **kwargs)
self.pages = int(pages)
self.page_size = int(page_size)
self.seq = 0
self.source = "eastmoney"
def start_requests(self):
"""按页请求东方财富行情接口。"""
for page in range(1, self.pages + 1):
url = (f"{EM_API}?pn={page}&pz={self.page_size}&po=1&np=1&fltt=2&invt=2"
f"&fid=f3&fs={EM_MARKET}&fields={EM_FIELDS}")
yield scrapy.Request(
url, callback=self.parse_api, cb_kwargs={"page": page},
errback=self.em_failed, dont_filter=True,
)
# ------------------------- 东方财富 -------------------------
def parse_api(self, response, page):
"""解析东方财富接口 JSON;没有数据时切换到备用数据源。"""
try:
payload = json.loads(response.text)
except json.JSONDecodeError:
payload = {}
rows = (payload.get("data") or {}).get("diff") or []
if not rows:
self.logger.warning("东方财富第 %s 页无数据(HTTP %s),切换备用数据源", page, response.status)
self.source = "sina"
yield scrapy.Request(
SINA_API.format(page=page, num=self.page_size),
callback=self.parse_sina, cb_kwargs={"page": page}, dont_filter=True,
)
return
self.logger.info("东方财富第 %s 页返回 %s 条", page, len(rows))
for row in rows:
self.seq += 1
code = str(row.get("f12", "")).strip()
item = StockItem(
seq=self.seq,
stock_no=code,
stock_name=str(row.get("f14", "")).strip(),
latest_price=to_float(row.get("f2")),
change_percent=to_float(row.get("f3")),
change_amount=to_float(row.get("f4")),
volume=to_float(row.get("f5")),
amplitude=to_float(row.get("f7")),
high=to_float(row.get("f15")),
low=to_float(row.get("f16")),
open_price=to_float(row.get("f17")),
prev_close=to_float(row.get("f18")),
detail_title="",
crawl_time=datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
)
yield from self.follow_detail(item)
def em_failed(self, failure):
"""东方财富接口请求失败(如 502)时,改用备用数据源。"""
page = failure.request.cb_kwargs.get("page", 1)
self.logger.warning("东方财富接口请求失败(%s),第 %s 页切换备用数据源",
failure.value, page)
self.source = "sina"
yield scrapy.Request(
SINA_API.format(page=page, num=self.page_size),
callback=self.parse_sina, cb_kwargs={"page": page}, dont_filter=True,
)
# ------------------------- 备用数据源 -------------------------
def parse_sina(self, response, page):
"""解析新浪行情接口 JSON 并换算为作业要求的 12 个字段。"""
try:
rows = json.loads(response.text)
except json.JSONDecodeError:
self.logger.error("备用数据源第 %s 页解析失败", page)
return
self.logger.info("备用数据源第 %s 页返回 %s 条", page, len(rows))
for row in rows:
self.seq += 1
settlement = to_float(row.get("settlement")) # 昨收
high = to_float(row.get("high"))
low = to_float(row.get("low"))
amplitude = round((high - low) / settlement * 100, 2) if settlement else 0.0
volume = round(to_float(row.get("volume")) / 100, 2) # 股 -> 手
item = StockItem(
seq=self.seq,
stock_no=str(row.get("code", "")).strip(),
stock_name=str(row.get("name", "")).strip(),
latest_price=to_float(row.get("trade")),
change_percent=to_float(row.get("changepercent")),
change_amount=to_float(row.get("pricechange")),
volume=volume,
amplitude=amplitude,
high=high,
low=low,
open_price=to_float(row.get("open")),
prev_close=settlement,
detail_title="",
crawl_time=datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
)
yield from self.follow_detail(item)
# ------------------------- 个股页 XPath 校验 -------------------------
def follow_detail(self, item):
"""请求个股页,用 XPath 解析 <title> 校验名称;无对应交易所则直接返回 Item。"""
prefix = market_prefix(item["stock_no"])
if not prefix:
yield item
return
yield scrapy.Request(
f"http://quote.eastmoney.com/{prefix}{item['stock_no']}.html",
callback=self.parse_detail,
cb_kwargs={"item": item},
errback=self.detail_failed,
dont_filter=True,
)
def parse_detail(self, response, item):
"""XPath 取个股页标题,形如“平安银行(000001)_最新价格_行情_走势图—东方财富网”。"""
titles = response.xpath("//title/text()").getall()
title = titles[0].strip() if titles else ""
item["detail_title"] = title
matched = re.search(r"^(.+?)\((\d{6})\)", title)
if matched and matched.group(2) == item["stock_no"]:
item["stock_name"] = matched.group(1).strip()
yield item
def detail_failed(self, failure):
"""个股页失败时保留行情数据,不中断整条记录。"""
self.logger.debug("个股页请求失败:%s", failure.request.url)
yield failure.request.cb_kwargs["item"]
Pipeline 实现(JSON 序列化 + MySQL 入库):
"""作业②:股票数据的 Pipeline。
包含两个 Pipeline:
StockJsonPipeline —— 演示 Item 的序列化输出,把每条 Item 写成 JSON 行;
StockMySQLPipeline —— 把 Item 写入 MySQL,表结构由 Pipeline 自动创建。
数据库连接信息集中在 settings.py 中,便于修改。
"""
from __future__ import annotations
import json
from pathlib import Path
import pymysql
from itemadapter import ItemAdapter
ROOT = Path(__file__).resolve().parent.parent
DATA_DIR = ROOT / "output"
# 建表语句:字段按作业要求的 12 列设计,另加采集时间
CREATE_TABLE_SQL = """
CREATE TABLE IF NOT EXISTS stock_quote (
id INT AUTO_INCREMENT PRIMARY KEY COMMENT '序号',
bStockNo VARCHAR(10) NOT NULL COMMENT '股票代码',
bStockName VARCHAR(32) NOT NULL COMMENT '股票名称',
bLatestPrice DECIMAL(12,3) DEFAULT NULL COMMENT '最新报价',
bChangeRate DECIMAL(12,3) DEFAULT NULL COMMENT '涨跌幅(%)',
bChangeAmount DECIMAL(12,3) DEFAULT NULL COMMENT '涨跌额',
bVolume DECIMAL(18,2) DEFAULT NULL COMMENT '成交量(手)',
bAmplitude DECIMAL(12,3) DEFAULT NULL COMMENT '振幅(%)',
bHigh DECIMAL(12,3) DEFAULT NULL COMMENT '最高',
bLow DECIMAL(12,3) DEFAULT NULL COMMENT '最低',
bOpen DECIMAL(12,3) DEFAULT NULL COMMENT '今开',
bPrevClose DECIMAL(12,3) DEFAULT NULL COMMENT '昨收',
dCrawlTime DATETIME NOT NULL COMMENT '采集时间',
UNIQUE KEY uniq_stock (bStockNo),
KEY idx_name (bStockName)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='作业②东方财富股票行情'
"""
INSERT_SQL = """
INSERT INTO stock_quote
(bStockNo, bStockName, bLatestPrice, bChangeRate, bChangeAmount,
bVolume, bAmplitude, bHigh, bLow, bOpen, bPrevClose, dCrawlTime)
VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
ON DUPLICATE KEY UPDATE
bStockName = VALUES(bStockName),
bLatestPrice = VALUES(bLatestPrice),
bChangeRate = VALUES(bChangeRate),
bChangeAmount = VALUES(bChangeAmount),
bVolume = VALUES(bVolume),
bAmplitude = VALUES(bAmplitude),
bHigh = VALUES(bHigh),
bLow = VALUES(bLow),
bOpen = VALUES(bOpen),
bPrevClose = VALUES(bPrevClose),
dCrawlTime = VALUES(dCrawlTime)
"""
class StockJsonPipeline:
"""把 Item 序列化为 JSON 文件,方便与数据库结果对照。"""
def open_spider(self, spider):
DATA_DIR.mkdir(parents=True, exist_ok=True)
self.records: list[dict] = []
def process_item(self, item, spider):
self.records.append(dict(ItemAdapter(item)))
return item
def close_spider(self, spider):
target = DATA_DIR / "stock_items.json"
target.write_text(json.dumps(self.records, ensure_ascii=False, indent=2), encoding="utf-8")
spider.logger.info("JSON 序列化完成:%s 条 -> %s", len(self.records), target)
class StockMySQLPipeline:
"""把 Item 写入 MySQL(存在则更新),表不存在时自动创建。"""
def __init__(self, host, port, user, password, database):
self.host = host
self.port = port
self.user = user
self.password = password
self.database = database
self.conn = None
self.cursor = None
self.count = 0
@classmethod
def from_crawler(cls, crawler):
settings = crawler.settings
return cls(
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", ""),
database=settings.get("MYSQL_DB", "homework3"),
)
def open_spider(self, spider):
self.conn = pymysql.connect(
host=self.host, port=self.port, user=self.user, password=self.password,
database=self.database, charset="utf8mb4", autocommit=True,
)
self.cursor = self.conn.cursor()
self.cursor.execute(CREATE_TABLE_SQL)
spider.logger.info("MySQL 连接成功,目标库 %s,表 stock_quote 已就绪", self.database)
def process_item(self, item, spider):
adapter = ItemAdapter(item)
values = (
adapter["stock_no"], adapter["stock_name"], adapter["latest_price"],
adapter["change_percent"], adapter["change_amount"], adapter["volume"],
adapter["amplitude"], adapter["high"], adapter["low"],
adapter["open_price"], adapter["prev_close"], adapter["crawl_time"],
)
self.cursor.execute(INSERT_SQL, values)
self.count += 1
return item
def close_spider(self, spider):
if self.cursor:
self.cursor.execute("SELECT COUNT(*) FROM stock_quote")
total = self.cursor.fetchone()[0]
spider.logger.info("MySQL 写入完成:本次 %s 条,表中累计 %s 条", self.count, total)
if self.conn:
self.conn.close()
Pipeline 与数据库配置(settings.py 片段):
ITEM_PIPELINES = {
"stock_scrapy.pipelines.StockJsonPipeline": 200, # 先序列化
"stock_scrapy.pipelines.StockMySQLPipeline": 300, # 再入库
}
MYSQL_HOST = "127.0.0.1"
MYSQL_PORT = 3306
MYSQL_USER = "root"
MYSQL_PASSWORD = "123456"
MYSQL_DB = "homework3"
表结构(由 Pipeline 自动创建):
CREATE TABLE IF NOT EXISTS stock_quote (
id INT AUTO_INCREMENT PRIMARY KEY COMMENT '序号',
bStockNo VARCHAR(10) NOT NULL COMMENT '股票代码',
bStockName VARCHAR(32) NOT NULL COMMENT '股票名称',
bLatestPrice DECIMAL(12,3) DEFAULT NULL COMMENT '最新报价',
bChangeRate DECIMAL(12,3) DEFAULT NULL COMMENT '涨跌幅(%)',
bChangeAmount DECIMAL(12,3) DEFAULT NULL COMMENT '涨跌额',
bVolume DECIMAL(18,2) DEFAULT NULL COMMENT '成交量(手)',
bAmplitude DECIMAL(12,3) DEFAULT NULL COMMENT '振幅(%)',
bHigh DECIMAL(12,3) DEFAULT NULL COMMENT '最高',
bLow DECIMAL(12,3) DEFAULT NULL COMMENT '最低',
bOpen DECIMAL(12,3) DEFAULT NULL COMMENT '今开',
bPrevClose DECIMAL(12,3) DEFAULT NULL COMMENT '昨收',
dCrawlTime DATETIME NOT NULL COMMENT '采集时间',
UNIQUE KEY uniq_stock (bStockNo)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
运行与结果。 抓取 3 页、每页 20 只,共 60 条记录入库;Scrapy 日志中可以看到东方财富接口 3 次 502 后自动切换备用数据源,最终 60 条全部写入,bStockNo 唯一、无重复名称。
python run_stock.py --pages 3


(二)作业③:中国银行外汇牌价采集
页面与 XPath。 中国银行外汇牌价页 https://www.boc.cn/sourcedb/whpj/ 是服务端渲染的 HTML 表格,正好可以用 Scrapy + XPath 直接解析。页面上有多张表格,先定位“表头含‘货币名称’”的那一张,再取其中的数据行,避免误取布局用的表格:
rows = response.xpath("//table[.//th[contains(normalize-space(.), '货币名称')]]//tr")
每行有 8 个单元格,顺序为:货币名称、现汇买入价、现钞买入价、现汇卖出价、现钞卖出价、中行折算价、发布日期(含时间)、发布时间。作业要求的 6 列对应关系为:Currency=货币名称、TBP=现汇买入价、CBP=现钞买入价、TSP=现汇卖出价、CSP=现钞卖出价、Time=发布时间。部分币种(如林吉特、越南盾)银行只公布部分价格,空缺单元格保留为空字符串,不做补零,避免把“没有报价”误当成“报价为 0”。
Item 定义:
"""作业③:外汇牌价数据项定义。
字段与作业输出表头对应:
Currency(货币名称)、TBP(现汇买入价)、CBP(现钞买入价)、
TSP(现汇卖出价)、CSP(现钞卖出价)、Time(发布时间)。
"""
import scrapy
class ForexItem(scrapy.Item):
"""一条外汇牌价记录。"""
currency = scrapy.Field() # 货币名称
tbp = scrapy.Field() # 现汇买入价
cbp = scrapy.Field() # 现钞买入价
tsp = scrapy.Field() # 现汇卖出价
csp = scrapy.Field() # 现钞卖出价
quote_time = scrapy.Field() # 发布时间 HH:MM:SS
quote_date = scrapy.Field() # 发布日期 YYYY-MM-DD
crawl_time = scrapy.Field() # 采集时间
Spider 实现(XPath 定位表格与逐行解析):
"""作业③:中国银行外汇牌价爬虫。
页面:https://www.boc.cn/sourcedb/whpj/
页面是服务端渲染的 HTML 表格,因此可以直接用 Scrapy + XPath 解析:
1. 用 XPath 选中“货币名称”表头所在的表格,再取其下所有数据行;
2. 每行 8 个单元格:货币名称、现汇买入价、现钞买入价、现汇卖出价、
现钞卖出价、中行折算价、发布日期(含时间)、发布时间;
3. 依次生成 ForexItem,交给 Pipeline 序列化为 JSON 并写入 MySQL。
"""
from __future__ import annotations
from datetime import datetime
import scrapy
from boc_scrapy.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 定位表格行,逐行解析 6 个业务字段。"""
# 先找到含“货币名称”表头的表格,避免误取页面上的其它表格
rows = response.xpath("//table[.//th[contains(normalize-space(.), '货币名称')]]//tr")
self.logger.info("XPath 匹配到 %s 行(含表头)", len(rows))
count = 0
for row in rows:
cells = row.xpath("./td")
if len(cells) < 8: # 表头行或空行没有 8 个 td
continue
texts = [cell.xpath("string(.)").get(default="").strip() for cell in cells]
currency = texts[0]
if not currency:
continue
count += 1
publisher = texts[6] # 形如 2026/11/19 23:48:35
quote_date = publisher.split(" ")[0].replace("/", "-") if publisher else ""
yield ForexItem(
currency=currency,
tbp=texts[1],
cbp=texts[2],
tsp=texts[3],
csp=texts[4],
quote_time=texts[7],
quote_date=quote_date,
crawl_time=datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
)
self.logger.info("共解析出 %s 条外汇牌价", count)
Pipeline 实现(JSON 序列化 + MySQL 入库,按“币种 + 日期 + 时间”去重):
"""作业③:外汇牌价的 Pipeline。
ForexJsonPipeline —— Item 序列化输出为 JSON 文件;
ForexMySQLPipeline —— 写入 MySQL 表 forex_rate,自动建表、按“币种+日期+时间”去重。
"""
from __future__ import annotations
import json
from pathlib import Path
import pymysql
from itemadapter import ItemAdapter
ROOT = Path(__file__).resolve().parent.parent
DATA_DIR = ROOT / "output"
CREATE_TABLE_SQL = """
CREATE TABLE IF NOT EXISTS forex_rate (
id INT AUTO_INCREMENT PRIMARY KEY COMMENT '序号',
cCurrency VARCHAR(32) NOT NULL COMMENT '货币名称',
cTBP VARCHAR(16) DEFAULT NULL COMMENT '现汇买入价',
cCBP VARCHAR(16) DEFAULT NULL COMMENT '现钞买入价',
cTSP VARCHAR(16) DEFAULT NULL COMMENT '现汇卖出价',
cCSP VARCHAR(16) DEFAULT NULL COMMENT '现钞卖出价',
cTime VARCHAR(12) DEFAULT NULL COMMENT '发布时间',
dDate DATE DEFAULT NULL COMMENT '发布日期',
dCrawlTime DATETIME NOT NULL COMMENT '采集时间',
UNIQUE KEY uniq_currency (cCurrency, dDate, cTime)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='作业③中国银行外汇牌价'
"""
INSERT_SQL = """
INSERT INTO forex_rate
(cCurrency, cTBP, cCBP, cTSP, cCSP, cTime, dDate, dCrawlTime)
VALUES (%s, %s, %s, %s, %s, %s, %s, %s)
ON DUPLICATE KEY UPDATE
cTBP = VALUES(cTBP),
cCBP = VALUES(cCBP),
cTSP = VALUES(cTSP),
cCSP = VALUES(cCSP),
dCrawlTime = VALUES(dCrawlTime)
"""
class ForexJsonPipeline:
"""把 Item 序列化成 JSON,便于对照与备份。"""
def open_spider(self, spider):
DATA_DIR.mkdir(parents=True, exist_ok=True)
self.records: list[dict] = []
def process_item(self, item, spider):
self.records.append(dict(ItemAdapter(item)))
return item
def close_spider(self, spider):
target = DATA_DIR / "forex_items.json"
target.write_text(json.dumps(self.records, ensure_ascii=False, indent=2), encoding="utf-8")
spider.logger.info("JSON 序列化完成:%s 条 -> %s", len(self.records), target)
class ForexMySQLPipeline:
"""把 Item 写入 MySQL 表 forex_rate。"""
def __init__(self, host, port, user, password, database):
self.host = host
self.port = port
self.user = user
self.password = password
self.database = database
self.conn = None
self.cursor = None
self.count = 0
@classmethod
def from_crawler(cls, crawler):
settings = crawler.settings
return cls(
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", ""),
database=settings.get("MYSQL_DB", "homework3"),
)
def open_spider(self, spider):
self.conn = pymysql.connect(
host=self.host, port=self.port, user=self.user, password=self.password,
database=self.database, charset="utf8mb4", autocommit=True,
)
self.cursor = self.conn.cursor()
self.cursor.execute(CREATE_TABLE_SQL)
spider.logger.info("MySQL 连接成功,目标库 %s,表 forex_rate 已就绪", self.database)
def process_item(self, item, spider):
adapter = ItemAdapter(item)
self.cursor.execute(INSERT_SQL, (
adapter["currency"], adapter["tbp"], adapter["cbp"], adapter["tsp"],
adapter["csp"], adapter["quote_time"], adapter["quote_date"] or None,
adapter["crawl_time"],
))
self.count += 1
return item
def close_spider(self, spider):
if self.cursor:
self.cursor.execute("SELECT COUNT(*) FROM forex_rate")
total = self.cursor.fetchone()[0]
spider.logger.info("MySQL 写入完成:本次 %s 条,表中累计 %s 条", self.count, total)
if self.conn:
self.conn.close()
运行与结果。 一次抓取到 45 个币种的牌价,全部写入 forex_rate 表;同一币种同一天同一发布时间重复抓取时,ON DUPLICATE KEY UPDATE 只更新时间戳,不会产生重复行。
python run_forex.py



2.2 实验心得
这次作业最大的收获是把“Item → Pipeline → 数据库”这条链路真正跑通了。以前写爬虫习惯在一个脚本里 requests + print,数据用完就没了;这次用 Scrapy 的 Item 统一字段,再用两个 Pipeline 分别做 JSON 序列化和 MySQL 入库,同一份数据既可以留档比对,也能直接用 SQL 聚合查询,结构清晰很多。from_crawler 读取 settings.py 里的数据库配置,也让密码、库名不必写死在 Pipeline 里。
第二个体会是“数据源要当作会失效的东西来设计”。东方财富的行情接口在实验时段一直 502,如果 Spider 只写一条数据链路,这次作业就完全跑不出结果。我把它改成主数据源失败后自动切换备用数据源,两条链路解析出同样的 Item,表结构不变。这个过程很像真实工程:接口不可用是常态,爬虫要能降级、能重试、能说明自己取的是哪一份数据。
第三个体会是 XPath 的“定位要精确到表头”。中国银行页面上有四张表格,如果直接用 //table[2] 这种位置下标,页面一改版就错位;改成“表头包含‘货币名称’的表格”之后,即使表格顺序变化也能命中。同理,股票任务的个股页用 <title> 校验名称与代码,比只信接口返回的名称更稳妥。
另外两个细节值得记录:一是 Scrapy 2.13 已经推荐用 start() 代替 start_requests(),旧写法会给出弃用警告,但为了兼容低版本我保留了 start_requests();二是 MySQL 建表时给股票代码加了唯一键,配合 ON DUPLICATE KEY UPDATE 实现“重复抓取只更新不重复插入”,比每次先 TRUNCATE 更安全。
最后是展示层面的问题:把 MySQL 结果打印成等宽文本时,中文字符占两列宽度,不处理就会错位。我在打印函数里用 unicodedata.east_asian_width 计算显示宽度再补空格,表格才对齐;博客里的数据库截图则是用表格控件直接渲染 MySQL 查询结果,比终端文本更清楚。
附:代码仓库结构与复现步骤
按课程“每次作业一个文件夹”的要求,本次作业在码云仓库中的目录结构如下(完整源码见文末仓库链接):
第三次作业/
├── 1_图片爬取/
│ ├── image_crawler.py # 单线程 / 多线程图片爬虫
│ ├── images/ # 126 张下载结果
│ └── output/ # report_single.json、report_multi.json
├── 2_股票爬虫/
│ └── stock_scrapy/
│ ├── scrapy.cfg
│ ├── run_stock.py # 运行入口,打印 MySQL 结果
│ ├── output/ # stock_items.json、console_run.txt
│ └── stock_scrapy/
│ ├── items.py
│ ├── pipelines.py
│ ├── settings.py
│ └── spiders/eastmoney_stock.py
└── 3_外汇爬虫/
└── boc_scrapy/
├── scrapy.cfg
├── run_forex.py
├── output/ # forex_items.json、console_run.txt
└── boc_scrapy/
├── items.py
├── pipelines.py
├── settings.py
└── spiders/boc_forex.py
Gitee 仓库链接:【在此粘贴你的码云仓库地址,例如 https://gitee.com/xxx/data-collection-homework 】
复现步骤:
# 作业①
cd 第三次作业/1_图片爬取
python image_crawler.py --mode single
python image_crawler.py --mode multi --workers 8
# 作业②(需先启动本机 MySQL,并建库 homework3)
cd 第三次作业/2_股票爬虫/stock_scrapy
python run_stock.py --pages 3
# 作业③
cd 第三次作业/3_外汇爬虫/boc_scrapy
python run_forex.py

浙公网安备 33010602011771号