数据采集第二次作业
这次线上作业要完成三个定向采集任务:中国气象网 4 个城市的 7 日天气预报、沪深 A 股行情、软科 2021 中国大学排名全量数据,三者都要求把结果落到数据库里。三个脚本互相独立,各用一个 SQLite 文件存放,运行环境为 Python 3.14 + requests 2.34 + BeautifulSoup 4.15,数据库使用 Python 自带的 sqlite3,不需要额外安装。
文中所有数据都是本机真实运行脚本采集的,采集时间为 2026 年 11 月 19 日夜;天气预报和股票行情会随时间变化,复现时结果可能不同。
pip install requests beautifulsoup4
python weather_7day.py # 作业① 天气
python stock_sina.py # 作业② 股票
python ranking_2021.py # 作业③ 排名
# 运行后数据分别写入 data/weather.db、data/stock.db、data/ranking.db
一、天气预报与股票行情的定向采集(作业①、作业②)
1)实验代码与运行结果
作业①和作业②的共同思路是一样的:先确定数据从哪里来(静态页面还是接口),再把请求、解析、入库拆成三个函数。区别在于天气数据藏在 HTML 的列表中,股票数据则由接口以 JSON 返回,需要用 json 模块解析。
作业① 中国气象网 7 日天气预报
中国气象网的城市天气页地址规则是 http://www.weather.com.cn/weather/城市编码.shtml,城市编码可以在站内搜索城市后从地址栏拿到。本次选北京(101010100)、上海(101020100)、广州(101280101)、福州(101230101)四个城市,覆盖南北方不同天气。
页面里的 7 天预报放在 <ul class="t"> 下,每天一个 <li>;h1 是日期,p.wea 是天气现象,p.tem 里的 span 是最高温、i 是最低温,p.win 里的 em span 的 title 是风向。有一点需要特别注意:第一天的 li 只有最低温,因为当天已经过了最高温时段,所以 temp_high 会入库为 NULL,打印时显示成“—”。
"""作业①:爬取中国气象网给定城市集未来 7 天天气预报,并保存到 SQLite 数据库。
运行环境:Python 3.10+,依赖 requests、BeautifulSoup4。
数据来源:中国气象网城市天气页 http://www.weather.com.cn/weather/<城市编码>.shtml
"""
from __future__ import annotations
import sqlite3
from datetime import datetime
from pathlib import Path
import requests
from bs4 import BeautifulSoup
# 城市集:城市名 -> 中国气象网城市编码(编码可从 http://www.weather.com.cn 搜索城市后从地址栏获得)
CITY_CODES = {
"北京": "101010100",
"上海": "101020100",
"广州": "101280101",
"福州": "101230101",
}
URL_TEMPLATE = "http://www.weather.com.cn/weather/{code}.shtml"
HEADERS = {
"User-Agent": (
"Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
"AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36"
),
"Accept-Language": "zh-CN,zh;q=0.9",
}
DB_PATH = Path(__file__).resolve().parent / "data" / "weather.db"
def fetch_page(city_code: str) -> str:
"""下载指定城市的天气页面 HTML 文本。"""
url = URL_TEMPLATE.format(code=city_code)
response = requests.get(url, headers=HEADERS, timeout=20)
response.raise_for_status()
# 中国气象网页面为 UTF-8 编码,显式指定可避免中文乱码
response.encoding = "utf-8"
return response.text
def parse_forecast(html_text: str, city: str) -> list[dict]:
"""解析页面中 ul.t 下的 7 个 li,返回每天的天气记录。"""
soup = BeautifulSoup(html_text, "html.parser")
forecast_list = soup.select("ul.t li")
if not forecast_list:
raise RuntimeError(f"未在 {city} 的页面中解析到预报列表")
records = []
for item in forecast_list[:7]:
date_text = item.select_one("h1").get_text(strip=True)
weather = item.select_one("p.wea").get_text(strip=True)
# tem 节点中 span 是最高温、i 是最低温;第一天的 li 只有 i(当天已过最高温时段)
high_node = item.select_one("p.tem span")
low_node = item.select_one("p.tem i")
temp_high = int(high_node.get_text(strip=True).replace("℃", "")) if high_node else None
temp_low = int(low_node.get_text(strip=True).replace("℃", "")) if low_node else None
wind_nodes = item.select("p.win em span")
wind = "、".join(node.get("title", "") for node in wind_nodes if node.get("title"))
wind_level = item.select_one("p.win i").get_text(strip=True)
records.append({
"city": city,
"date_text": date_text,
"weather": weather,
"temp_high": temp_high,
"temp_low": temp_low,
"wind": wind,
"wind_level": wind_level,
})
return records
def save_to_db(records: list[dict]) -> int:
"""把预报记录写入 SQLite,返回写入条数。"""
DB_PATH.parent.mkdir(parents=True, exist_ok=True)
with sqlite3.connect(DB_PATH) as conn:
conn.execute(
"""
CREATE TABLE IF NOT EXISTS weather_7day (
id INTEGER PRIMARY KEY AUTOINCREMENT,
city TEXT NOT NULL,
date_text TEXT NOT NULL,
weather TEXT,
temp_high INTEGER,
temp_low INTEGER,
wind TEXT,
wind_level TEXT,
fetch_time TEXT NOT NULL,
UNIQUE (city, date_text)
)
"""
)
fetch_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
rows = [
(r["city"], r["date_text"], r["weather"], r["temp_high"],
r["temp_low"], r["wind"], r["wind_level"], fetch_time)
for r in records
]
# 同一城市同一天重复采集时用 REPLACE 覆盖,保证表内是最新一次结果
conn.executemany(
"""
INSERT OR REPLACE INTO weather_7day
(city, date_text, weather, temp_high, temp_low, wind, wind_level, fetch_time)
VALUES (?, ?, ?, ?, ?, ?, ?, ?)
""",
rows,
)
conn.commit()
return len(rows)
def show_from_db() -> None:
"""从数据库中读回数据并打印,验证入库结果。"""
with sqlite3.connect(DB_PATH) as conn:
cursor = conn.execute(
"""
SELECT city, date_text, weather, temp_high, temp_low, wind, wind_level
FROM weather_7day ORDER BY city, id
"""
)
print(f"\n数据库 data/{DB_PATH.name} 中 weather_7day 表的内容:")
print(f"{'城市':<5} | {'日期':<9} | {'天气':<7} | {'最高':>5} | {'最低':>5} | {'风向':<13} | 风力")
for city, date_text, weather, high, low, wind, level in cursor:
high_text = "—" if high is None else str(high)
low_text = "—" if low is None else str(low)
print(f"{city:<5} | {date_text:<9} | {weather:<7} | {high_text:>5} | "
f"{low_text:>5} | {wind:<13} | {level}")
def main() -> None:
all_records = []
print("=" * 78)
print("作业① 中国气象网 7 日天气预报采集")
print(f"城市集:{'、'.join(CITY_CODES)} 数据库:data/weather.db")
print("=" * 78)
for city, code in CITY_CODES.items():
html_text = fetch_page(code)
records = parse_forecast(html_text, city)
all_records.extend(records)
print(f"\n【{city}】{URL_TEMPLATE.format(code=code)} 共解析 {len(records)} 天")
for r in records:
high = r["temp_high"] if r["temp_high"] is not None else "—"
print(f" {r['date_text']:<12}{r['weather']:<8}"
f"{high!s:>4}/{r['temp_low']!s:<4}℃ {r['wind']} {r['wind_level']}")
count = save_to_db(all_records)
print("\n" + "-" * 78)
print(f"已写入数据库 data/{DB_PATH.name},本次写入 {count} 条记录")
show_from_db()
if __name__ == "__main__":
main()

