1. 为什么你需要一个自己的汇率监控工具？

如果你经常关注人民币汇率，或者你的工作、生意和外汇有点关系，那你肯定有过这样的经历：时不时就要打开手机银行或者财经网站，手动刷新一下页面，看看最新的牌价是多少。做外贸的朋友可能更头疼，报价的时候得算汇率，收款的时候也得盯着，生怕汇率波动把利润给“吃”掉一部分。我以前做跨境相关的项目时，就深受其苦，一天要看好几十遍，效率低不说，还容易错过关键的价格变动点。

后来我就想，这事儿能不能让电脑自动干？每天定时去把数据抓下来，存起来，再画个图给我看，有异常波动还能提醒我一下。这不就是典型的自动化场景吗？说干就干，我用 Python 捣鼓了一个小工具，没想到效果出奇的好。现在，我每天打开电脑，最新的汇率走势图已经自动生成好了，历史数据也整整齐齐地躺在表格里，需要分析的时候特别方便。

这个工具的核心，其实就是三步走：抓取数据、存储数据、可视化数据。听起来高大上，但用 Python 来实现，真的没有想象中那么难。哪怕你之前没怎么写过爬虫，只要跟着我的步骤走，一两个小时就能搭出一个能跑起来的监控系统。它特别适合这几类朋友：对金融数据感兴趣的编程新手、需要监控汇率波动的跨境电商从业者、学习数据分析想找个实战项目练手的学生，以及任何想把自己从重复性劳动中解放出来的“懒人”。

接下来，我就手把手带你走一遍这个完整的流程。我们会用到 requests 库去网站“拿”数据，用 pandas 库来整理和存储数据，最后用 matplotlib 画出生动的图表。整个过程我会把踩过的坑、需要注意的细节都讲清楚，保证你看完就能动手做出来。

2. 环境准备与核心库安装

工欲善其事，必先利其器。在开始写代码之前，我们得先把“厨房”收拾好，把需要的“食材”和“厨具”备齐。这里说的就是 Python 环境和几个关键的库。

2.1 Python 环境搭建

首先，确保你的电脑上已经安装了 Python。我强烈建议使用 Python 3.7 或更高的版本，因为很多新库对老版本的支持可能不太好。怎么检查呢？打开你的命令行（Windows 上是 CMD 或 PowerShell，Mac 或 Linux 上是 Terminal），输入 python --version 或者 python3 --version。如果能看到类似 Python 3.9.13 这样的版本号，那就没问题。如果没有，你需要去 Python 官网下载安装包进行安装，记得在安装时勾选“Add Python to PATH”这个选项，这样在命令行里就能直接调用了。

我个人习惯使用 Anaconda 来管理 Python 环境，特别是做数据分析的时候。Anaconda 自带了很多科学计算和数据分析的库（比如我们马上要用的 pandas 和 matplotlib），而且可以创建相互隔离的虚拟环境，避免不同项目之间的库版本冲突。如果你还没安装，可以去 Anaconda 官网下载安装，步骤很简单。安装好后，你可以创建一个专门用于这个项目的新环境，比如叫 forex-monitor：

conda create -n forex-monitor python=3.9
conda activate forex-monitor

激活环境后，你的命令行前面会显示 (forex-monitor)，表示你已经在这个独立的环境里了。

2.2 安装必备的 Python 库

我们的项目主要依赖四个库，它们各自扮演着重要的角色：

• requests：这是 Python 里最受欢迎的 HTTP 库，我们用它来向目标网站发送请求，获取包含汇率数据的网页内容。它用起来非常直观，功能强大。
• pandas：数据分析的“瑞士军刀”。我们抓下来的原始数据通常是表格形式的 HTML，pandas 可以非常轻松地把它读成一个结构化的 DataFrame（你可以理解为 Excel 里的一个工作表），方便我们进行筛选、清洗、计算和保存。
• matplotlib：Python 绘图库的“老大哥”，功能极其全面。我们用它来将汇率数据转换成折线图、柱状图，让枯燥的数字变成一眼就能看懂的视觉信息。
• tqdm：这是一个“锦上添花”的库，用来在命令行里显示漂亮的进度条。当我们需要处理大量历史数据文件时，有个进度条能让你清楚知道程序运行到哪了，体验会好很多。

