数据采集第二次作业:天气预报、股票行情与大学排名采集
数据采集实验二:天气预报、股票行情与大学排名采集
学号姓名:102580109熊晨昉
完成日期:2026-11-07
运行环境:Windows 11 + Python 3.13 + requests + BeautifulSoup4 + SQLite
本次实验完成三项数据采集任务:用 requests + BeautifulSoup 抓取中国气象网福建八市的
最近 7 日天气预报、用 requests + json 抓取股票行情、用 requests + json 抓取软科
2021 中国大学排名榜单,三者都清洗后写入 SQLite 数据库,并做了简单的数据可视化。
目录
一、任务①②:福建八市天气与股票行情数据采集
1.1 作业代码与运行结果
1.1.1 实验环境、项目结构与公共模块
实验环境
| 项目 | 版本 / 说明 |
|---|---|
| 操作系统 | Windows 11 |
| Python | 3.13.9 |
| 请求库 | requests 2.32 |
| 解析库 | BeautifulSoup4 4.14 + lxml |
| 数据库 | SQLite 3(Python 标准库 sqlite3 自带,无需安装数据库服务) |
| 可视化 | matplotlib 3.10 |
项目结构
实验二/
├── config.py # 公共配置:URL、城市编码、字段映射、路径
├── utils.py # 公共工具:中文等宽表格输出、数值清洗
├── db.py # 数据库:建表 + 三个任务的批量写入
├── weather_spider.py # 任务①:福建八市 7 日天气
├── stock_spider.py # 任务②:股票行情(requests + json)
├── university_spider.py # 任务③:软科 2021 大学排名
├── run_all.py # 一键运行三个任务
├── make_images.py # 生成博客配图(运行截图、图表、抓包 GIF)
├── build_blog.py # 由模板生成博客(把真实源码/统计填进占位符)
├── data/spider.db # SQLite 数据库文件
├── output/ # 导出的 csv 与原始 JSON
└── images/ # 博客配图
三个任务共用一套"配置 - 工具 - 数据库"分层:抓取逻辑写在各自的 *_spider.py 中,
建表与写入集中在 db.py,公共常量集中在 config.py,这样改接口、换数据库只需要动一处。
运行方式
pip install -r requirements.txt # 安装依赖
python run_all.py # 依次运行三个任务
python weather_spider.py # 也可以单独运行某一个任务
python stock_spider.py
python university_spider.py
python make_images.py # 重新生成博客配图(会真跑一遍爬虫)
python build_blog.py # 由模板重新生成博客
运行后会在 data/ 下生成 spider.db,在 output/ 下生成三个 csv 明细文件与原始 JSON
样本,在 images/ 下生成全部配图。
公共配置 config.py
# -*- coding: utf-8 -*-
"""实验二 公共配置模块。
集中存放三个任务的请求地址、请求参数、城市编码、数据库与输出目录等常量,
避免在业务代码中散落"魔法值",方便后续维护与扩展。
"""
from pathlib import Path
# --------------------------------------------------------------------------- #
# 路径
# --------------------------------------------------------------------------- #
BASE_DIR = Path(__file__).resolve().parent # 项目根目录
DATA_DIR = BASE_DIR / "data" # 数据库目录
OUTPUT_DIR = BASE_DIR / "output" # 导出的 csv / json
IMAGE_DIR = BASE_DIR / "images" # 运行截图与图表
DB_PATH = DATA_DIR / "spider.db" # SQLite 数据库文件
# --------------------------------------------------------------------------- #
# 通用请求参数
# --------------------------------------------------------------------------- #
# 浏览器 UA:部分站点会拦截 python-requests 默认 UA
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-Language": "zh-CN,zh;q=0.9",
}
REQUEST_TIMEOUT = 15 # 单次请求超时(秒)
REQUEST_RETRY = 3 # 请求失败重试次数
REQUEST_INTERVAL = 1.0 # 相邻请求间隔(秒),礼貌爬取,避免给服务器造成压力
# --------------------------------------------------------------------------- #
# 任务① 中国气象网 —— 福建八市最近 7 日天气预报
# --------------------------------------------------------------------------- #
# 中国气象网的城市编码规则:101 + 省份代码(23=福建) + 地级市序号(01~09) + 01(区县)
WEATHER_URL = "http://www.weather.com.cn/weather/{city_code}.shtml"
PROVINCE = "福建"
FORECAST_DAYS = 7 # 采集天数:最近 7 日
# 福建共有 9 个地级市,任务要求"八市",此处采集其中 8 个;
# 若需补齐宁德,取消下面最后一行的注释即可(宁德 101230301)。
FUJIAN_CITIES = {
"福州": "101230101",
"厦门": "101230201",
"莆田": "101230401",
"泉州": "101230501",
"漳州": "101230601",
"龙岩": "101230701",
"三明": "101230801",
"南平": "101230901",
# "宁德": "101230301",
}
# --------------------------------------------------------------------------- #
# 任务② 东方财富网 —— 沪深 A 股行情数据(requests + json)
# --------------------------------------------------------------------------- #
STOCK_LIST_URL = "https://push2.eastmoney.com/api/qt/clist/get"
STOCK_PAGE_SIZE = 100 # 每页条数(接口上限一般 100)
STOCK_MAX_PAGES = 5 # 最多翻 5 页,即抓取 500 只股票,可按需调整
# 市场筛选:深主板 / 创业板 / 沪主板 / 科创板
STOCK_MARKET_FILTER = "m:0+t:6,m:0+t:80,m:1+t:2,m:1+t:23"
STOCK_SORT_FIELD = "f3" # 排序字段:f3 = 涨跌幅
# 需要请求的字段,字段含义见 STOCK_FIELD_MAP
STOCK_FIELDS = (
"f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f12,f13,f14,f15,"
"f16,f17,f18,f20,f21,f23,f24,f25"
)
# 接口字段 → 数据库字段(字段含义来自 F12 抓包分析)
STOCK_FIELD_MAP = {
"f12": "stock_code", # 股票代码
"f14": "stock_name", # 股票名称
"f2": "latest_price", # 最新价
"f3": "change_pct", # 涨跌幅(%)
"f4": "change_amount", # 涨跌额
"f5": "volume", # 成交量(手)
"f6": "amount", # 成交额(元)
"f7": "amplitude", # 振幅(%)
"f8": "turnover_rate", # 换手率(%)
"f9": "pe_dynamic", # 市盈率(动态)
"f10": "volume_ratio", # 量比
"f15": "high_price", # 最高价
"f16": "low_price", # 最低价
"f17": "open_price", # 今开
"f18": "prev_close", # 昨收
"f20": "total_market_cap", # 总市值(元)
"f21": "circulating_market_cap", # 流通市值(元)
"f23": "pb", # 市净率
"f24": "change_60d", # 近 60 日涨跌幅(%)
"f25": "change_ytd", # 年初至今涨跌幅(%)
}
# --------------------------------------------------------------------------- #
# 任务③ 软科 —— 2021 中国大学排名(主榜)
# --------------------------------------------------------------------------- #
RANK_URL = "https://www.shanghairanking.cn/api/pub/v1/bcur"
RANK_YEAR = 2021
RANK_TYPE = 11 # 11 = 主榜(中国大学排名主榜)
# 排行榜页面地址,作为 Referer 使用,否则接口可能返回 403
RANK_REFERER = f"https://www.shanghairanking.cn/rankings/bcur/{RANK_YEAR}"
公共工具 utils.py
说明:终端里中文占 2 个字符宽度、英文占 1 个,直接用
ljust对齐会错位。
display_width()用unicodedata.east_asian_width计算真实显示宽度,
format_table()据此生成对齐的表格,运行截图中的表格就是这样来的。
# -*- coding: utf-8 -*-
"""通用工具模块。
提供两类工具:
1. 控制台输出工具:按"显示宽度"对齐中文表格(中文占 2 列,英文占 1 列);
2. 数据清洗工具:把接口返回的 "-"、"" 等无效值统一转换为 None,
以及把金额、时间等格式化为便于阅读的中文单位。
"""
import sys
import unicodedata
from datetime import datetime
def setup_console():
"""避免 Windows 控制台因编码问题抛出 UnicodeEncodeError。
仅把无法编码的字符替换掉,不改变原有编码设置(GBK / UTF-8 均可)。
"""
for stream in (sys.stdout, sys.stderr):
if hasattr(stream, "reconfigure"):
try:
stream.reconfigure(errors="replace")
except (ValueError, OSError): # 某些重定向场景下不支持
pass
def display_width(text):
"""计算字符串在等宽终端中的显示宽度:全角字符计 2,半角字符计 1。"""
return sum(2 if unicodedata.east_asian_width(ch) in "WFA" else 1
for ch in str(text))
def pad(text, width, align="left"):
"""按显示宽度把字符串补齐到指定宽度。"""
text = "" if text is None else str(text)
space = max(0, width - display_width(text))
if align == "right":
return " " * space + text
if align == "center":
left = space // 2
return " " * left + text + " " * (space - left)
return text + " " * space
def format_table(headers, rows, aligns=None, title=None):
"""把二维数据渲染成等宽文本表格。
:param headers: 表头列表,如 ["城市", "日期", "天气"]
:param rows: 数据行,元素为列表 / 元组
:param aligns: 每列的对齐方式,"left" 或 "right"
:param title: 表格标题,可为空
:return: 可直接 print 的多行字符串
"""
headers = [str(h) for h in headers]
rows = [[("" if cell is None else str(cell)) for cell in row] for row in rows]
aligns = aligns or ["left"] * len(headers)
widths = [display_width(h) for h in headers]
for row in rows:
for index, cell in enumerate(row[:len(widths)]):
widths[index] = max(widths[index], display_width(cell))
total_width = sum(widths) + 2 * (len(widths) - 1)
if title: # 标题比表格宽时,分隔线跟着标题走
total_width = max(total_width, display_width(" " + title))
sep = "-" * min(total_width, 120)
lines = []
if title:
lines.extend([sep, " " + title, sep])
else:
lines.append(sep)
lines.append(" ".join(pad(h, widths[i], "center")
for i, h in enumerate(headers)).rstrip())
lines.append(sep)
for row in rows:
line = " ".join(pad(cell, widths[i], aligns[i] if i < len(aligns) else "left")
for i, cell in enumerate(row))
lines.append(line.rstrip())
lines.append(sep)
return "\n".join(lines)
def clean_value(value):
"""清洗接口/页面的空值:'-'、'--'、'' 统一返回 None。"""
if value is None:
return None
if isinstance(value, str):
value = value.strip()
if value in ("", "-", "--", "None", "null"):
return None
return value
return value
def to_float(value):
"""把字符串安全转换为浮点数,失败返回 None。"""
value = clean_value(value)
if value is None:
return None
try:
return float(value)
except (TypeError, ValueError):
return None
def to_int(value):
"""把字符串安全转换为整数,失败返回 None。"""
value = clean_value(value)
if value is None:
return None
try:
return int(float(value))
except (TypeError, ValueError):
return None
def now_str():
"""返回当前时间字符串,精确到秒,用于记录抓取时间。"""
return datetime.now().strftime("%Y-%m-%d %H:%M:%S")
def weekday_cn(day):
"""把 date 对象转换为中文星期,如 2026-11-07 -> 周六。"""
return "周" + "一二三四五六日"[day.weekday()]
def money_to_yi(value):
"""把"元"为单位的金额转换为"亿元"字符串,便于阅读。"""
value = to_float(value)
if value is None:
return "-"
return f"{value / 1e8:.2f}亿"
数据库模块 db.py
数据库共 4 张表:3 张业务表 + 1 张抓取日志表。设计上有两个细节:
- 唯一约束:
weather_forecast用(city_code, forecast_date)唯一,
stock_info用股票代码做主键,university_rank用(year, university)唯一。
配合INSERT ... ON CONFLICT DO UPDATE,重复运行爬虫只会更新数据,不会产生重复行。 - 抓取日志:每次运行都往
crawl_log写一条记录(条数、状态、耗时),
方便回溯"哪天的数据是哪次抓的"。
# -*- coding: utf-8 -*-
"""SQLite 数据库模块。
职责:
1. 建库建表(三张业务表 + 一张抓取日志表);
2. 提供三个任务对应的批量写入函数,统一处理"重复运行"问题
(使用 ON CONFLICT DO UPDATE,重复执行不会产生重复数据);
3. 提供查询封装,供导出 csv、统计与生成图片使用。
为什么选 SQLite:Python 标准库自带 sqlite3,无需安装/启动数据库服务,
交作业时只需一个 .db 文件即可复现;若改用 MySQL,只需替换本模块的
连接与占位符(%s),建表语句的字段设计完全一致。
"""
import sqlite3
from config import DB_PATH
from utils import now_str
# --------------------------------------------------------------------------- #
# 建表语句
# --------------------------------------------------------------------------- #
SCHEMA = """
-- 任务①:福建八市最近 7 日天气预报
CREATE TABLE IF NOT EXISTS weather_forecast (
id INTEGER PRIMARY KEY AUTOINCREMENT,
province TEXT NOT NULL, -- 省份,如"福建"
city TEXT NOT NULL, -- 城市名,如"福州"
city_code TEXT NOT NULL, -- 中国气象网城市编码,如 101230101
forecast_date TEXT NOT NULL, -- 预报日期 YYYY-MM-DD
weekday TEXT, -- 星期,如"周六"
weather TEXT, -- 天气原文,如"阴转小雨"
weather_day TEXT, -- 白天天气,如"阴"
weather_night TEXT, -- 夜间天气,如"小雨"
temp_high REAL, -- 最高气温(℃),"今天"可能为空
temp_low REAL, -- 最低气温(℃)
wind_dir TEXT, -- 风向,如"北风转东北风"
wind_level TEXT, -- 风力,如"4-5级"
source_url TEXT, -- 数据来源地址
crawl_time TEXT NOT NULL, -- 抓取时间
UNIQUE (city_code, forecast_date) -- 同城同日只保留一条
);
-- 任务②:东方财富网沪深 A 股行情
CREATE TABLE IF NOT EXISTS stock_info (
stock_code TEXT PRIMARY KEY, -- 股票代码,如 600519
stock_name TEXT NOT NULL, -- 股票名称
market TEXT, -- 交易所:上交所/深交所
latest_price REAL, -- 最新价
change_pct REAL, -- 涨跌幅(%)
change_amount REAL, -- 涨跌额
volume REAL, -- 成交量(手)
amount REAL, -- 成交额(元)
amplitude REAL, -- 振幅(%)
turnover_rate REAL, -- 换手率(%)
pe_dynamic REAL, -- 市盈率(动态)
volume_ratio REAL, -- 量比
high_price REAL, -- 最高价
low_price REAL, -- 最低价
open_price REAL, -- 今开
prev_close REAL, -- 昨收
total_market_cap REAL, -- 总市值(元)
circulating_market_cap REAL, -- 流通市值(元)
pb REAL, -- 市净率
change_60d REAL, -- 近 60 日涨跌幅(%)
change_ytd REAL, -- 年初至今涨跌幅(%)
list_rank INTEGER, -- 接口返回顺序(按涨跌幅排序)
source TEXT, -- 数据来源:东方财富 / 新浪财经
crawl_time TEXT NOT NULL -- 抓取时间
);
-- 任务③:软科 2021 中国大学排名(主榜)
CREATE TABLE IF NOT EXISTS university_rank (
id INTEGER PRIMARY KEY AUTOINCREMENT,
year INTEGER NOT NULL, -- 榜单年份
ranking INTEGER, -- 排名
university TEXT NOT NULL, -- 学校名称(中文)
university_en TEXT, -- 学校名称(英文)
province TEXT, -- 省市
category TEXT, -- 办学类型,如"综合""理工"
score REAL, -- 总分
tags TEXT, -- 标签,如"双一流,985,211"
univ_slug TEXT, -- 英文标识,如 tsinghua-university
crawl_time TEXT NOT NULL, -- 抓取时间
UNIQUE (year, university) -- 同一年同一学校只保留一条
);
-- 抓取日志:记录每次任务执行的时间、条数与状态,便于回溯
CREATE TABLE IF NOT EXISTS crawl_log (
id INTEGER PRIMARY KEY AUTOINCREMENT,
task TEXT, -- 任务标识,如 weather / stock / university
table_name TEXT, -- 目标表名
row_count INTEGER, -- 本次写入条数
status TEXT, -- success / failed
message TEXT, -- 备注或异常信息
cost_second REAL, -- 耗时(秒)
crawl_time TEXT -- 执行时间
);
CREATE INDEX IF NOT EXISTS idx_weather_city_date
ON weather_forecast (city, forecast_date);
CREATE INDEX IF NOT EXISTS idx_rank_year_ranking
ON university_rank (year, ranking);
"""
def connect_db(db_path=DB_PATH):
"""连接 SQLite 数据库(文件不存在时自动创建),返回 Connection 对象。"""
db_path.parent.mkdir(parents=True, exist_ok=True)
conn = sqlite3.connect(db_path)
conn.row_factory = sqlite3.Row # 查询结果可以用列名访问
conn.execute("PRAGMA encoding = 'UTF-8'")
return conn
def init_db(conn):
"""执行建表语句(IF NOT EXISTS,可重复调用)。"""
conn.executescript(SCHEMA)
conn.commit()
# --------------------------------------------------------------------------- #
# 三个任务的写入函数
# --------------------------------------------------------------------------- #
def save_weather_rows(conn, rows):
"""批量写入天气预报,重复的(城市, 预报日期)执行更新。
:param rows: 字典列表,键名与 weather_forecast 字段一致
:return: 写入(或更新)的条数
"""
if not rows:
return 0
sql = """
INSERT INTO weather_forecast (
province, city, city_code, forecast_date, weekday, weather,
weather_day, weather_night, temp_high, temp_low,
wind_dir, wind_level, source_url, crawl_time
) VALUES (
:province, :city, :city_code, :forecast_date, :weekday, :weather,
:weather_day, :weather_night, :temp_high, :temp_low,
:wind_dir, :wind_level, :source_url, :crawl_time
)
ON CONFLICT (city_code, forecast_date) DO UPDATE SET
province = excluded.province,
city = excluded.city,
weekday = excluded.weekday,
weather = excluded.weather,
weather_day = excluded.weather_day,
weather_night = excluded.weather_night,
temp_high = excluded.temp_high,
temp_low = excluded.temp_low,
wind_dir = excluded.wind_dir,
wind_level = excluded.wind_level,
source_url = excluded.source_url,
crawl_time = excluded.crawl_time
"""
conn.executemany(sql, rows)
conn.commit()
return len(rows)
def save_stock_rows(conn, rows):
"""批量写入股票行情,以股票代码为主键做覆盖更新。
:param rows: 字典列表,键名与 stock_info 字段一致
:return: 写入(或更新)的条数
"""
if not rows:
return 0
columns = [
"stock_code", "stock_name", "market", "latest_price", "change_pct",
"change_amount", "volume", "amount", "amplitude", "turnover_rate",
"pe_dynamic", "volume_ratio", "high_price", "low_price", "open_price",
"prev_close", "total_market_cap", "circulating_market_cap", "pb",
"change_60d", "change_ytd", "list_rank", "source", "crawl_time",
]
placeholders = ", ".join(f":{column}" for column in columns)
updates = ", ".join(
f"{column} = excluded.{column}" for column in columns
if column != "stock_code"
)
sql = (
f"INSERT INTO stock_info ({', '.join(columns)}) "
f"VALUES ({placeholders}) "
f"ON CONFLICT (stock_code) DO UPDATE SET {updates}"
)
conn.executemany(sql, rows)
conn.commit()
return len(rows)
def save_university_rows(conn, rows):
"""批量写入大学排名,同一年的同一所学校执行更新。
:param rows: 字典列表,键名与 university_rank 字段一致
:return: 写入(或更新)的条数
"""
if not rows:
return 0
sql = """
INSERT INTO university_rank (
year, ranking, university, university_en, province,
category, score, tags, univ_slug, crawl_time
) VALUES (
:year, :ranking, :university, :university_en, :province,
:category, :score, :tags, :univ_slug, :crawl_time
)
ON CONFLICT (year, university) DO UPDATE SET
ranking = excluded.ranking,
university_en = excluded.university_en,
province = excluded.province,
category = excluded.category,
score = excluded.score,
tags = excluded.tags,
univ_slug = excluded.univ_slug,
crawl_time = excluded.crawl_time
"""
conn.executemany(sql, rows)
conn.commit()
return len(rows)
def log_crawl(conn, task, table_name, row_count, status,
message="", cost_second=0.0):
"""记录一次任务执行日志。"""
conn.execute(
"INSERT INTO crawl_log (task, table_name, row_count, status, message, "
"cost_second, crawl_time) VALUES (?, ?, ?, ?, ?, ?, ?)",
(task, table_name, row_count, status, message, round(cost_second, 3),
now_str()),
)
conn.commit()
# --------------------------------------------------------------------------- #
# 查询
# --------------------------------------------------------------------------- #
def fetch_all(conn, sql, params=()):
"""执行查询并把结果转换为字典列表。"""
cursor = conn.execute(sql, params)
return [dict(row) for row in cursor.fetchall()]
def count_rows(conn, table_name):
"""统计某张表的行数。"""
return conn.execute(f"SELECT COUNT(*) FROM {table_name}").fetchone()[0]
1.1.2 任务①:中国气象网福建八市最近 7 日天气预报
(1)需求拆解
- 对象:福建八市(福州、厦门、莆田、泉州、漳州、龙岩、三明、南平)。
福建实际有 9 个地级市,任务要求"八市",因此这里采集其中 8 个;
如需补齐宁德,在config.py的FUJIAN_CITIES里取消注释即可(宁德编码 101230301)。 - 内容:每市最近 7 天的日期、星期、天气、最高/最低气温、风向、风力。
- 落库:写入
weather_forecast表。
(2)网站结构与接口分析
中国气象网的城市编码规则是 101 + 省级代码 + 地级市序号 + 01,福建的省级代码是 23:
| 城市 | 城市编码 | 城市 | 城市编码 |
|---|---|---|---|
| 福州 | 101230101 | 龙岩 | 101230701 |
| 厦门 | 101230201 | 三明 | 101230801 |
| 莆田 | 101230401 | 南平 | 101230901 |
| 泉州 | 101230501 | 漳州 | 101230601 |
7 日预报页面是服务端渲染的静态页面,地址形如
http://www.weather.com.cn/weather/101230101.shtml,7 天的数据在 ul.t.clearfix
下的 7 个 li 里:
<ul class="t clearfix">
<li class="sky skyid lv3 on">
<h1>7日(今天)</h1>
<p title="阴" class="wea">阴</p>
<p class="tem"><i>20℃</i></p>
<p class="win">
<em><span title="东北风" class="NE"></span></em>
<i>4-5级</i>
</p>
</li>
<li class="sky skyid lv3">
<h1>8日(明天)</h1>
<p title="阴转小雨" class="wea">阴转小雨</p>
<p class="tem"><span>27℃</span>/<i>19℃</i></p>
...
</li>
</ul>
解析时有三个"坑":
- 页面只有"几日",没有年和月。若直接拼当前年份,遇到跨年(12 月 31 日预测
1 月 1 日)就会出错。解决办法是读页面隐藏域
<input id="fc_24h_internal_update_time" value="2026110720">,取前 8 位解析出
基准日期,再按序号往后推。 - "今天"的气温只有一个数。中国气象网在每天 20:00 之后不再显示当天的最高气温,
p.tem里只剩<i>20℃</i>。代码对此做了区分:只有<i>时记最低气温,
最高气温存NULL(表格里显示--),而不是拿当前温度冒充最高温。 - 风向藏在属性里。风向文字不在标签内容中,而在
<span title="东北风">的
title属性上;白天/夜间风向不同时有两个span,需要用"转"连接。
(3)完整代码
# -*- coding: utf-8 -*-
"""任务①:爬取中国气象网福建八市最近 7 日天气预报,并保存到数据库。
实现思路
--------
1. 中国气象网的 7 日预报是**服务端渲染**的静态页面,地址形如
http://www.weather.com.cn/weather/101230101.shtml
其中 101230101 是城市编码(101 + 省级代码 23 + 地级市序号 + 区县 01)。
2. 请求页面后用 BeautifulSoup 解析 `ul.t.clearfix` 下的 7 个 `li`,
每个 `li` 对应一天:h1=日期、p.wea=天气、p.tem=气温、p.win=风向风力。
3. 页面只给出"几日",年份月份需要从隐藏域 fc_24h_internal_update_time
(形如 2026110720)中解析,避免手工推算跨月出错。
4. 清洗后的数据既写入 SQLite 数据库,也导出 csv 方便查看。
运行:python weather_spider.py
"""
import csv
import re
import time
from datetime import datetime, timedelta
import requests
from bs4 import BeautifulSoup
from config import (FORECAST_DAYS, FUJIAN_CITIES, HEADERS, OUTPUT_DIR, PROVINCE,
REQUEST_INTERVAL, REQUEST_RETRY, REQUEST_TIMEOUT, WEATHER_URL)
from db import connect_db, count_rows, init_db, log_crawl, save_weather_rows
from utils import (format_table, now_str, setup_console, to_float, weekday_cn)
# --------------------------------------------------------------------------- #
# 1. 下载页面
# --------------------------------------------------------------------------- #
def fetch_page(city, city_code):
"""下载指定城市的 7 日天气页面,失败时按次数重试。
:param city: 城市名,仅用于日志输出
:param city_code: 中国气象网城市编码,如 101230101
:return: (页面地址, 页面 HTML 文本)
"""
url = WEATHER_URL.format(city_code=city_code)
for attempt in range(1, REQUEST_RETRY + 1):
try:
response = requests.get(url, headers=HEADERS, timeout=REQUEST_TIMEOUT)
response.raise_for_status()
# 中国气象网页面统一使用 UTF-8,显式指定避免 requests 猜错编码
response.encoding = "utf-8"
return url, response.text
except requests.RequestException as exc:
print(f" [重试 {attempt}/{REQUEST_RETRY}] {city} 页面获取失败:{exc}")
time.sleep(REQUEST_INTERVAL * attempt) # 退避等待,避免频繁请求
raise RuntimeError(f"{city}({city_code}) 页面获取失败,已重试 {REQUEST_RETRY} 次")
# --------------------------------------------------------------------------- #
# 2. 解析页面
# --------------------------------------------------------------------------- #
def parse_base_date(soup):
"""从隐藏域解析预报的基准日期(即"今天")。
页面隐藏域 fc_24h_internal_update_time 形如 "2026110720",
前 8 位就是预报更新日期;取不到时退化为系统当天日期。
"""
node = soup.find("input", id="fc_24h_internal_update_time")
if node and node.get("value") and len(node["value"]) >= 8:
try:
return datetime.strptime(node["value"][:8], "%Y%m%d").date()
except ValueError:
pass
return datetime.now().date()
def align_date(base_date, day_number, index):
"""把页面上的"X日"换算成具体日期。
正常情况下 base_date + index 就是答案;若页面与基准日期不一致
(例如跨月、缓存页面),则从基准日期向后寻找第一个日号匹配的日期。
"""
guess = base_date + timedelta(days=index)
if day_number is None or guess.day == day_number:
return guess
for offset in range(index, 40):
candidate = base_date + timedelta(days=offset)
if candidate.day == day_number:
return candidate
return guess
def parse_temperature(temperature_node):
"""解析 p.tem 节点,返回 (最高气温, 最低气温)。
页面结构有两种:
<p class="tem"><span>27℃</span>/<i>19℃</i></p> -> 最高 27,最低 19
<p class="tem"><i>20℃</i></p> -> 只有当前气温(今天),最高为空
"""
if temperature_node is None:
return None, None
highs = temperature_node.find_all("span")
lows = temperature_node.find_all("i")
temp_high = to_float(re.sub(r"[^\d.\-]", "", highs[0].get_text())) if highs else None
temp_low = to_float(re.sub(r"[^\d.\-]", "", lows[0].get_text())) if lows else None
return temp_high, temp_low
def parse_wind(wind_node):
"""解析 p.win 节点,返回 (风向, 风力)。
风向藏在 <span title="东北风"> 的 title 属性里;
白天/夜间风向不同时会有两个 span(如"北风""东北风"),用"转"连接。
风力在 <i>4-5级</i> 中。
"""
if wind_node is None:
return None, None
directions = []
for span in wind_node.find_all("span"):
value = (span.get("title") or "").strip()
# 相同风向只保留一个,避免出现"无持续风转向无持续风"
if value and (not directions or directions[-1] != value):
directions.append(value)
level_node = wind_node.find("i")
wind_level = level_node.get_text(strip=True) if level_node else None
return ("转".join(directions) if directions else None), wind_level
def parse_forecast(html, city, city_code, url):
"""解析页面,返回该城市最近 7 日天气预报(字典列表)。"""
soup = BeautifulSoup(html, "lxml")
base_date = parse_base_date(soup)
items = soup.select("ul.t.clearfix li")
if not items:
raise ValueError(f"{city}({city_code}) 页面结构异常:未找到未来天气列表")
crawl_time = now_str()
rows = []
for index, item in enumerate(items[:FORECAST_DAYS]):
# ---- 日期与星期 ----
date_node = item.find("h1")
date_text = date_node.get_text(strip=True) if date_node else ""
match = re.search(r"(\d{1,2})日", date_text)
day_number = int(match.group(1)) if match else None
forecast_date = align_date(base_date, day_number, index)
weekday = weekday_cn(forecast_date)
# ---- 天气:如"阴转小雨",拆成白天/夜间 ----
weather_node = item.find("p", class_="wea")
weather = weather_node.get_text(strip=True) if weather_node else ""
if "转" in weather:
weather_day, weather_night = weather.split("转", 1)
else:
weather_day, weather_night = weather, weather
# ---- 气温、风向风力 ----
temp_high, temp_low = parse_temperature(item.find("p", class_="tem"))
wind_dir, wind_level = parse_wind(item.find("p", class_="win"))
rows.append({
"province": PROVINCE,
"city": city,
"city_code": city_code,
"forecast_date": forecast_date.strftime("%Y-%m-%d"),
"weekday": weekday,
"weather": weather,
"weather_day": weather_day,
"weather_night": weather_night,
"temp_high": temp_high,
"temp_low": temp_low,
"wind_dir": wind_dir,
"wind_level": wind_level,
"source_url": url,
"crawl_time": crawl_time,
})
return rows
# --------------------------------------------------------------------------- #
# 3. 结果展示与导出
# --------------------------------------------------------------------------- #
def print_overview(rows):
"""把 8 城 × 7 天的数据打印成两张概览矩阵(天气 / 气温)。"""
if not rows:
return
cities = list(FUJIAN_CITIES.keys()) # 城市顺序与配置一致
dates = [row["forecast_date"] for row in rows if row["city"] == cities[0]]
# 表头形如 "11-07 周六"
header = ["城市"] + [f"{d[5:]} {weekday_cn(datetime.strptime(d, '%Y-%m-%d').date())}"
for d in dates]
weather_rows, temp_rows = [], []
for city in cities:
city_rows = {row["forecast_date"]: row for row in rows if row["city"] == city}
weather_rows.append([city] + [city_rows[d]["weather"] for d in dates])
temp_rows.append([city] + [
(f"{int(city_rows[d]['temp_high'])}/{int(city_rows[d]['temp_low'])}"
if city_rows[d]["temp_high"] is not None and city_rows[d]["temp_low"] is not None
else f"--/{int(city_rows[d]['temp_low'])}"
if city_rows[d]["temp_low"] is not None else "--/--")
for d in dates
])
# 日期表头形如 "11-07 周六",比两行表头更整齐
header = ["城市"] + [f"{d[5:]} {weekday_cn(datetime.strptime(d, '%Y-%m-%d').date())}"
for d in dates]
print(format_table(header, weather_rows, title="表1 福建八市最近 7 日天气"))
print()
print(format_table(header, temp_rows, aligns=["left"] + ["right"] * len(dates),
title="表2 福建八市最近 7 日气温(最高/最低,℃)"))
print("注:中国气象网在每天 20:00 之后不再显示“今天”的最高气温,"
"因此今天一列的最高气温记为 --(数据库中存 NULL)。")
def export_csv(rows, path):
"""把明细数据导出为 csv(utf-8-sig,Excel 直接打开不乱码)。"""
path.parent.mkdir(parents=True, exist_ok=True)
columns = ["province", "city", "city_code", "forecast_date", "weekday",
"weather", "weather_day", "weather_night", "temp_high",
"temp_low", "wind_dir", "wind_level", "source_url", "crawl_time"]
headers = ["省份", "城市", "城市编码", "预报日期", "星期", "天气", "白天天气",
"夜间天气", "最高气温(℃)", "最低气温(℃)", "风向", "风力",
"数据来源", "抓取时间"]
with open(path, "w", newline="", encoding="utf-8-sig") as fp:
writer = csv.writer(fp)
writer.writerow(headers)
for row in rows:
writer.writerow([row.get(column) for column in columns])
# --------------------------------------------------------------------------- #
# 4. 主流程
# --------------------------------------------------------------------------- #
def main():
"""任务①主流程:抓取 -> 解析 -> 入库 -> 展示。"""
setup_console()
start = time.time()
print("=" * 78)
print(" 任务① 中国气象网 —— 福建八市最近 7 日天气预报")
print("=" * 78)
conn = connect_db()
init_db(conn)
all_rows = []
for order, (city, city_code) in enumerate(FUJIAN_CITIES.items(), start=1):
url, html = fetch_page(city, city_code)
rows = parse_forecast(html, city, city_code, url)
all_rows.extend(rows)
print(f"[{order}/{len(FUJIAN_CITIES)}] {city}({city_code}) 解析成功:"
f"{len(rows)} 条预报 {rows[0]['forecast_date']} ~ {rows[-1]['forecast_date']}")
time.sleep(REQUEST_INTERVAL) # 控制请求频率,做"有礼貌的爬虫"
saved = save_weather_rows(conn, all_rows)
cost = time.time() - start
log_crawl(conn, "weather", "weather_forecast", saved, "success",
f"{len(FUJIAN_CITIES)} 个城市", cost)
print()
print_overview(all_rows)
print()
print(f"本次解析 {len(all_rows)} 条,写入数据库 {saved} 条,"
f"表内现有 {count_rows(conn, 'weather_forecast')} 条,耗时 {cost:.1f} 秒")
csv_path = OUTPUT_DIR / "weather_forecast.csv"
export_csv(all_rows, csv_path)
print(f"明细已导出:{csv_path}")
conn.close()
return all_rows
if __name__ == "__main__":
main()
(4)运行结果
执行 python weather_spider.py,控制台输出如下(8 个城市各 7 条,共 56 条):