图 1 作业① 运行输出:4 个城市各 7 天预报

图 2 作业① 入库校验:从 weather.db 读回 28 条记录
入库时用 (city, date_text) 做唯一键,配合 INSERT OR REPLACE,同一天重复采集只会更新而不是插重复数据;另外加一列 fetch_time 记录采集时间,方便判断数据是哪一次跑的。表结构如下:
| 字段 | 类型 | 说明 |
|---|---|---|
| city | TEXT | 城市名 |
| date_text | TEXT | 日期文本,如“20日(明天)” |
| weather | TEXT | 天气现象,如“多云转晴” |
| temp_high / temp_low | INTEGER | 最高温 / 最低温,第一天最高温为 NULL |
| wind / wind_level | TEXT | 风向 / 风力 |
| fetch_time | TEXT | 采集时间 |
作业② 沪深 A 股行情(requests + json)
作业给的候选站点是东方财富网和新浪股票。按课件提示先试了东方财富的行情接口 push2.eastmoney.com/api/qt/clist/get,参数里的 f12 是代码、f14 是名称、f2 是最新价、f3 是涨跌幅,本地能取到一页 100 条;但换网络环境后这个接口开始返回 502 和 ProxyError,反复重试都不稳定。于是改用候选里同样可用的新浪股票接口:
http://vip.stock.finance.sina.com.cn/quotes_service/api/json_v2.php/
Market_Center.getHQNodeData?page=1&num=100&sort=changepercent&asc=0&node=hs_a
它返回一个 JSON 数组,每只股票是对象,字段名直接就是含义:code 代码、name 名称、trade 最新价、changepercent 涨跌幅、amount 成交额、turnoverratio 换手率、per 市盈率等。把字段名映射成数据库列名后,用 json.loads 解析、逐条转成浮点数即可入库。为了体现翻页处理,脚本抓了前 3 页共 300 条,并按股票代码去重。
"""作业②:用 requests + json 解析新浪股票行情接口,并保存到 SQLite 数据库。
选题说明:作业给出的候选网站是东方财富网和新浪股票。东方财富的行情接口
push2.eastmoney.com/api/qt/clist/get 在部分网络环境下会被限制(返回 502 或
ProxyError),因此改用新浪股票的行情列表接口,同样满足“requests 请求 +
json 解析 + 入库”的要求。
接口:http://vip.stock.finance.sina.com.cn/quotes_service/api/json_v2.php/
Market_Center.getHQNodeData?page=1&num=100&sort=changepercent&asc=0&node=hs_a
"""
from __future__ import annotations
import json
import sqlite3
import time
from datetime import datetime
from pathlib import Path
import requests
API_URL = (
"http://vip.stock.finance.sina.com.cn/quotes_service/api/json_v2.php/"
"Market_Center.getHQNodeData"
)
HEADERS = {
"User-Agent": (
"Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
"AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36"
),
"Referer": "http://finance.sina.com.cn/stock/",
}
DB_PATH = Path(__file__).resolve().parent / "data" / "stock.db"
PAGES = 3 # 抓取前 3 页,每页 100 条,合计约 300 只股票
PAGE_SIZE = 100
# 接口字段 -> 数据库列名(字段含义见新浪行情接口说明)
FIELD_MAP = {
"code": "code",
"name": "name",
"trade": "price", # 最新价
"changepercent": "change_pct", # 涨跌幅 %
"pricechange": "change", # 涨跌额
"open": "open",
"high": "high",
"low": "low",
"settlement": "prev_close", # 昨收
"volume": "volume", # 成交量(股)
"amount": "amount", # 成交额(元)
"turnoverratio": "turnover", # 换手率 %
"per": "pe", # 市盈率
"pb": "pb",
"mktcap": "market_cap", # 总市值(万元)
}
def fetch_page(page: int) -> list[dict]:
"""请求一页行情数据,返回股票记录列表。"""
params = {
"page": page,
"num": PAGE_SIZE,
"sort": "changepercent",
"asc": 0,
"node": "hs_a", # 沪深 A 股
"symbol": "",
"_s_r_a": "page",
}
response = None
last_error = None
for _ in range(3):
try:
response = requests.get(API_URL, params=params, headers=HEADERS, timeout=20)
response.raise_for_status()
break
except requests.RequestException as error:
last_error = error
time.sleep(1)
if response is None:
raise RuntimeError(f"第 {page} 页请求失败:{last_error}")
# 接口返回的是 JSON 数组,个别页码可能返回 null,需要先做判断
payload = json.loads(response.text)
if not payload:
return []
records = []
for item in payload:
record = {}
for field, column in FIELD_MAP.items():
value = item.get(field)
if column in ("code", "name"):
record[column] = value or ""
else:
try:
record[column] = float(value) if value not in (None, "") else None
except (TypeError, ValueError):
record[column] = None
records.append(record)
return records
def save_to_db(stocks: list[dict]) -> int:
"""写入 SQLite,股票代码为主键,重复采集时更新为最新行情。"""
DB_PATH.parent.mkdir(parents=True, exist_ok=True)
with sqlite3.connect(DB_PATH) as conn:
conn.execute(
"""
CREATE TABLE IF NOT EXISTS stock_quote (
code TEXT PRIMARY KEY,
name TEXT NOT NULL,
price REAL, change_pct REAL, change REAL,
open REAL, high REAL, low REAL, prev_close REAL,
volume REAL, amount REAL, turnover REAL,
pe REAL, pb REAL, market_cap REAL,
trade_time TEXT NOT NULL
)
"""
)
trade_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
rows = [
(s["code"], s["name"], s["price"], s["change_pct"], s["change"],
s["open"], s["high"], s["low"], s["prev_close"], s["volume"],
s["amount"], s["turnover"], s["pe"], s["pb"], s["market_cap"], trade_time)
for s in stocks
]
conn.executemany(
"""
INSERT OR REPLACE INTO stock_quote
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
""",
rows,
)
conn.commit()
return len(rows)
def show_from_db(limit: int = 10) -> None:
"""按涨跌幅倒序读回数据库,验证入库结果。"""
with sqlite3.connect(DB_PATH) as conn:
total = conn.execute("SELECT COUNT(*) FROM stock_quote").fetchone()[0]
print(f"\n数据库 data/{DB_PATH.name} 中 stock_quote 表共 {total} 条记录")
print(f"{'代码':<7} | {'名称':<9} | {'最新价':>8} | {'涨跌幅%':>8} | "
f"{'成交额(亿)':>9} | {'换手%':>7}")
for code, name, price, change_pct, amount, turnover in conn.execute(
"""
SELECT code, name, price, change_pct, amount, turnover
FROM stock_quote ORDER BY change_pct DESC LIMIT ?
""",
(limit,),
):
amount_yi = f"{amount / 1e8:.2f}" if amount else "-"
price_text = f"{price:.2f}" if price is not None else "-"
pct_text = f"{change_pct:.2f}" if change_pct is not None else "-"
turnover_text = f"{turnover:.2f}" if turnover is not None else "-"
print(f"{code:<7} | {name:<9} | {price_text:>8} | {pct_text:>8} | "
f"{amount_yi:>9} | {turnover_text:>7}")
def main() -> None:
print("=" * 78)
print("作业② 新浪股票沪深 A 股行情采集(requests + json 解析)")
print(f"接口:{API_URL}")
print(f"参数:node=hs_a sort=changepercent asc=0 num={PAGE_SIZE} 共 {PAGES} 页")
print("=" * 78)
all_stocks: dict[str, dict] = {}
for page in range(1, PAGES + 1):
stocks = fetch_page(page)
print(f"第 {page} 页:解析到 {len(stocks)} 条记录")
for item in stocks:
all_stocks[item["code"]] = item
stocks = list(all_stocks.values())
print(f"\n三页汇总去重后共 {len(stocks)} 只股票,按涨跌幅排序前 10 名:")
for item in stocks[:10]:
amount_yi = item["amount"] / 1e8 if item["amount"] else 0
print(f" {item['code']:<7}{item['name']:<9}"
f"{item['price']:>8.2f} {item['change_pct']:>7.2f}%"
f" 成交额 {amount_yi:>7.2f} 亿")
count = save_to_db(stocks)
print("\n" + "-" * 78)
print(f"已写入数据库 data/{DB_PATH.name},本次写入 {count} 条记录")
show_from_db()
if __name__ == "__main__":
main()