安装它们非常简单。在你的命令行（确保已经激活了正确的 Conda 环境或系统 Python 环境）中，输入以下命令：

pip install requests pandas matplotlib tqdm

pip 是 Python 的包管理工具，它会自动从网络上下载这些库以及它们依赖的其他库。如果安装速度慢，可以考虑使用国内的镜像源，比如清华的源：pip install -i https://pypi.tuna.tsinghua.edu.cn/simple requests pandas matplotlib tqdm。

安装完成后，可以写个简单的测试脚本验证一下：

import requests
import pandas as pd
import matplotlib.pyplot as plt
from tqdm import tqdm
import time

print(“所有库导入成功！”)

运行这个脚本如果没有报错，那么恭喜你，准备工作全部就绪，我们可以进入最核心的环节了。

3. 实战第一步：从网站抓取实时汇率数据

数据是这一切的基础。我们的目标是某个权威金融机构网站发布的汇率信息页面。这里非常重要的一点是，我们必须以合法、合规且尊重网站规则的方式获取数据。这意味着我们要模拟一个普通浏览器的访问行为，而不是用程序恶意地、高频地去“攻击”网站服务器。通常，查看目标网站的 robots.txt 文件（一般在网站根目录，如 https://example.com/robots.txt）可以了解哪些路径允许爬虫访问。

3.1 分析网页结构与构造请求

首先，我们得弄清楚数据在哪，以及怎么拿到它。打开你常用的浏览器（Chrome、Edge 等），访问目标网址。按 F12 打开开发者工具，切换到 Network（网络）标签页。然后你在页面上选择一种货币（比如港币），点击查询。这时，Network 标签页里会刷出一堆新的请求。

我们需要找到那个真正返回数据表格的请求。通常，它会是一个 POST 请求（因为提交了查询表单），名字可能和页面本身类似。点击这个请求，查看它的 Headers（标头）和 Payload（负载，在有些浏览器里叫 Request Body 或 Form Data）。这里包含了我们程序需要模仿的所有信息。

请求头（Headers） 里最重要的是 User-Agent，它告诉服务器我们是什么类型的浏览器。如果我们直接用 Python 的 requests 库而不设置这个，有些网站会拒绝服务。所以我们把从浏览器里复制过来的 User-Agent 字符串放到代码里。此外，Content-Type 告诉服务器我们提交的数据格式，对于表单通常是 application/x-www-form-urlencoded。Host 和 Origin 等字段也一并复制过来，增加请求的“真实性”。

请求体（Payload/Form Data） 是关键中的关键，它包含了查询参数。以我抓取的网站为例，参数包括：

• erectDate：查询起始日期
• nothing：查询结束日期（这里留空可能代表查当天）
• pjname：货币名称，如“港币”、“美元”
• page：页码

我们的代码需要构造一个字典来存放这些参数。这里有个小技巧，对于中文的货币名称，直接写中文就可以，requests 库配合 urlencode 会处理好编码问题。

3.2 编写数据抓取函数

理解了原理，我们就可以动手写函数了。我把这个核心函数命名为 get_rate。它的任务很明确：发送请求，拿到响应，从响应中提取表格数据，保存到本地，并打印一条日志。

import time
import requests
from urllib.parse import urlencode
import datetime
import pandas as pd
import os

# 目标网址
url = ‘https://srh.bankofchina.com/search/whpj/search_cn.jsp’