表 1 是八市未来 7 天的天气,表 2 是对应的最高/最低气温(-- 表示数据缺失,见上面的第 2 点)。
把最高气温画成折线图,可以直观看到这一周福建先降温后回暖的过程:

(5)数据库存储结果
CREATE TABLE weather_forecast (
id INTEGER PRIMARY KEY AUTOINCREMENT,
province TEXT NOT NULL, -- 省份
city TEXT NOT NULL, -- 城市名
city_code TEXT NOT NULL, -- 中国气象网城市编码
forecast_date TEXT NOT NULL, -- 预报日期 YYYY-MM-DD
weekday TEXT, -- 星期
weather TEXT, -- 天气原文,如"阴转小雨"
weather_day TEXT, -- 白天天气
weather_night TEXT, -- 夜间天气
temp_high REAL, -- 最高气温(℃)
temp_low REAL, -- 最低气温(℃)
wind_dir TEXT, -- 风向
wind_level TEXT, -- 风力
source_url TEXT, -- 数据来源
crawl_time TEXT NOT NULL, -- 抓取时间
UNIQUE (city_code, forecast_date) -- 同城同日只保留一条
);

1.1.3 任务②:东方财富网股票行情(requests + json)
(1)F12 抓包分析过程
- 打开 https://quote.eastmoney.com/center/gridlist.html,按
F12打开开发者工具,
切到 Network(网络) 面板,勾选 Fetch/XHR 过滤; - 刷新页面,可以看到列表数据不是写在 HTML 里的,而是由一条名为
clist的请求返回:
https://push2.eastmoney.com/api/qt/clist/get
?pn=1&pz=20&po=1&np=1&fltt=2&invt=2&fid=f3
&fs=m:0+t:6,m:0+t:80,m:1+t:2,m:1+t:23
&fields=f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f12,f13,f14,f15,...,f152
&ut=bd1d9ddb04089700cf9c27f6f7426281
- 切换到 Response 标签,返回的是标准 JSON:
{
"rc": 0, "rt": 6, "svr": 181734925, "lt": 1, "full": 1,
"data": {
"total": 5563,
"diff": [
{"f2": 36.6, "f3": 20.0, "f5": 178977, "f6": 631178254.66,
"f12": "301697", "f14": "贝特利", "f15": 36.6, "f16": 33.0, "f17": 34.58}
]
}
}
- 逐个参数试验后可以确认各参数的作用(这也是本次实验最有意思的一步):
| 参数 | 作用 | 常用取值 |
|---|---|---|
pn / pz |
页码 / 每页条数 | pn=1,pz 最大一般 100 |
po |
排序方向 | 1 降序、0 升序 |
np |
返回结构 | 1 时 diff 是列表,0 时是带名称的字典 |
fltt |
数值精度 | 2 = 价格保留 2 位小数 |
fid |
排序字段 | f3 涨跌幅、f2 最新价、f6 成交额 |
fs |
市场筛选 | m:0+t:6 深主板、m:0+t:80 创业板、m:1+t:2 沪主板、m:1+t:23 科创板 |
fields |
返回字段 | 按需增删,见下表 |
fields中常用的字段含义(全部写进了config.STOCK_FIELD_MAP):
| 字段 | 含义 | 字段 | 含义 |
|---|---|---|---|
f12 |
股票代码 | f14 |
股票名称 |
f2 |
最新价 | f3 |
涨跌幅(%) |
f4 |
涨跌额 | f5 |
成交量(手) |
f6 |
成交额(元) | f7 |
振幅(%) |
f8 |
换手率(%) | f9 |
市盈率(动态) |
f10 |
量比 | f15/f16/f17/f18 |
最高价 / 最低价 / 今开 / 昨收 |
f20/f21 |
总市值 / 流通市值 | f23 |
市净率 |
(2)代码设计上的几个考虑
- 分页抓取:接口一页最多 100 条,沪深 A 股有 5000 多只,代码用
pn循环翻页,STOCK_MAX_PAGES = 5控制抓取 500 条,避免一次抓太多给服务器压力。 fields按需裁剪:任务提示"根据情况可删减请求的参数",因此只保留需要的 21 个
字段,返回体从 200 KB 降到几十 KB,解析也更快。- 空值清洗:停牌等情况下接口会返回
-,utils.to_float()统一把它们变成None,
保证数据库里是真正的NULL而不是字符串。 - 备用数据源:调试时遇到过东方财富接口对本机 IP 直接断开连接(
Connection aborted),
因此代码实现了"接口降级"——首选东方财富,失败时自动切换到任务给出的另一个候选站点
新浪财经,并把两个来源的字段统一映射、用source字段标注来源。
这样即使某一方的接口临时不可用,实验也不会中断(本次运行结果就是走了备用源)。
(3)完整代码
# -*- coding: utf-8 -*-
"""任务②:用 requests + json 定向爬取股票行情,并保存到数据库。
抓包分析思路(F12 -> Network -> Fetch/XHR)
------------------------------------------
打开 https://quote.eastmoney.com/center/gridlist.html 后,行情表格并不是写死在
HTML 里的,而是通过 XHR 异步加载,请求地址为:
https://push2.eastmoney.com/api/qt/clist/get?pn=1&pz=20&po=1&np=1
&fltt=2&invt=2&fid=f3&fs=m:0+t:6,m:0+t:80,m:1+t:2,m:1+t:23
&fields=f1,f2,f3,f4,f5,...&ut=bd1d9ddb04089700cf9c27f6f7426281
关键参数含义:
pn / pz 页码 / 每页条数(pz 最大一般 100)
po=1 排序方式:1 降序,0 升序
np=1 返回格式:1 = diff 为列表,0 = diff 为带名称的字典
fltt=2 数值精度:价格保留 2 位小数
fid=f3 排序字段,f3 即"涨跌幅",可改成 f2(最新价)、f6(成交额) 等
fs=... 市场筛选:m:0+t:6 深主板、m:0+t:80 创业板、
m:1+t:2 沪主板、m:1+t:23 科创板
fields=... 需要返回的字段,按需增删(字段含义见 config.STOCK_FIELD_MAP)
接口返回标准 JSON:
{"rc":0,"rt":6,"svr":...,"full":1,
"data":{"total":5563,"diff":[{...},{...}]}}
为了应对接口限流(有时会直接断开连接),本脚本还实现了任务允许的另一个候选
站点——新浪财经的行情接口作为备用数据源,两个来源最终写进同一张表,并用
source 字段标注数据来源。
运行:python stock_spider.py
"""
import csv
import json
import time
import requests
from config import (HEADERS, OUTPUT_DIR, REQUEST_INTERVAL, REQUEST_RETRY,
REQUEST_TIMEOUT, STOCK_FIELD_MAP, STOCK_FIELDS,
STOCK_LIST_URL, STOCK_MARKET_FILTER, STOCK_MAX_PAGES,
STOCK_PAGE_SIZE, STOCK_SORT_FIELD)
from db import connect_db, count_rows, init_db, log_crawl, save_stock_rows
from utils import (clean_value, format_table, money_to_yi, now_str,
setup_console, to_float)
# 东方财富接口的固定签名参数,F12 抓包时原样带上即可
EASTMONEY_UT = "bd1d9ddb04089700cf9c27f6f7426281"
# 备用数据源:新浪财经行情接口(任务给出的另一个候选网站)
SINA_LIST_URL = ("http://vip.stock.finance.sina.com.cn/quotes_service/api/"
"json_v2.php/Market_Center.getHQNodeData")
SINA_HEADERS = dict(HEADERS, Referer="https://finance.sina.com.cn/")
# --------------------------------------------------------------------------- #
# 0. 通用请求(带重试)
# --------------------------------------------------------------------------- #
def http_get_json(url, params, headers, retry=REQUEST_RETRY):
"""发送 GET 请求并解析 JSON,失败时重试。
:param url: 请求地址
:param params: 查询参数字典
:param headers: 请求头
:param retry: 重试次数
:return: 解析后的 Python 对象(列表或字典)
"""
last_error = None
for attempt in range(1, retry + 1):
try:
response = requests.get(url, params=params, headers=headers,
timeout=REQUEST_TIMEOUT)
response.raise_for_status()
return response.json() # requests 自带 json 解析
except (requests.RequestException, ValueError) as exc:
last_error = exc
print(f" [重试 {attempt}/{retry}] 请求失败:{exc}")
time.sleep(REQUEST_INTERVAL * attempt) # 退避等待
raise RuntimeError(f"请求 {url} 失败:{last_error}")
# --------------------------------------------------------------------------- #
# 1. 数据源 A:东方财富网(任务首选)
# --------------------------------------------------------------------------- #
def build_eastmoney_params(page):
"""构造一页行情请求参数(参数含义见模块开头的注释)。"""
return {
"pn": page, # 页码
"pz": STOCK_PAGE_SIZE, # 每页条数
"po": 1, # 1 = 降序
"np": 1, # 1 = diff 返回列表
"fltt": 2, # 价格保留 2 位小数
"invt": 2,
"fid": STOCK_SORT_FIELD, # 按涨跌幅排序
"fs": STOCK_MARKET_FILTER, # 沪深 A 股
"fields": STOCK_FIELDS, # 需要的字段
"ut": EASTMONEY_UT,
}
def parse_eastmoney_item(item, rank, crawl_time):
"""把东方财富接口的一条记录转换为数据库字段。
:param item: 接口 diff 列表中的一个元素,如 {'f12': '600519', ...}
:param rank: 该记录在本次抓取中的序号(接口已按涨跌幅排序)
:param crawl_time: 抓取时间
:return: 字典,键名与 stock_info 表字段一致
"""
record = {"list_rank": rank, "crawl_time": crawl_time,
"source": "东方财富"}
for field, column in STOCK_FIELD_MAP.items():
value = item.get(field)
if column in ("stock_code", "stock_name"):
record[column] = clean_value(value)
else:
record[column] = to_float(value) # "-" 等无效值统一转为 None
record["market"] = guess_market(record.get("stock_code"))
return record
def crawl_eastmoney():
"""翻页抓取东方财富行情,返回统一格式的记录列表。"""
crawl_time = now_str()
headers = dict(HEADERS, Referer="https://quote.eastmoney.com/")
rows = []
first_payload = None
for page in range(1, STOCK_MAX_PAGES + 1):
payload = http_get_json(STOCK_LIST_URL, build_eastmoney_params(page), headers)
if first_payload is None:
first_payload = payload # 留作抓包分析样本
data = payload.get("data") or {}
diff = data.get("diff") or []
if isinstance(diff, dict): # np=0 时 diff 是字典
diff = list(diff.values())
start_rank = len(rows) + 1 # 本页第一条记录的总序号
rows.extend(parse_eastmoney_item(item, start_rank + index, crawl_time)
for index, item in enumerate(diff))
print(f"[第 {page} 页] 返回 {len(diff)} 条,市场总数 {data.get('total')} 只,"
f"累计 {len(rows)} 条")
if len(diff) < STOCK_PAGE_SIZE: # 最后一页,提前结束
break
time.sleep(REQUEST_INTERVAL)
if not rows:
raise RuntimeError("东方财富接口返回空数据")
return rows, first_payload
# --------------------------------------------------------------------------- #
# 2. 数据源 B:新浪财经(备用,接口被限流时自动启用)
# --------------------------------------------------------------------------- #
def build_sina_params(page):
"""构造新浪行情接口参数:按涨跌幅降序、沪深 A 股、每页 100 条。"""
return {
"page": page,
"num": STOCK_PAGE_SIZE,
"sort": "changepercent",
"asc": 0,
"node": "hs_a",
"_s_r_a": "page",
}
def parse_sina_item(item, rank, crawl_time):
"""把新浪财经接口的一条记录转换为与东方财富一致的数据库字段。
两个接口的字段名完全不同,这里做一次"字段对齐",让入库逻辑可以复用。
单位换算:成交量 股->手(除以 100);市值 万元->元(乘以 10000)。
"""
prev_close = to_float(item.get("settlement"))
high = to_float(item.get("high"))
low = to_float(item.get("low"))
amplitude = None
if prev_close and high is not None and low is not None:
amplitude = round((high - low) / prev_close * 100, 2) # 振幅自行计算
volume = to_float(item.get("volume"))
total_cap = to_float(item.get("mktcap"))
circle_cap = to_float(item.get("nmc"))
return {
"stock_code": clean_value(item.get("code")),
"stock_name": clean_value(item.get("name")),
"market": guess_market(item.get("symbol") or item.get("code")),
"latest_price": to_float(item.get("trade")),
"change_pct": to_float(item.get("changepercent")),
"change_amount": to_float(item.get("pricechange")),
"volume": round(volume / 100, 2) if volume is not None else None,
"amount": to_float(item.get("amount")),
"amplitude": amplitude,
"turnover_rate": to_float(item.get("turnoverratio")),
"pe_dynamic": to_float(item.get("per")),
"volume_ratio": None,
"high_price": high,
"low_price": low,
"open_price": to_float(item.get("open")),
"prev_close": prev_close,
"total_market_cap": total_cap * 10000 if total_cap is not None else None,
"circulating_market_cap": circle_cap * 10000 if circle_cap is not None else None,
"pb": to_float(item.get("pb")),
"change_60d": None,
"change_ytd": None,
"list_rank": rank,
"source": "新浪财经",
"crawl_time": crawl_time,
}
def crawl_sina():
"""翻页抓取新浪财经行情,返回统一格式的记录列表。"""
crawl_time = now_str()
rows = []
first_payload = None
for page in range(1, STOCK_MAX_PAGES + 1):
payload = http_get_json(SINA_LIST_URL, build_sina_params(page), SINA_HEADERS)
if first_payload is None:
first_payload = payload
if not isinstance(payload, list) or not payload:
break
start_rank = len(rows) + 1 # 本页第一条记录的总序号
rows.extend(parse_sina_item(item, start_rank + index, crawl_time)
for index, item in enumerate(payload))
print(f"[第 {page} 页] 返回 {len(payload)} 条,累计 {len(rows)} 条")
if len(payload) < STOCK_PAGE_SIZE:
break
time.sleep(REQUEST_INTERVAL)
if not rows:
raise RuntimeError("新浪财经接口返回空数据")
return rows, first_payload
# --------------------------------------------------------------------------- #
# 3. 数据源选择
# --------------------------------------------------------------------------- #
def guess_market(code):
"""根据代码或代码前缀推断交易所。
新浪接口的 symbol 形如 sh600519 / sz000001 / bj920085,可直接判断;
东方财富只给 6 位代码,按首位判断:6=沪市,0/3=深市,4/8/9=北交所。
"""
if not code:
return None
code = str(code).lower()
if code.startswith("sh"):
return "上交所"
if code.startswith("sz"):
return "深交所"
if code.startswith("bj"):
return "北交所"
if code.startswith("6"):
return "上交所"
if code.startswith(("0", "3")):
return "深交所"
if code.startswith(("4", "8", "9")):
return "北交所"
return "其他"
def crawl_stock():
"""优先抓东方财富,接口不可用时自动切换到新浪财经。
:return: (数据来源名称, 记录列表, 原始 JSON 样本)
"""
try:
rows, raw = crawl_eastmoney()
return "东方财富", rows, raw
except RuntimeError as exc:
print(f"[警告] 东方财富接口不可用:{exc}")
print(" 自动切换到备用数据源:新浪财经")
rows, raw = crawl_sina()
return "新浪财经", rows, raw
# --------------------------------------------------------------------------- #
# 4. 结果展示与导出
# --------------------------------------------------------------------------- #
def print_top(rows, top=10):
"""打印涨跌幅前 N 名的表格。"""
header = ["排名", "代码", "名称", "最新价", "涨跌幅%", "成交额", "换手率%", "市盈率"]
table_rows = []
for row in rows[:top]:
table_rows.append([
row["list_rank"],
row["stock_code"],
row["stock_name"],
f"{row['latest_price']:.2f}" if row["latest_price"] is not None else "-",
f"{row['change_pct']:+.2f}" if row["change_pct"] is not None else "-",
money_to_yi(row["amount"]),
f"{row['turnover_rate']:.2f}" if row["turnover_rate"] is not None else "-",
f"{row['pe_dynamic']:.2f}" if row["pe_dynamic"] is not None else "-",
])
print(format_table(
header, table_rows,
aligns=["right", "left", "left", "right", "right", "right", "right", "right"],
title=f"A 股涨跌幅前 {min(top, len(rows))} 名",
))
def print_summary(rows):
"""打印本次抓取的市场分布与涨跌统计。"""
up = sum(1 for row in rows if (row["change_pct"] or 0) > 0)
down = sum(1 for row in rows if (row["change_pct"] or 0) < 0)
flat = len(rows) - up - down
markets = {}
for row in rows:
markets[row["market"]] = markets.get(row["market"], 0) + 1
market_text = "、".join(f"{name} {count} 只" for name, count in markets.items())
print(f"统计:共 {len(rows)} 只 | {market_text}")
print(f" 涨跌分布:上涨 {up} 只、下跌 {down} 只、平盘 {flat} 只"
f"(按涨跌幅降序取样,因此样本以上涨股票为主)")
def export_csv(rows, path):
"""把行情明细导出为 csv。"""
path.parent.mkdir(parents=True, exist_ok=True)
columns = ["list_rank", "stock_code", "stock_name", "market", "latest_price",
"change_pct", "change_amount", "volume", "amount", "amplitude",
"turnover_rate", "pe_dynamic", "volume_ratio", "high_price",
"low_price", "open_price", "prev_close", "total_market_cap",
"circulating_market_cap", "pb", "change_60d", "change_ytd",
"source", "crawl_time"]
headers = ["序号", "代码", "名称", "交易所", "最新价", "涨跌幅(%)", "涨跌额",
"成交量(手)", "成交额(元)", "振幅(%)", "换手率(%)", "市盈率",
"量比", "最高价", "最低价", "今开", "昨收", "总市值(元)",
"流通市值(元)", "市净率", "60日涨跌幅(%)", "年初至今(%)",
"数据来源", "抓取时间"]
with open(path, "w", newline="", encoding="utf-8-sig") as fp:
writer = csv.writer(fp)
writer.writerow(headers)
for row in rows:
writer.writerow([row.get(column) for column in columns])
# --------------------------------------------------------------------------- #
# 5. 主流程
# --------------------------------------------------------------------------- #
def main():
"""任务②主流程:请求接口 -> 解析 JSON -> 入库 -> 展示。"""
setup_console()
start = time.time()
print("=" * 78)
print(" 任务② 股票行情数据爬取(requests + json)")
print("=" * 78)
conn = connect_db()
init_db(conn)
source, rows, raw_payload = crawl_stock()
saved = save_stock_rows(conn, rows)
cost = time.time() - start
log_crawl(conn, "stock", "stock_info", saved, "success",
f"数据来源:{source}", cost)
# 保存一页原始 JSON,便于和 F12 抓包结果对照(同时演示 json 模块的用法)
raw_path = OUTPUT_DIR / "stock_raw_page1.json"
raw_path.parent.mkdir(parents=True, exist_ok=True)
with open(raw_path, "w", encoding="utf-8") as fp:
json.dump(raw_payload, fp, ensure_ascii=False, indent=2)
print()
print_top(rows, top=10)
print_summary(rows)
print()
print(f"数据来源:{source};本次解析 {len(rows)} 条,写入数据库 {saved} 条,"
f"表内现有 {count_rows(conn, 'stock_info')} 条,耗时 {cost:.1f} 秒")
print(f"原始 JSON 样本:{raw_path}")
csv_path = OUTPUT_DIR / "stock_info.csv"
export_csv(rows, csv_path)
print(f"行情明细已导出:{csv_path}")
conn.close()
return rows
if __name__ == "__main__":
main()
(4)运行结果