图 3 作业② 运行输出:三页共 300 条并按涨跌幅排序

图 4 作业② 入库校验:从 stock.db 读回前 10 名
表结构按行情字段设计,code 作主键,重复采集时覆盖为最新行情:
| 字段 | 类型 | 说明 |
|---|---|---|
| code | TEXT | 股票代码(主键) |
| name | TEXT | 股票名称 |
| price / change_pct / change | REAL | 最新价 / 涨跌幅 / 涨跌额 |
| open / high / low / prev_close | REAL | 开盘 / 最高 / 最低 / 昨收 |
| volume / amount / turnover | REAL | 成交量(股)/ 成交额(元)/ 换手率 |
| pe / pb / market_cap | REAL | 市盈率 / 市净率 / 总市值(万元) |
| trade_time | TEXT | 采集时间 |
2)作业心得
第一个体会是“先看清数据在哪,再动手写解析”。天气页的 7 天列表在 HTML 里,用 BeautifulSoup 选 ul.t li 就够了;股票数据不在页面里,页面上看到的表格是 JS 渲染出来的,直接抓 HTML 只会拿到空壳。所以这两个任务虽然都是“爬取 + 入库”,但前半段的思路完全不同。
第二个体会是接口会变、网络也会变。东方财富的接口上午还能返回 200,下午就连续 502,换成 http 协议、换子域名、加重试都只能碰运气。最后选新浪并不是因为它“更好”,而是它此刻更稳定,而且作业本来就把新浪列在候选里。这件事让我意识到:写爬虫时把“取数”和“入库”解耦很有必要,接口不稳定时只影响取数那一步,解析和入库的代码不用改。
第三个体会是细节决定数据质量。天气页第一天的最高温是空的,如果不处理,数据库里会出现一堆没有解释的 NULL;股票接口里的数值是字符串,直接入库会变成 TEXT 类型,排序就会出错。统一转成数值、把空值显式变成 None、再给每张表加上唯一键和时间戳,后面查数据时才不会踩坑。
另外,请求头里的 User-Agent 和 Referer 不能省。新浪的行情接口在没有 Referer 时虽然也能返回,但加上本站 Referer 更接近真实浏览器;中国气象网对没有 UA 的请求同样可能直接拒绝。
二、软科 2021 中国大学排名全量采集(作业③)
1)实验代码、F12 抓包过程与运行结果
作业③ 软科 2021 主榜全量院校
排名页 https://www.shanghairanking.cn/rankings/bcur/2021 打开后能看到完整表格,但查看网页源代码会发现表格是空的——数据由 JavaScript 请求接口后再渲染。按 F12 打开开发者工具,切到 Network 面板,刷新页面,就能在请求列表里看到一条 api/pub/v1/bcur?bcur_type=11&year=2021 的请求,响应是一段 JSON,data.rankings 就是全部院校。下面的动图记录了整个过程:

图 5 F12 抓包过程:打开 Network → 刷新 → 找到 bcur 接口
动图共 14 帧:先打开排名页,按 F12 调出开发者工具,切到 Network 面板,按 Ctrl+R 刷新页面,请求列表由空到满,bcur?bcur_type=11&year=2021 就是拿到全部院校数据的那条请求。若图片在编辑器里显示为静态,点开原图即可看到播放过程。
把接口地址直接放到浏览器地址栏,可以看到返回的 JSON 结构,bcur_type=11 表示主榜,year=2021 表示 2021 年:

图 6 接口返回的 JSON:data.rankings 中每所院校一条记录
接口里每所院校的字段有 ranking(名次)、univNameCn、univNameEn、province、univCategory(类型)、score(总分)、univTags(双一流 / 985 / 211 等标签)。脚本请求一次接口即可拿到全部 582 所院校,不需要翻页,也不需要解析 HTML。
"""作业③:爬取软科中国大学排名 2021 主榜全部院校,并保存到 SQLite 数据库。
抓包思路:排名页 https://www.shanghairanking.cn/rankings/bcur/2021 的表格由
JavaScript 渲染,直接在 HTML 源码里看不到数据。按 F12 打开 Network 面板,
切换到 XHR/JS 分类并刷新页面,可以看到一条
https://www.shanghairanking.cn/api/pub/v1/bcur?bcur_type=11&year=2021
接口请求,响应 JSON 的 data.rankings 就是全部院校记录。
"""
from __future__ import annotations
import json
import sqlite3
import time
from pathlib import Path
import requests
API_URL = "https://www.shanghairanking.cn/api/pub/v1/bcur"
PARAMS = {"bcur_type": "11", "year": "2021"} # bcur_type=11 为主榜
HEADERS = {
"User-Agent": (
"Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
"AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36"
),
"Referer": "https://www.shanghairanking.cn/rankings/bcur/2021",
}
DB_PATH = Path(__file__).resolve().parent / "data" / "ranking.db"
def fetch_rankings() -> list[dict]:
"""请求排名接口,返回按名次排好的院校记录列表。"""
response = None
last_error = None
for _ in range(3):
try:
response = requests.get(API_URL, params=PARAMS, headers=HEADERS, timeout=30)
response.raise_for_status()
break
except requests.RequestException as error:
last_error = error
time.sleep(1)
if response is None:
raise RuntimeError(f"接口请求失败:{last_error}")
payload = json.loads(response.text)
if payload.get("code") != 200:
raise RuntimeError(f"接口返回异常:{payload.get('code')} {payload.get('msg')}")
rankings = payload["data"]["rankings"]
records = []
for item in rankings:
records.append({
"ranking": item.get("ranking", ""),
"name_cn": item.get("univNameCn", ""),
"name_en": item.get("univNameEn", ""),
"province": item.get("province", ""),
"category": item.get("univCategory", ""),
"score": item.get("score"),
"tags": "、".join(item.get("univTags") or []),
})
# 接口按名次升序返回,这里按名次数值再排一次,兼容并列名次的情况
records.sort(key=lambda r: (int(r["ranking"]) if str(r["ranking"]).isdigit() else 9999))
return records
def save_to_db(records: list[dict]) -> int:
"""把全部院校写入 SQLite,名次 + 学校作为唯一键。"""
DB_PATH.parent.mkdir(parents=True, exist_ok=True)
with sqlite3.connect(DB_PATH) as conn:
conn.execute(
"""
CREATE TABLE IF NOT EXISTS university_2021 (
id INTEGER PRIMARY KEY AUTOINCREMENT,
ranking TEXT NOT NULL,
name_cn TEXT NOT NULL,
name_en TEXT,
province TEXT,
category TEXT,
score REAL,
tags TEXT,
UNIQUE (ranking, name_cn)
)
"""
)
conn.executemany(
"""
INSERT OR REPLACE INTO university_2021
(ranking, name_cn, name_en, province, category, score, tags)
VALUES (?, ?, ?, ?, ?, ?, ?)
""",
[(r["ranking"], r["name_cn"], r["name_en"], r["province"],
r["category"], r["score"], r["tags"]) for r in records],
)
conn.commit()
return len(records)
def show_from_db() -> None:
"""从数据库中读回前 10 名和统计信息,验证入库结果。"""
with sqlite3.connect(DB_PATH) as conn:
total = conn.execute("SELECT COUNT(*) FROM university_2021").fetchone()[0]
print(f"\n数据库 {DB_PATH.name} 中 university_2021 表共 {total} 条记录")
print(f"{'排名':<6}{'学校':<16}{'省市':<8}{'类型':<8}{'总分':>8}")
for ranking, name, province, category, score in conn.execute(
"""
SELECT ranking, name_cn, province, category, score
FROM university_2021 ORDER BY CAST(ranking AS INTEGER) LIMIT 10
"""
):
print(f"{ranking:<6}{name:<16}{province:<8}{category:<8}{score!s:>8}")
def main() -> None:
print("=" * 78)
print("作业③ 软科中国大学排名 2021 主榜全量采集")
print(f"页面:https://www.shanghairanking.cn/rankings/bcur/2021")
print(f"接口:{API_URL}?bcur_type=11&year=2021")
print("=" * 78)
records = fetch_rankings()
print(f"\n接口返回院校 {len(records)} 所,其中前 10 名:")
for r in records[:10]:
print(f" {r['ranking']:<5}{r['name_cn']:<14}{r['province']:<6}"
f"{r['category']:<6}{r['score']}")
count = save_to_db(records)
print("\n" + "-" * 78)
print(f"已写入数据库 data/ranking.db,本次写入 {count} 条记录")
show_from_db()
if __name__ == "__main__":
main()