# 模仿浏览器的请求头
headers = {
    ‘User-Agent’: ‘Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/94.0.4606.81 Safari/537.36 Edg/94.0.992.47’,
    ‘Content-Type’: ‘application/x-www-form-urlencoded’,
    ‘Host’: ‘srh.bankofchina.com’,
    ‘Origin’: ‘https://srh.bankofchina.com’,
    ‘Referer’: ‘https://srh.bankofchina.com/search/whpj/search_cn.jsp’,
}

# 查询参数
data = {
    ‘erectDate’: ‘’,  # 起始时间，留空通常代表当天
    ‘nothing’: ‘’,     # 结束时间，留空
    ‘pjname’: ‘港币’, # 这里可以改成你想查询的货币，如‘美元’、‘欧元’
    ‘page’: 1,         # 页码
}

def get_rate():
    “”“抓取指定货币的实时汇率数据”“”
    # 将参数字典编码为表单格式
    encoded_data = urlencode(data)

    # 发送POST请求
    # 这里有个细节：`data`参数直接传字典，requests会自动编码，但有时需要显式使用urlencode后的字符串
    # 根据目标网站实际情况调整，我测试时直接传字典是可行的。
    response = requests.post(url, data=data, headers=headers)

    # 检查请求是否成功
    if response.status_code != 200:
        print(f“请求失败，状态码：{response.status_code}”)
        return None

    # pandas 的神奇功能：直接解析HTML中的表格
    # read_html 会返回一个DataFrame的列表，每个DataFrame对应网页中的一个表格
    # 我们需要通过观察确定哪个表格是我们需要的，这里假设是第二个（索引为1）
    df_list = pd.read_html(response.text)
    target_df = df_list[1]  # 根据实际情况调整索引

    # 数据清洗：删除无用的列和空行
    # 首先查看一下DataFrame的列名，看看哪些是多余的
    # print(target_df.columns)
    # 假设我们发现了一些名为‘Unnamed: x’的列需要删除
    columns_to_drop = [col for col in target_df.columns if ‘Unnamed’ in str(col)]
    cleaned_df = target_df.drop(columns=columns_to_drop).dropna()

    # 创建按日期分类的文件夹
    today_str = time.strftime(“%Y-%m-%d”, time.localtime())
    save_dir = f‘./rate_data/{today_str}’
    if not os.path.exists(save_dir):
        os.makedirs(save_dir)

    # 保存到Excel文件，用时间戳命名避免重复
    timestamp = int(time.time())
    save_path = f‘{save_dir}/{timestamp}.xlsx’
    cleaned_df.to_excel(save_path, index=False)
    print(f“[{datetime.datetime.now().strftime(‘%Y-%m-%d %H:%M:%S’)}] 数据已保存至：{save_path}”)
    print(f“最新现汇买入价：{cleaned_df[‘现汇买入价’].iloc[0]}， 现汇卖出价：{cleaned_df[‘现汇卖出价’].iloc[0]}”)

    return cleaned_df

这个函数已经具备了完整的抓取、解析、保存和日志功能。你可以单独运行它测试一下：df = get_rate()，如果一切顺利，你会看到控制台打印出成功信息，并且在当前目录下的 rate_data/今日日期 文件夹里生成了一个 Excel 文件。

4. 让数据“活”起来：实时可视化与监控

把数据存到硬盘里只是第一步，我们更希望能直观地看到它的变化。一个自动更新的图表，远比翻看一堆数字文件要直观得多。这就是可视化的威力。我们将创建一个动态图表，它能每隔一段时间（比如30秒）自动抓取一次最新数据，并更新到图表上，形成一条实时延伸的汇率曲线。

4.1 使用 Matplotlib 创建动态图表

matplotlib 不仅擅长画静态图，通过 plt.pause() 函数，我们也能实现简单的动画效果。思路是：在一个无限循环中，每次循环抓取一次数据，将新数据点添加到图表的数据序列中，然后重绘图表，并暂停一段时间。

import matplotlib.pyplot as plt