取涨幅前 15 名画成柱状图:

(5)数据库存储结果
股票表以股票代码为主键,每次运行覆盖更新,相当于保存"最新一次行情快照":
CREATE TABLE stock_info (
stock_code TEXT PRIMARY KEY, -- 股票代码
stock_name TEXT NOT NULL, -- 股票名称
market TEXT, -- 上交所 / 深交所 / 北交所
latest_price REAL, -- 最新价
change_pct REAL, -- 涨跌幅(%)
amount REAL, -- 成交额(元)
turnover_rate REAL, -- 换手率(%)
pe_dynamic REAL, -- 市盈率
pb REAL, -- 市净率
total_market_cap REAL, -- 总市值(元)
source TEXT, -- 数据来源
crawl_time TEXT NOT NULL -- 抓取时间
-- 其余字段省略
);
1.1.4 运行统计
| 任务 | 数据表 | 记录数 | 说明 |
|---|---|---|---|
| 任务① 天气预报 | weather_forecast |
56 条 | 8 个城市 × 7 天 |
| 任务② 股票行情 | stock_info |
500 条 | 数据来源:新浪财经 |
| 任务③ 大学排名 | university_rank |
582 条 | 31 个省市、5 种办学类型 |
| 合计 | 3 张业务表 | 1138 条 | 数据库文件 284 KB(SQLite) |
1.2 作业心得
第一个任务看起来最简单,其实踩的坑最多,也让我第一次意识到"能跑通"和"数据正确"是两回事。
一是编码。 一开始直接用 response.text,抓下来的城市名全是乱码——requests 依据
响应头猜的编码是 ISO-8859-1,而页面其实是 UTF-8。改成显式设置 response.encoding = "utf-8"
之后才正常。后来处理股票接口时又遇到相反的问题:Windows 控制台默认是 GBK,
打印中文没问题,但打印带 ℃、± 之类的字符就可能抛 UnicodeEncodeError,
最后统一在程序入口把标准输出的 errors 设为 replace,才彻底消停。编码问题不解决,
后面所有解析都是白做,这是这次实验最直接的一条经验。
二是要"看懂页面"而不是"写正则"。 最初我想用一个正则把 7 天的数据一次性抠出来,
写出来的正则又长又脆,页面一改就全崩。后来用 BeautifulSoup 按 ul.t.clearfix > li
逐层取节点,代码立刻清晰了,而且 p.wea、p.tem、p.win 这些类名本身就把语义说清楚了。
更关键的是,只有认真看 DOM 才会发现"今天"的气温结构和别的日子不一样(只有一个 <i>),
也才会注意到风向其实写在 span 的 title 属性里而不是标签文本中。
数据结构上的例外,往往就藏在这些不起眼的细节里。
三是日期。 页面只给"7日(今天)"这样的日号,我一开始直接用了系统当天日期,
结果测试时正好赶上跨月,日期全错了。后来发现页面里有 fc_24h_internal_update_time
这个隐藏域记录了完整的 2026110720,用它做基准日期再按序号推算,问题就解决了。
这件事让我记住:页面上一定有比"我猜"更可靠的依据,只是需要去找。
四是关于反爬和数据源。 股票任务的接口一开始能正常返回 JSON,多请求几次之后
就开始直接断开连接。我试过加 Cookie、换 Referer、换 HTTP/2、换请求方式,都没有用,
最后判断是对方的风控。于是给代码加了"主数据源 + 备用数据源"的降级逻辑:
东方财富优先,失败就自动切到新浪财经,字段统一后再入库。
回头看,这其实是工程上很常见的一种思路——不要把鸡蛋放在一个接口上,
同时也提醒自己控制请求频率(每次请求之间 sleep),做"有礼貌的爬虫"。
五是数据库。 我最初每跑一次就往表里插一遍数据,跑三次表里就有三份重复数据。
后来给表加了唯一约束,写入改成 INSERT ... ON CONFLICT DO UPDATE,
重复运行只会更新而不会重复。这个小改动让我理解了数据库约束的意义:
数据的正确性最好由数据库保证,而不是靠调用方自觉。
二、任务③:软科 2021 中国大学排名
2.1 作业代码与运行结果
2.1.1 F12 抓包分析过程(GIF)
打开 https://www.shanghairanking.cn/rankings/bcur/2021 后按 F12 → Network →
勾选 Fetch/XHR → 刷新页面,就能看到榜单数据的来源接口 bcur。
下面的 GIF 把这个过程逐帧还原了出来(依次是:找到接口 → 看请求头 → 看响应 JSON →
用 requests 复现 → 入库结果):