图 7 作业③ 运行输出:接口返回 582 所,打印前 10 名

图 8 作业③ 入库校验:从 ranking.db 读回名校表
入库后统计:共 582 所院校,覆盖 31 个省级行政区,其中带“985”标签的有 37 所;排名第一的清华大学 969.2 分,最后一名太原学院 58.2 分。表结构如下:
| 字段 | 类型 | 说明 |
|---|---|---|
| ranking | TEXT | 名次(接口返回字符串,有时含并列) |
| name_cn / name_en | TEXT | 中文名 / 英文名 |
| province | TEXT | 省市 |
| category | TEXT | 类型:综合 / 理工 / 师范等 |
| score | REAL | 总分 |
| tags | TEXT | 标签,如“双一流、985、211” |
2)作业心得
这个任务最直观的收获是:能抓接口就不要硬解析页面。最开始我尝试用 BeautifulSoup 找 tr,结果一个数据行都没有,因为表格是 JS 渲染出来的。打开 Network 面板后,一次接口请求就把 582 条数据完整拿到,比翻页解析 HTML 简单得多,也更快、更稳定。
第二点是抓包要会“过滤”。Network 面板里一次刷新会有几十个请求,脚本、图片、字体全在里面,直接找会看花眼。把类型切到 Fetch/XHR,再按名字搜索 bcur,目标接口一眼就能看到;找到后再看 Payload 里的参数,就能知道年份和榜单类型是怎么传的,换成别的年份只要改一个参数。
第三点是入库前要校验。接口说返回 582 条,入库后我也会数一遍 COUNT(*),并检查首尾两条是否对得上页面显示的第 1 名和最后一名;如果数量不对,多半是 JSON 结构变了或者字段名改了。这种“数量对账”比肉眼翻表格可靠得多。
最后,录制抓包 GIF 的过程本身也让我熟悉了开发者工具的布局:Elements 看结构、Network 看请求、Preview 看 JSON,三个面板配合起来,定位一个页面的数据来源通常不超过两分钟。

浙公网安备 33010602011771号