def plot_realtime_rate():
    “”“绘制并实时更新汇率走势图”“”
    plt.ion()  # 打开交互模式，允许图表动态更新
    fig, ax = plt.subplots(figsize=(12, 6))  # 创建图形和坐标轴

    # 初始化数据列表
    time_points = []  # 用来记录时间点或数据点序号
    buying_rates = [] # 现汇买入价序列
    selling_rates = [] # 现汇卖出价序列

    # 设置图表样式
    ax.set_title(‘人民币兑港币汇率实时走势’, fontsize=16, fontweight=‘bold’)
    ax.set_xlabel(‘数据点序列’, fontsize=12)
    ax.set_ylabel(‘汇率’, fontsize=12)
    ax.grid(True, linestyle=‘--’, alpha=0.6) # 添加网格线，更美观
    ax.legend([‘现汇买入价’, ‘现汇卖出价’])

    print(“开始实时监控，图表窗口已打开。关闭窗口可终止程序。”)

    point_counter = 0
    while True:
        try:
            # 1. 获取最新数据
            df = get_rate()
            if df is not None and not df.empty:
                latest_buy = df[‘现汇买入价’].iloc[0]
                latest_sell = df[‘现汇卖出价’].iloc[0]
                latest_time = df[‘发布时间’].iloc[0]

                # 2. 更新数据序列
                point_counter += 1
                time_points.append(point_counter)
                buying_rates.append(latest_buy)
                selling_rates.append(latest_sell)

                # 3. 清空当前轴，重新绘制（这是最简单的动态更新方式）
                ax.clear()
                # 重新设置标题和标签（因为clear()会清掉它们）
                ax.set_title(f‘人民币兑港币汇率实时走势 (最新更新：{latest_time})’, fontsize=16, fontweight=‘bold’)
                ax.set_xlabel(‘数据点序列’, fontsize=12)
                ax.set_ylabel(‘汇率’, fontsize=12)
                ax.grid(True, linestyle=‘--’, alpha=0.6)

                # 4. 绘制两条折线
                ax.plot(time_points, buying_rates, ‘b-’, marker=‘o’, label=‘现汇买入价’, linewidth=2)
                ax.plot(time_points, selling_rates, ‘r-’, marker=‘s’, label=‘现汇卖出价’, linewidth=2)
                ax.legend(loc=‘upper left’)

                # 5. 在图上标注最新数值
                ax.annotate(f‘买入：{latest_buy}’, xy=(point_counter, latest_buy), xytext=(10, 10),
                           textcoords=‘offset points’, color=‘blue’, fontweight=‘bold’)
                ax.annotate(f‘卖出：{latest_sell}’, xy=(point_counter, latest_sell), xytext=(10, -20),
                           textcoords=‘offset points’, color=‘red’, fontweight=‘bold’)

                # 6. 自动调整坐标轴范围，让曲线始终在视图中央
                ax.relim()
                ax.autoscale_view()

                # 7. 暂停一段时间，并刷新图形
                plt.pause(30)  # 暂停30秒，然后进入下一轮循环

        except KeyboardInterrupt:
            # 用户按 Ctrl+C 中断程序
            print(“\n监控程序被用户中断。”)
            plt.ioff() # 关闭交互模式
            plt.show(block=True) # 阻塞显示最终图表
            break
        except Exception as e:
            # 处理其他异常，比如网络错误
            print(f“获取数据时发生错误：{e}， 1分钟后重试...”)
            time.sleep(60)

运行 plot_realtime_rate() 函数，一个图表窗口会弹出来。你会看到两条曲线（蓝色买入价和红色卖出价）随着时间一点点向右延伸。图表标题会显示最新的更新时间，最新数据点旁边还有清晰的数值标注。这个动态看板对于需要时刻关注汇率波动的场景来说，非常实用。

4.2 添加简单的波动预警机制

光是看图还不够，我们可能希望在汇率波动超过某个阈值时，能得到更主动的提醒。我们可以在上面的循环里加入一个简单的判断逻辑。