说明:GIF 中的地址、参数、JSON 片段均来自本次运行的真实请求与响应;
为便于在博客中阅读,采用了终端风格的逐帧渲染方式呈现。
如果需要在博客中放浏览器录屏,可用录屏软件(如 ScreenToGif)录制一遍并替换本图。
2.1.2 接口与响应结构
| 项目 | 内容 |
|---|---|
| 请求地址 | https://www.shanghairanking.cn/api/pub/v1/bcur |
| 请求方法 | GET |
| 参数 | bcur_type=11(主榜)、year=2021 |
| 必要请求头 | Referer: https://www.shanghairanking.cn/rankings/bcur/2021、普通浏览器 UA |
| 返回 | JSON,data.rankings 数组,2021 主榜共 582 所院校 |
响应中每条记录的结构如下(节选):
{
"ranking": "1",
"univNameCn": "清华大学",
"univNameEn": "Tsinghua University",
"province": "北京",
"univCategory": "综合",
"score": 969.2,
"univTags": ["双一流", "985", "211"],
"univUp": "tsinghua-university",
"indData": {"159": "37.9", "160": "74.3", "...": "..."}
}
几点观察:
- 接口一次性返回全部 582 所院校,
page、page_size参数不起作用,
所以不需要翻页,一次请求就够; - 接口会校验
Referer,不带时可能返回 403,所以请求头里必须带上排行榜页面地址; ranking是字符串,score是浮点数,入库前分别用to_int/to_float转换;univTags是数组,入库时拼成双一流,985,211这样的字符串便于查询。
2.1.3 完整代码
# -*- coding: utf-8 -*-
"""任务③:爬取软科 2021 中国大学排名(主榜)全部院校信息并保存到数据库。
抓包分析思路(F12 -> Network -> Fetch/XHR)
------------------------------------------
访问 https://www.shanghairanking.cn/rankings/bcur/2021 时,页面只是一个
空壳,真正的榜单数据由前端通过 XHR 异步请求:
GET https://www.shanghairanking.cn/api/pub/v1/bcur
?bcur_type=11&year=2021
参数含义:
bcur_type = 11 榜单类型,11 表示"中国大学排名(主榜)"
year = 2021 榜单年份
可选 page / page_size:该接口一次性返回全部上榜院校(2021 主榜共 582 所),
分页参数实际不起作用,因此抓取时只需请求一次。
返回的是标准 JSON:
{"code":200,"msg":"success",
"data":{"rankings":[{"ranking":"1","univNameCn":"清华大学",
"province":"北京","univCategory":"综合",
"score":969.2,"univTags":["双一流","985","211"], ...}],
"inds":..., "provinces":..., "univCategorys":...}}
注意:接口会校验 Referer,缺少 Referer 时可能返回 403,所以请求头里带上
排行榜页面地址。
运行:python university_spider.py
"""
import csv
import json
import time
import requests
from config import (HEADERS, OUTPUT_DIR, RANK_REFERER, RANK_TYPE, RANK_URL,
RANK_YEAR, REQUEST_INTERVAL, REQUEST_RETRY,
REQUEST_TIMEOUT)
from db import (connect_db, count_rows, init_db, log_crawl,
save_university_rows)
from utils import (format_table, now_str, setup_console, to_float, to_int)
def fetch_rankings():
"""请求软科排名接口,返回 (原始 JSON, 榜单列表)。"""
headers = dict(HEADERS)
headers["Referer"] = RANK_REFERER
headers["Accept"] = "application/json, text/plain, */*"
params = {"bcur_type": RANK_TYPE, "year": RANK_YEAR}
last_error = None
for attempt in range(1, REQUEST_RETRY + 1):
try:
response = requests.get(RANK_URL, params=params, headers=headers,
timeout=REQUEST_TIMEOUT)
response.raise_for_status()
payload = response.json()
if payload.get("code") != 200:
raise ValueError(f"接口返回异常:{payload.get('msg')}")
return payload, payload["data"]["rankings"]
except (requests.RequestException, ValueError, KeyError) as exc:
last_error = exc
print(f" [重试 {attempt}/{REQUEST_RETRY}] 排名接口请求失败:{exc}")
time.sleep(REQUEST_INTERVAL * attempt)
raise RuntimeError(f"软科排名接口请求失败:{last_error}")
def parse_ranking(item, crawl_time):
"""把接口的一条院校记录转换为数据库字段。"""
tags = item.get("univTags") or []
return {
"year": RANK_YEAR,
"ranking": to_int(item.get("ranking")),
"university": (item.get("univNameCn") or "").strip(),
"university_en": (item.get("univNameEn") or "").strip(),
"province": item.get("province"),
"category": item.get("univCategory"),
"score": to_float(item.get("score")),
"tags": ",".join(tags),
"univ_slug": item.get("univUp"),
"crawl_time": crawl_time,
}
def print_top(rows, top=15):
"""打印主榜前 N 名。"""
header = ["排名", "学校", "省市", "类型", "总分", "标签"]
table_rows = [
[row["ranking"], row["university"], row["province"], row["category"],
f"{row['score']:.1f}" if row["score"] is not None else "-",
row["tags"] or "-"]
for row in rows[:top]
]
print(format_table(header, table_rows,
aligns=["right", "left", "left", "left", "right", "left"],
title=f"软科 {RANK_YEAR} 中国大学排名(主榜)前 {min(top, len(rows))} 名"))
def print_summary(rows):
"""打印省份 / 类型分布等统计信息。"""
provinces = {}
categories = {}
for row in rows:
provinces[row["province"]] = provinces.get(row["province"], 0) + 1
categories[row["category"]] = categories.get(row["category"], 0) + 1
top_provinces = sorted(provinces.items(), key=lambda kv: kv[1], reverse=True)[:10]
top_categories = sorted(categories.items(), key=lambda kv: kv[1], reverse=True)
print(format_table(
["省市", "上榜数"],
[[name, count] for name, count in top_provinces],
aligns=["left", "right"],
title="上榜院校最多的 10 个省市",
))
print()
print("办学类型分布:" + "、".join(f"{name} {count} 所" for name, count in top_categories))
print(f"合计:{len(rows)} 所院校,覆盖 {len(provinces)} 个省市、{len(categories)} 种办学类型")
def export_csv(rows, path):
"""把榜单导出为 csv。"""
path.parent.mkdir(parents=True, exist_ok=True)
columns = ["year", "ranking", "university", "university_en", "province",
"category", "score", "tags", "univ_slug", "crawl_time"]
headers = ["年份", "排名", "学校", "英文校名", "省市", "类型", "总分",
"标签", "英文标识", "抓取时间"]
with open(path, "w", newline="", encoding="utf-8-sig") as fp:
writer = csv.writer(fp)
writer.writerow(headers)
for row in rows:
writer.writerow([row.get(column) for column in columns])
def main():
"""任务③主流程:请求接口 -> 解析 JSON -> 入库 -> 展示。"""
setup_console()
start = time.time()
print("=" * 78)
print(f" 任务③ 软科 {RANK_YEAR} 中国大学排名(主榜)—— {RANK_URL}")
print("=" * 78)
conn = connect_db()
init_db(conn)
payload, rankings = fetch_rankings()
crawl_time = now_str()
rows = [parse_ranking(item, crawl_time) for item in rankings
if (item.get("univNameCn") or "").strip()]
rows.sort(key=lambda row: (row["ranking"] is None, row["ranking"] or 0))
saved = save_university_rows(conn, rows)
cost = time.time() - start
log_crawl(conn, "university", "university_rank", saved, "success",
f"主榜 {len(rows)} 所院校", cost)
# 保存原始 JSON,便于对照 F12 抓包结果
raw_path = OUTPUT_DIR / "university_raw.json"
raw_path.parent.mkdir(parents=True, exist_ok=True)
with open(raw_path, "w", encoding="utf-8") as fp:
json.dump(payload, fp, ensure_ascii=False, indent=2)
print(f"接口返回 {len(rankings)} 条院校记录,解析后 {len(rows)} 条")
print()
print_top(rows)
print()
print_summary(rows)
print()
print(f"写入数据库 {saved} 条,表内现有 {count_rows(conn, 'university_rank')} 条,"
f"耗时 {cost:.1f} 秒")
csv_path = OUTPUT_DIR / "university_rank.csv"
export_csv(rows, csv_path)
print(f"榜单已导出:{csv_path}")
print(f"原始 JSON:{raw_path}")
conn.close()
return rows
if __name__ == "__main__":
main()
2.1.4 运行结果

