数据采集第二次作业

这次线上作业要完成三个定向采集任务:中国气象网 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 天预报

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

图 2 作业① 入库校验:从 weather.db 读回 28 条记录

图 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 条并按涨跌幅排序

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

图 4 作业② 入库校验:从 stock.db 读回前 10 名

图 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 接口

图 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 中每所院校一条记录

图 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 名

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

图 8 作业③ 入库校验:从 ranking.db 读回名校表

图 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,三个面板配合起来,定位一个页面的数据来源通常不超过两分钟。

posted @ 2026-11-20 00:25  102580126黄喆珺  阅读(0)  评论(0)    收藏  举报