def plot_realtime_rate_with_alert(alert_threshold=0.02):
    “”“带波动预警的实时监控”“”
    # ... [前面的初始化代码与上面函数相同] ...

    previous_buy = None
    while True:
        try:
            df = get_rate()
            if df is not None and not df.empty:
                latest_buy = df[‘现汇买入价’].iloc[0]
                # ... [更新图表代码与上面相同] ...

                # 预警逻辑
                if previous_buy is not None:
                    change = abs((latest_buy - previous_buy) / previous_buy)
                    if change > alert_threshold:
                        # 这里可以替换成更醒目的提醒方式，比如播放声音、发送邮件等
                        print(f“⚠️  警报！汇率波动超过 {alert_threshold*100:.1f}%！当前波动：{change*100:.2f}%”)
                        # 在图表上用醒目颜色标记这个点
                        ax.plot(point_counter, latest_buy, ‘y*’, markersize=15, markeredgewidth=2, markeredgecolor=‘black’)

                previous_buy = latest_buy
                plt.pause(30)
        except KeyboardInterrupt:
            # ... [中断处理代码] ...

这样，当相邻两次抓取的数据波动幅度超过你设定的比例（默认2%）时，控制台会打印警报信息，并且在图表上对应的数据点处画一个黄色的星号。你可以把这个阈值 (alert_threshold) 调成你需要的任何值。

5. 数据的持久化与历史分析

实时监控很重要，但历史数据同样宝贵。它能帮助我们分析长期趋势、发现规律、回溯异常。我们之前已经将每次抓取的数据都按日期保存到了单独的 Excel 文件里。现在，我们需要一个工具，能把散落在各处的数据文件合并起来，形成一个完整的历史数据集，方便我们进行更宏观的分析。

5.1 合并多日数据文件

随着程序运行天数增加，rate_data 文件夹下会产生很多以日期命名的子文件夹，每个子文件夹里又有多个以时间戳命名的 Excel 文件。我们需要一个脚本来遍历所有文件夹，读取所有 Excel 文件，然后把它们合并成一个大表格。

这里用到了 os.walk 来递归遍历目录，以及 tqdm 来显示合并进度，体验会好很多。

from tqdm import tqdm

def merge_historical_data(data_root_dir=‘./rate_data’):
    “”“合并指定根目录下所有的汇率数据Excel文件”“”
    all_excel_files = []

    print(“正在扫描数据文件...”)
    # os.walk 会遍历根目录下的所有子文件夹
    for root, dirs, files in os.walk(data_root_dir):
        for file in files:
            if file.endswith(‘.xlsx’): # 只处理.xlsx文件
                file_path = os.path.join(root, file)
                all_excel_files.append(file_path)

    if not all_excel_files:
        print(“未找到任何数据文件。”)
        return None

    print(f“共找到 {len(all_excel_files)} 个数据文件，开始合并...”)

    merged_df = pd.DataFrame() # 创建一个空的DataFrame作为容器

    # 使用tqdm包装循环，显示进度条
    for file_path in tqdm(all_excel_files, desc=“合并进度”):
        try:
            # 读取单个Excel文件
            df_single = pd.read_excel(file_path)
            # 使用pd.concat进行纵向合并，比已废弃的.append方法更高效
            merged_df = pd.concat([merged_df, df_single], ignore_index=True)
        except Exception as e:
            print(f“读取文件 {file_path} 时出错：{e}，已跳过。”)

    # 数据去重与排序
    # 由于我们可能在不同时间抓取了同一发布时刻的数据，需要去重
    # 假设‘发布时间’字段可以唯一标识一条记录
    if ‘发布时间’ in merged_df.columns:
        merged_df = merged_df.drop_duplicates(subset=[‘发布时间’])
        merged_df = merged_df.sort_values(by=‘发布时间’) # 按时间排序
        merged_df.reset_index(drop=True, inplace=True) # 重置索引

    # 保存合并后的数据
    output_path = ‘./merged_historical_rate_data.xlsx’
    merged_df.to_excel(output_path, index=False)
    print(f“数据合并完成！共 {len(merged_df)} 条记录，已保存至：{output_path}”)

    return merged_df

