数据采集第二次作业:天气预报、股票行情与大学排名采集

数据采集实验二:天气预报、股票行情与大学排名采集

学号姓名: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 张抓取日志表。设计上有两个细节:

  1. 唯一约束:weather_forecast 用 (city_code, forecast_date) 唯一,
    stock_info 用股票代码做主键,university_rank 用 (year, university) 唯一。
    配合 INSERT ... ON CONFLICT DO UPDATE,重复运行爬虫只会更新数据,不会产生重复行。
  2. 抓取日志:每次运行都往 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>

解析时有三个"坑":

  1. 页面只有"几日",没有年和月。若直接拼当前年份,遇到跨年(12 月 31 日预测
    1 月 1 日)就会出错。解决办法是读页面隐藏域
    <input id="fc_24h_internal_update_time" value="2026110720">,取前 8 位解析出
    基准日期,再按序号往后推。
  2. "今天"的气温只有一个数。中国气象网在每天 20:00 之后不再显示当天的最高气温,
    p.tem 里只剩 <i>20℃</i>。代码对此做了区分:只有 <i> 时记最低气温,
    最高气温存 NULL(表格里显示 --),而不是拿当前温度冒充最高温。
  3. 风向藏在属性里。风向文字不在标签内容中,而在 <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 条):

weather_run

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

weather_chart

(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)     -- 同城同日只保留一条
);

db_summary

1.1.3 任务②:东方财富网股票行情(requests + json)

(1)F12 抓包分析过程
  1. 打开 https://quote.eastmoney.com/center/gridlist.html,按 F12 打开开发者工具,
    切到 Network(网络) 面板,勾选 Fetch/XHR 过滤;
  2. 刷新页面,可以看到列表数据不是写在 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
  1. 切换到 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}
    ]
  }
}
  1. 逐个参数试验后可以确认各参数的作用(这也是本次实验最有意思的一步):
参数 作用 常用取值
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 返回字段 按需增删,见下表
  1. 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)运行结果

stock_run

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

stock_chart

(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 复现 → 入库结果):

f12_api_analysis

说明: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 运行结果

university_run

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

university_chart

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 条记录。

参考资料

posted @ 2026-11-07 18:55  Truly_Beary  阅读(11)  评论(0)    收藏  举报