- 2021 主榜共 582 所院校,覆盖 31 个省市、
5 种办学类型; - 排名靠前的是清华、北大、浙大、上海交大、南大……与大家平时的认知一致,说明抓到的数据是可信的;
- 从地域看,江苏(38 所)、山东(33 所)、河南(31 所)上榜数量最多;
从类型看,理工类(211 所)和综合类(172 所)占了绝大多数。

2.1.5 数据库存储与主程序
CREATE TABLE university_rank (
id INTEGER PRIMARY KEY AUTOINCREMENT,
year INTEGER NOT NULL, -- 榜单年份
ranking INTEGER, -- 排名
university TEXT NOT NULL, -- 学校名称
university_en TEXT, -- 英文校名
province TEXT, -- 省市
category TEXT, -- 办学类型
score REAL, -- 总分
tags TEXT, -- 标签:双一流/985/211
univ_slug TEXT, -- 英文标识
crawl_time TEXT NOT NULL, -- 抓取时间
UNIQUE (year, university)
);
2.2 作业心得
第三个任务的接口是最容易的:一次请求就拿到全部 582 条数据,几乎没有反爬。
但正因为太顺利,反而让我把注意力放到了"抓包"这件事本身,收获也更多。
第一,抓包是找接口最快的方法。 如果直接请求排行榜页面,会得到一堆空表格——
因为数据是 JS 渲染的。打开 F12 的 Fetch/XHR 过滤,刷新页面,一眼就能看到 bcur 这条请求,
点开 Response 就能看到完整的 JSON。以前我总觉得 F12 是"给前端用的",
这次才真正体会到:对爬虫来说,F12 就是地图,接口地址、参数、请求头、返回结构一目了然。
实验中我还注意到接口校验 Referer,一开始不带 Referer 请求返回 403,补上就正常了,
这说明"照着浏览器的请求抄一份"是最稳妥的起手方式。
第二,接口参数是"瞎蒙"出来的,但要有依据。 任务提示里说 bcur_type 和 year
决定榜单内容,我就分别改了这两个值做对比:year=2020 返回的是 2020 年的榜单,
bcur_type 换成其他值则返回单科榜(医药、财经等)。这种"改一个参数、看一次结果"的
实验方法,比读文档更快,也更能发现接口的边界。
第三,数据清洗比抓取更重要。 接口返回的 ranking 是字符串、score 是浮点数、
univTags 是数组、univNameEn 可能为空。如果不做转换,后面做统计和排序会处处别扭。
我现在的习惯是先写一个 parse_xxx() 函数,把"接口的原始数据"统一成"数据库要的形状",
入库函数只负责写,职责分开之后代码可读性好了很多。
第四,可视化能反过来验证数据。 画完前 10 名的总分柱状图和各省上榜数量统计图之后,
我一眼就看出清华、北大断层领先,江苏、山东、河南上榜数量最多,
和常识一致——如果图表看起来"不对劲",往往是爬虫抓错了。
比如某次解析时我把 ranking 抓成了字符串顺序,图上的名次就全乱,
正是通过看图发现的。
最后一点体会:三个任务从"解析 HTML"到"解析 JSON"再到"抓包分析接口",
难度是递增的,但方法其实是同一套——观察真实请求 → 复现请求 → 解析响应 → 清洗入库。
这套流程跑通之后,再遇到新的网站,第一反应已经不是"怎么爬",
而是"先按 F12 看看它到底请求了什么"。
数据说明
- 天气数据为运行当天中国气象网发布的未来 7 日预报,每次运行会覆盖更新;
- 股票数据按涨跌幅降序抓取前 500 只,以股票代码为主键覆盖更新,相当于"最新行情快照";
- 大学排名为软科 2021 年主榜,共 582 所院校,数据是静态的,重复运行结果一致;
- 数据库为 SQLite 文件
data/spider.db,三张业务表共 56 + 500 + 582 条记录。
参考资料
- 中国气象网:http://www.weather.com.cn
- 东方财富网行情中心:https://quote.eastmoney.com/center/gridlist.html
- 新浪财经行情接口:http://vip.stock.finance.sina.com.cn
- 软科中国大学排名:https://www.shanghairanking.cn/rankings/bcur/2021
- Python 官方文档
sqlite3:https://docs.python.org/zh-cn/3/library/sqlite3.html

浙公网安备 33010602011771号