运行这个函数，它会自动帮你把几个月甚至几年的数据都整理到一个文件里。tqdm 的进度条让你对合并进度一目了然，处理成百上千个文件时也不会觉得程序“卡住了”。

5.2 基于历史数据的趋势分析

有了完整的历史数据，我们就可以玩出更多花样了。比如，绘制某个月份的汇率日K线图（需要计算每日的开盘、收盘、最高、最低价），或者计算移动平均线来平滑短期波动、观察长期趋势。

这里举个简单的例子，绘制历史数据的完整走势图，并添加一条30期（假设每次抓取是一个“期”）的简单移动平均线（SMA）。

def analyze_historical_trend(merged_data_path=‘./merged_historical_rate_data.xlsx’):
    “”“分析历史汇率趋势”“”
    try:
        df = pd.read_excel(merged_data_path)
        # 确保‘发布时间’是datetime类型
        df[‘发布时间’] = pd.to_datetime(df[‘发布时间’])
        df = df.sort_values(‘发布时间’)

        # 计算30期简单移动平均线
        df[‘买入价_30期SMA’] = df[‘现汇买入价’].rolling(window=30, min_periods=1).mean()
        df[‘卖出价_30期SMA’] = df[‘现汇卖出价’].rolling(window=30, min_periods=1).mean()

        # 开始绘图
        plt.figure(figsize=(16, 8))
        plt.plot(df[‘发布时间’], df[‘现汇买入价’], ‘b-’, label=‘现汇买入价’, alpha=0.7, linewidth=1)
        plt.plot(df[‘发布时间’], df[‘现汇卖出价’], ‘r-’, label=‘现汇卖出价’, alpha=0.7, linewidth=1)
        plt.plot(df[‘发布时间’], df[‘买入价_30期SMA’], ‘g--’, label=‘买入价30期均线’, linewidth=2)
        plt.plot(df[‘发布时间’], df[‘卖出价_30期SMA’], ‘orange’, linestyle=‘--’, label=‘卖出价30期均线’, linewidth=2)

        plt.title(‘人民币兑港币历史汇率走势与移动平均线’, fontsize=18, fontweight=‘bold’)
        plt.xlabel(‘发布时间’, fontsize=14)
        plt.ylabel(‘汇率’, fontsize=14)
        plt.legend(loc=‘best’)
        plt.grid(True, linestyle=‘--’, alpha=0.5)
        plt.xticks(rotation=45) # 旋转x轴标签，避免重叠
        plt.tight_layout() # 自动调整子图参数，使之填充整个图像区域

        # 保存分析图表
        plt.savefig(‘./historical_trend_analysis.png’, dpi=300)
        print(“历史趋势分析图已保存为 ‘historical_trend_analysis.png’”)
        plt.show()

    except FileNotFoundError:
        print(f“未找到合并数据文件：{merged_data_path}，请先运行 merge_historical_data() 函数。”)
    except Exception as e:
        print(f“分析过程中出现错误：{e}”)

这张图的信息量就比实时监控图大多了。你可以清晰地看到汇率的长期走向，以及移动平均线如何过滤掉“毛刺”，揭示出更稳定的趋势。这对于判断未来一段时间的汇率走向非常有参考价值。

6. 进阶优化与部署建议

一个能跑起来的工具是第一步，但要让它真正可靠、好用，能7x24小时稳定运行，还需要一些“打磨”。这里分享几个我踩过坑之后总结的优化点和部署思路。

6.1 提升代码的健壮性

网络是不稳定的，网站也可能改版。我们的程序必须能应对各种意外。

1. 增加重试机制：网络请求偶尔失败很正常。我们可以用 try...except 包裹请求代码，并在失败后等待几秒重试几次。可以使用 requests 库的 Session 对象，或者第三方库 retrying 来优雅地实现重试逻辑。
2. 异常处理与日志记录：不要只是 print 错误信息。应该使用 Python 内置的 logging 模块，将程序运行状态、错误信息记录到文件里。这样即使程序在后台运行，出了问题我们也能通过查看日志文件来排查。可以设置不同级别的日志（INFO, WARNING, ERROR），方便过滤。
3. 应对网站结构变化：网站前端改版是爬虫的天敌。我们的代码依赖 pd.read_html(response.text)[1] 来定位表格，如果网站结构调整，这里就会出错。一个更稳健的做法是，在解析 HTML 时，不只依赖索引，而是结合表格的某些特征（比如表头文字包含“货币名称”、“现汇买入价”等）来定位正确的表格。
4. 设置合理的抓取间隔：在 plot_realtime_rate 函数中，我们用了 plt.pause(30)，即30秒抓一次。这个频率需要谨慎设置。过于频繁的请求会给对方服务器带来压力，也可能导致你的 IP 被暂时限制访问。对于汇率数据，分钟级甚至小时级的更新通常就足够了。务必尊重网站的 robots.txt 规则。

6.2 部署到服务器实现自动化运行

你不可能一直开着个人电脑运行这个脚本。最好的方式是把它部署到一台云服务器上，让它全天候自动工作。

1. 方案一：使用系统定时任务（Cron Job）。这是最经典、最稳定的方法。你可以写一个只负责抓取和保存数据的脚本（比如叫 crawl_rate.py），然后在 Linux 服务器上使用 crontab -e 命令添加一条定时任务。例如，*/30 * * * * /usr/bin/python3 /path/to/your/crawl_rate.py 表示每30分钟运行一次。数据保存后，你可以再写一个单独的脚本，定期（比如每天）执行数据合并和分析，生成报告图表。
2. 方案二：使用 Python 调度库。如果你希望所有逻辑都还在一个 Python 程序里管理，可以使用 schedule 或 APScheduler 这样的库。它们允许你在代码中定义类似“每30分钟执行一次 get_rate 函数”这样的任务，程序会作为一个常驻进程运行。这种方式更灵活，但需要确保进程不会意外退出，可以考虑配合 supervisor 这样的进程管理工具。
3. 方案三：无服务器函数（Serverless）。像阿里云的函数计算、腾讯云的云函数等，可以让你按需运行代码，无需管理服务器。你可以将抓取函数打包部署，并设置为定时触发。这对于轻量级、低频次的任务来说非常经济高效。

6.3 扩展功能设想

这个基础框架有很大的扩展空间：

• 多货币监控：修改 data 字典中的 pjname 参数，用一个循环来遍历 [‘美元’， ‘欧元’， ‘日元’， ‘英镑’] 等多种货币，实现一图监控多币种。
• 数据存储升级：当数据量非常大时，Excel 可能不是最佳选择。可以考虑存入 SQLite（轻量级数据库）或者 MySQL、PostgreSQL 等专业数据库中，方便进行复杂的 SQL 查询和分析。
• 通知提醒：将预警机制升级，当波动超过阈值时，不仅打印日志，还可以通过邮件（使用 smtplib 库）、企业微信、钉钉机器人或者 Telegram Bot 发送消息到你的手机，实现真正的即时告警。
• Web 仪表盘：使用 Flask 或 Streamlit 这样的轻量级 Web 框架，将数据和图表封装成一个简单的网页。这样你可以在任何地方的浏览器上查看监控面板，体验更佳。Streamlit 尤其适合快速将数据脚本转化为交互式应用。

我在实际项目中，最终就把它做成了一个集成多币种监控、异常邮件告警、并拥有简单 Web 看板的小系统。从最初的一个脚本演化过来，每一步都是根据实际需求慢慢添加的。编程的乐趣就在于此，你可以从一个简单的想法出发，亲手搭建出一个能解决实际问题的工具。希望这个实战项目能给你带来同样的成就感。