Parquet 文件入门 Python 读写 Parquet 文件实战 大数据存储优化：Parquet 格式解析 Python 数据分析必备：Parquet 文件处理技巧 列式存储揭秘：Parquet 文件与性能优化 使用 Python 和 PyArrow 处理嵌套 Parquet 数据 从 CSV 到 Parquet：Python 数据格式转换教程

什么是 Parquet 文件？

为什么使用 Parquet？

• 列式存储：按列存储数据，提高分析任务的查询性能。
• 压缩：支持高效的压缩技术，减少存储空间。
• 兼容性：可与多种数据处理框架配合使用。
• 模式演进：支持增加或删除列而不破坏现有数据。

安装所需库

pip install pandas pyarrow

在 Python 中读取 Parquet 文件

import pandas as pd
import pyarrow.parquet as pq

# Parquet 文件路径
file_path = "example.parquet"

# 读取 Parquet 文件到 DataFrame
df = pd.read_parquet(file_path)

# 显示前 5 行
print(df.head())

写入 Parquet 文件

import pandas as pd

# 创建示例 DataFrame
data = {
    "name": ["Alice", "Bob", "Charlie"],
    "age": [25, 30, 35],
    "city": ["London", "Paris", "New York"]
}
df = pd.DataFrame(data)

# 保存为 Parquet
df.to_parquet("output.parquet", engine="pyarrow", index=False)

处理嵌套数据

import pyarrow.parquet as pq
from io import BytesIO

# 直接读取 Parquet 文件
table = pq.read_table("example.parquet")
df = table.to_pandas()
print(df.head())

总结

使用原子 TAS 指令实现自旋锁

使用原子 TAS 指令实现自旋锁 Implementing a Spinlock Using the Atomic TAS Instruction 从零实现自旋锁：基于 TAS 的最小同步原语 Building a Spinlock from Scratch with Atomic TAS 用 test-and-set 实现最简单的互斥锁 Implementing a Minimal Mutex Using Test-and-Set 自旋锁的底层原理：TAS、原子性与忙等待 Inside Spinlocks: TAS, Atomicity, and Busy Waiting 原子操作与自旋锁：用 C 语言实现线程同步 Atomic Operations and Spinlocks: Thread Synchronization in C 从原子指令到锁：全面理解 TAS 和自旋锁 From Atomic Instructions to Locks: A Complete Guide to TAS and Spinlocks 动手写一个自旋锁：tryLock / lockAcquire / lockRelease 全实现 Hands-On Spinlock Implementation: tryLock, lockAcquire, and lockRelease 你的第一个自旋锁：基于 C 语言的 TAS 实现 Your First Spinlock: A TAS-Based Implementation in C 原子交换与线程互斥：自旋锁实现指南 Atomic Exchange and Thread Mutual Exclusion: A Guide to Implementing Spinlocks

int TAS(int* memory, int newVal) {
    int old = *memory;
    *memory = newVal;
    return old;
}

• lockAcquire()
• lockRelease()

typedef struct {
    int lock;
} lockType;

typedef struct {
    int val;
} threadArgType;

void threadFunc(void* arg) {
    lockAcquire((static_cast<lockType*>arg)->lock);
    (static_cast<threadArgType*>arg)->val++;
    lockRelease((static_cast<lockType*>arg)->lock);
}

实现 tryLock

enum {
    UNLOCKED = 0,
    LOCKED = 1
}

int tryLock(lockType* lock) {
    // 如果之前已锁定返回 1，如果之前未锁定返回 0
    int old = TAS(lock->lock, LOCKED);
    return (old == UNLOCKED);   // true (1) = 成功获取锁
}

实现 lockAcquire()

void lockAcquire(lockType* lock) {
    while (!tryLock(lockType* lock)) {
        // 自旋直到锁可用
    }
}

void lockAcquire(lockType* lock) {
    do {
       if (tryLock(lockType* lock)) {
          break;
       }
    } while (1);
}

void lockAcquire(lockType* lock) {
    do {
       int old = TAS(lock->lock, LOCKED);
       // 无论锁是否已被获取，锁都已设置为 LOCKED
       if (old == UNLOCKED) {
           break;
       }
    } while (1);
}

实现 lockRelease()

void lockRelease(lockType* lock) {
    TAS(lock->lock, UNLOCKED);
}

总结

• 一个 tryLock() 尝试
• 一个 lockAcquire() 自旋锁
• 一个 lockRelease() 解锁操作

理解 Sigma 函数：因子、乘法性与公式推导

一文看懂 Sigma 函数：因子分解的终极威力！ σ(n) 完全解析：为什么求和函数能“自动”变成乘积？ 数学之美：Sigma 函数的推导、公式与 Python 实现 从几何级数到质因数：Sigma 函数的魔法公式大揭秘 搞懂 σ(n) 的那一天，我看到了数学的秩序 为什么 σ(n) = 乘积？带你走进数论的核心思想 Divisor 终极指南：Sigma 函数推导 + 代码 一篇搞定

可除性符号

质因数分解与因子的结构

关键性质：Sigma 函数是乘法性的

质数幂的 Sigma 公式

示例：计算 σ(12)

Python 实现：高效的 Sigma 函数

def sigma(n: int) -> int:
    """高效计算因子和函数 σ(n)。"""
    total = 1
    x = n

    # 处理质因数 2
    count = 0
    while x % 2 == 0:
        x //= 2
        count += 1
    if count > 0:
        total *= (2 ** (count + 1) - 1) // (2 - 1)

    # 处理奇质数
    p = 3
    while p * p <= x:
        if x % p == 0:
            count = 0
            while x % p == 0:
                x //= p
                count += 1
            total *= (p ** (count + 1) - 1) // (p - 1)
        p += 2

    # 若剩下的是质数
    if x > 1:
        total *= (x**2 - 1) // (x - 1)

    return total

结语

Amdahl 定律 vs Gustafson 定律 — 完整教程、推导、应用场景及 Python 绘图

Amdahl 定律 vs Gustafson 定律：完整教程、推导、应用场景及 Python 绘图 理解并行加速：通过代码讲解 Amdahl 定律和 Gustafson 定律 并行计算基础：Amdahl 定律、Gustafson 定律及加速建模 并行加速原理：Amdahl 和 Gustafson 定律完整指南 并行扩展解析：推导并比较 Amdahl 和 Gustafson 定律 Amdahl vs Gustafson：并行加速完整指南（含 Python 代码） 并行性能建模：Amdahl 定律、Gustafson 定律及实际应用 学习并行加速：数学、直觉、应用场景及 Python 可视化 并行计算：必须掌握的两条定律（Amdahl & Gustafson） 工程师的并行加速：Amdahl 定律、Gustafson 定律及 Python 实现 从理论到代码：用 Amdahl 和 Gustafson 建模并行加速 实用并行加速指南：Amdahl 定律、Gustafson 定律及可视化 为什么并行不是无限的：简单解释 Amdahl vs Gustafson 并行加速真相：Amdahl 限制 vs Gustafson 扩展 并行计算神话与现实：Amdahl 和 Gustafson 的教训

引言

• Amdahl 定律 — 固定规模工作负载的性能
• Gustafson 定律 — 可扩展规模工作负载的性能

1. 什么是加速比？

2. Amdahl 定律（固定工作量）

2.1 直觉

• 总工作量保持 不变
• 部分工作是串行的，无法并行化

• f = 串行比例
• 1 - f = 可并行比例

2.2 推导

2.3 当 N → ∞ 时的极限

2.4 Amdahl 定律的实际应用场景

• GPU 内核优化固定张量大小
• 单次请求推理延迟降低
• 视频编码、压缩、排序
• 加速固定批量作业
• 数据库查询加速

3. Gustafson 定律（可扩展工作量）

3.1 直觉

3.2 推导

• f = 串行比例（按规模测量）

3.3 解释

3.4 Gustafson 定律的实际应用场景

• 天气和气候模拟
• 粒子模拟、CFD、有限元分析
• LLM 训练：更多 GPU → 更长序列或更大模型
• 大数据分析（Spark, Dask, Flink）
• 蒙特卡洛模拟

4. Amdahl 定律 vs Gustafson 定律（比较表）

5. 实际应用场景（综合视角）

Amdahl（延迟优化）

• 减少单次 LLM 查询推理时间
• 加速数据库 join 操作
• 固定张量 GPU 内核优化
• 视频编码（相同视频）

Gustafson（吞吐量 / 扩展）

• LLM 训练（扩展至更多 GPU）
• 高分辨率天气模型模拟
• 大数据 ETL 扩展
• 科学 HPC 工作负载

6. Python 绘图脚本（显示两条定律）

图示解读

• Amdahl 曲线迅速趋于平缓——受串行部分限制。
• Gustafson 曲线几乎线性上升——适用于可扩展工作负载。
• 串行比例 f 越高，两种模型差距越大。

结论

• Amdahl 定律 → 固定规模工作负载 → 收益递减
• Gustafson 定律 → 可扩展工作负载 → 近似线性加速
• 结合使用理解硬件极限与算法特性
• Python 工具使可视化直观易懂

组合简介（组合数学入门）

格子行走示例 — 从左下到右上路径

R R U R U U R R R U R U R R U R R R U U U U R R R 

二项式系数（组合）表示法

组合公式 — 基于阶乘的推导

把公式应用到格子示例

为什么这个公式直观上合理

• 视角一 — 选择位置：从 [math]n[/math] 个位置中选择放置 U 的 [math]m[/math] 个位置；这就是 [math]C(n,m)[/math]。
• 视角二 — 用排列除以顺序：先计算 n 步的所有排列，然后除去相同步序的重排（比如相同类型步的交换）。

帕斯卡三角与递推关系

 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1 

from functools import cache

@cache
def C(n, m):
    if m == 0:
        return 1  # C(n, 0) = 1
    if m == n:
        return 1  # C(n, n) = 1
    return C(n-1, m-1) + C(n-1, m)

def C_bottom_up(n, m):
    dp = [[0]*(m+1) for _ in range(n+1)]
    for i in range(n+1):
        dp[i][0] = 1  # C(i, 0) = 1
        for j in range(1, min(i, m)+1):
            if j == i:
                dp[i][j] = 1  # C(i, i) = 1
            else:
                dp[i][j] = dp[i-1][j-1] + dp[i-1][j]
    return dp[n][m]

def C_one_dim(n, m):
    dp = [0] * (m+1)
    dp[0] = 1  # C(i, 0) = 1

    for i in range(1, n+1):
        # 从右往左更新，避免覆盖上一行数据
        for j in range(min(i, m), 0, -1):
            dp[j] = dp[j] + dp[j-1]
    
    return dp[m]

print(C_one_dim(5, 2))  # 输出 10

• 空间复杂度 O(m)
• 时间复杂度 O(n*m)
• 可以方便扩展计算整行或整列组合数

组合证明 — 采苹果

递推关系的格子解释

常见的小值与说明

 C(5,0)=1 C(5,1)=5 C(5,2)=10 C(5,3)=10 C(5,4)=5 C(5,5)=1 

结语

性能隐藏的引擎：数据存放在哪里决定一切

1. 性能的真正秘密：数据放在哪里决定一切 2. 决定系统快慢的不是 CPU，而是数据的距离 3. 缓存才是现代计算性能的核心 4. 忽视数据局部性，一切性能优化都是徒劳 5. 性能瓶颈不在算力，而在内存层级 6. 数据局部性：被低估的性能决定因素 7. CPU 在等你的内存：缓存层级的真实代价 8. 系统速度快的真正原因：一切都与缓存有关 9. 别再关注 CPU 速度了——数据局部性才是制胜关键 10. 为什么缓存是所有高性能系统的幕后引擎 11. 性能的关键不在于 GHz，而在于距离 12. 你的 CPU 正在等待内存：缓存不为人知的故事 13. 数据局部性：计算机领域最重要却鲜为人知的因素 14. 数据存储位置决定一切 15. 缓存主宰一切：性能指南 16. 内存层次结构：性能的隐形杀手（或救星） 17. 为什么现代性能之战是与延迟的较量，而非与计算能力的较量

为什么缓存主导一切

真正的设计问题： 它能放进缓存吗？

抽象失灵的地方

• 独占核亲和（core pinning） —— 保持线程在同一 CPU 上以维持缓存热度
• 中断合并（interrupt coalescing） —— 降低中断率但以延迟为代价
• NUMA 局部性 —— 跨插槽访问会严重削弱性能
• 物理网卡与虚拟网卡 行为不同

AI 也碰到同样的问题

• 数组优于指针密集的结构，因为内存是连续的
• 硬件预取器只有在访问可预测时才有用
• 当内存布局合理时，缓存行被更高效地利用

在机器人控制中也能看到

IBM Telum：不同量级的缓存

• 十个 36 MB 的 L2 缓存
• 360 MB 的虚拟 L3
• 2.8 GB 的虚拟 L4

结论

我们经常谈论 CPU 速度，却很少关注数据存储的位置。 性能主要取决于数据存储的便利程度。寄存器、L1 缓存、L2 缓存、L3 缓存、主内存——每一步都会增加延迟并降低吞吐量。访问主内存可能需要 200 个时钟周期，比 L1 缓存慢 50 倍。 当工作集能够放入缓存时，代码运行速度极快。否则，CPU 只能等待。 在数据包处理中，这种差异决定了一切。每个数据包都会触发表查找。如果这些表保存在 缓存 中，您可以每秒处理数百万个数据包。否则，吞吐量将急剧下降。 所以，下次设计数据结构时，请问问自己： 它能放进缓存吗？ 因为在对性能要求极高的系统中，缓存不仅仅是一种优化手段，它定义了整个系统。 而且不仅是数据，指令也一样！我见过高频交易工程师讨论他们的策略，他们将热路径编程为始终处于激活状态，并且只在数据包需要离开系统时才启用网卡。这样也能保持指令缓存处于热状态。 保持指令缓存处于热状态与保持数据缓存处于热状态同样重要，尤其是在对可预测性要求很高的工作负载中。优化热路径，使 CPU 始终保持在指令缓存中至关重要，因为即使是很小的停顿也可能导致尾延迟显著增加。这很好地提醒我们，架构设计的真正目的是尽可能地将指令和数据都放在靠近核心的位置。 很多技术决策者都固守一刀切的策略：例如……万物皆可云——他们认为任何虚拟化工作负载都可以在任何虚拟化环境中运行，底层硬件和虚拟化技术都只是商品而已。但这并不适用于虚拟化网络功能，因为厂商们早就知道，独占线程核心绑定可以让执行线程独占使用 CPU 缓存。厂商们也知道，在虚拟化环境中，中断合并可以降低“CPU 使用率”，但会增加延迟。他们了解 NUMA 局部性，甚至把这些都写进了文档里。当然，销售人员来了之后，他们希望与高层战略保持一致，使用最佳优化基准测试，然后就云或虚拟机管理程序支持的问题展开另一场不加任何细节的讨论。没错，这行得通*但附注：你需要三倍的许可证/硬件，而且仍然无法获得最佳性能。人们对底层性能如此缺乏兴趣，技能差距如此之大，以至于似乎只能通过增加抽象层和厂商来掩盖责任。如果珠穆朗玛峰是检验技术领导力还是厂商责任的试金石，那么我们很想知道，究竟是哪一方会坚持到底，还是会在山脚下卖羽绒服。完全正确。一旦你依赖缓存行为、核心绑定和NUMA局部性，平台就不再具有可互换性了。底层细节远比大多数高层策略重要得多。 大多数繁重的AI工作负载仍然会遇到相同的内存层次结构限制。模型规模不断扩大，但芯片内部数据传输的物理机制并没有发生太大变化。理解局部性仍然是获得良好性能的关键。 数组能够为CPU提供它真正需要的东西：连续的内存和可预测的访问模式。这意味着预取器可以真正发挥作用，缓存行可以得到高效利用，并且避免了分散结构带来的指针追踪惩罚。这是保持缓存友好性的最简单方法之一。 机器人多轴运动控制也是如此。第一个轴预热缓存并承受缓存未命中的影响，下一个轴的计算时间缩短了一半。 IBM Telum处理器可以验证这一点，它能够按需将L2缓存转换为L3缓存，并且L4缓存可以被任何其他CPU访问。此外，该芯片的时钟频率始终保持在 5.5 GHz。它包含十个 36 MB 的二级缓存¹，以及扩展的虚拟三级缓存（360 MB）和四级缓存（2.8 GB）。 这是一款令人着迷的芯片。与大多数架构相比，其缓存容量巨大，这让我不禁好奇这会对各级缓存的访问延迟产生怎样的影响。可惜的是，我找不到任何关于 Telum 缓存的公开延迟数据，否则我很想了解 IBM 在实际应用中是如何平衡缓存容量、交换空间距离和命中延迟的。

[caption id="attachment_70386" align="alignnone" width="2017"] Q Learning强化学习算法(机器学习/人工智能)[/caption] 强化学习（Reinforcement Learning, RL）是一种让智能体/Agent通过与环境交互、试错学习来获得最优行为策略的机器学习方法。本文用一个简单的 Q-learning 迷宫示例，帮助你快速理解强化学习的基本原理。

强化学习入门：从试错中学习的艺术 Reinforcement Learning 101: The Art of Learning by Trial and Error 深度解析强化学习：Q-Learning算法详解 Deep Dive into Reinforcement Learning: Understanding the Q-Learning Algorithm 机器如何学会自己做决定？强化学习告诉你答案 How Do Machines Learn to Make Their Own Decisions? Reinforcement Learning Explained 从奖励中学习：人工智能的“试错智慧” Learning from Rewards: The Trial-and-Error Intelligence Behind AI

一、什么是强化学习？

• Agent（智能体）：做决策、执行动作的主体
• Environment（环境）：智能体所处的世界
• State（状态）：当前环境的描述
• Action（动作）：智能体可采取的操作
• Reward（奖励）：环境反馈，用来衡量动作的好坏

二、Q-Learning 原理

• [math] \alpha [/math]：学习率（Learning Rate）
• [math] \gamma [/math]：折扣因子（Discount Factor）
• [math] r [/math]：奖励（Reward）
• [math] s' [/math]：下一状态（Next State）

三、迷宫环境设计

• 0：空地
• -1：墙
• 1：出口（目标）

四、完整 Python 实现代码

import numpy as np
import random

# 1️⃣ 定义迷宫
maze = np.array([
    [0,  0,  0, -1,  1],
    [0, -1,  0, -1,  0],
    [0,  0,  0,  0,  0]
])

n_rows, n_cols = maze.shape
actions = ['up', 'down', 'left', 'right']
Q = np.zeros((n_rows, n_cols, len(actions)))

# 2️⃣ 超参数
alpha = 0.1
gamma = 0.9
epsilon = 0.1
episodes = 500

# 3️⃣ 辅助函数
def is_valid(state):
    r, c = state
    return 0 <= r < n_rows and 0 <= c < n_cols and maze[r, c] != -1

def next_state(state, action):
    r, c = state
    if action == 'up': r -= 1
    elif action == 'down': r += 1
    elif action == 'left': c -= 1
    elif action == 'right': c += 1
    return (r, c)

def get_reward(state):
    r, c = state
    if maze[r, c] == 1: return 10
    elif maze[r, c] == -1: return -1
    return -0.1

# 4️⃣ 训练循环
for episode in range(episodes):
    state = (2, 0)
    done = False

    while not done:
        if random.uniform(0, 1) < epsilon:
            action_idx = random.randint(0, len(actions)-1)
        else:
            action_idx = np.argmax(Q[state[0], state[1]])

        action = actions[action_idx]
        next_s = next_state(state, action)

        if not is_valid(next_s):
            reward = -1
            next_s = state
        else:
            reward = get_reward(next_s)

        Q[state[0], state[1], action_idx] += alpha * (
            reward + gamma * np.max(Q[next_s[0], next_s[1]]) - Q[state[0], state[1], action_idx]
        )

        state = next_s
        if maze[state[0], state[1]] == 1:
            done = True

print("✅ 训练完成！")

# 5️⃣ 查看学到的路径
state = (2, 0)
path = [state]

while maze[state[0], state[1]] != 1:
    action_idx = np.argmax(Q[state[0], state[1]])
    next_s = next_state(state, actions[action_idx])
    if not is_valid(next_s) or next_s in path:
        break
    state = next_s
    path.append(state)

print("🗺️ 学到的路径:", path)

五、运行结果

六、总结

• Q 表：保存每个状态-动作的价值
• ε-greedy 策略：平衡探索与利用
• 奖励函数设计：引导智能体形成目标导向行为
• 强化学习思想：通过试错和奖励反馈不断改进策略

如何证明 √2 是无理数 — 两种方法（反证法与几何无限下降）

方法一 — 反证法

方法二 — 几何无限下降（等腰直角三角形中线构造）

• 如果假设存在整数边长满足 [math]a^2=2b^2[/math]，则这种几何构造（或等价的、保持整数关系的中点构造）会产生一个更小的正整数解。
• 无限重复下去会得到一个严格递减的正整数序列，这显然不可能。

• 方法一（反证法）利用奇偶性，说明若假设分数为最简形式则会导致分子和分母都为偶数，从而矛盾。
• 方法二（几何无限下降）通过在等腰直角三角形中作中线并利用相似性得到更小的整数解，从而与最小性矛盾。

Dart 是一种面向对象的编程语言，支持类和基于混入（Mixin）的继承机制。在 Dart 中除 Null 以外的所有类都继承自 Object 类。

1. 基本用法

Dart 中类的基本用法和大部分面向对象语言差不多，这里不作详细介绍，直接从一个简单的示例开始：

// 导入依赖库
import 'dart:math';

class Point {
  // 成员变量
  double? x;    // 默认值初始值为null
  double y = 0; // 初始值为0

  // 构造函数
  Point(double x, double y) {
    this.x = x;
    this.y = y;
  }

  //成员方法
  double distanceTo(Point other) {
    double dx = (this.x ?? 0) - (other.x ?? 0);
    var dy = this.y - other.y;
    return sqrt(dx * dx + dy * dy);
  }

  // 静态方法
  static double distanceBetween(Point a, Point b) {
    return a.distanceTo(b);
  }

  // 重写toString方法
  @override
  String toString() {
    return 'Point($x, $y)';
  }
}

调用也很简单，代码如下：

void main() {
  Point p1 = new Point(0, 0); 
  Point p2 = new Point(3, 4);
  print(p1.distanceTo(p2));             // 5.0
  print(Point.distanceBetween(p1, p2)); // 5.0
  print(p1);                            // Point(0.0, 0.0)
  print(p2);                            // Point(3.0, 4.0)
  print(p2.y);                          // 4.0
}

单看上述代码，几乎分不清究竟是 JavaScript、Java, 还是 Dart，下文主要介绍一些 Dart 相对独特的地方。

[...]

下面是一个简单的函数示例：

bool isNoble(int atomicNumber) {
  return _nobleGases[atomicNumber] != null;
}

虽然 返回值类型 和 参数类型 都可以省略，但建议加上，省略后的代码如下：

isNoble(atomicNumber) {
  return _nobleGases[atomicNumber] != null;
}

如果函数体 只有一条语句，也可以使用 箭头函数：

bool isNoble(int atomicNumber) => _nobleGases[atomicNumber] != null;

其中，=> expr; 语法就是 { return expr; } 的简写形式，与其它语言不同，如果函数体有多条语句，就不能使用这种语法了。

[...]

1. 注释

• 单行注释：以两个斜杠（//）开头，持续到行尾。
• 多行注释：以 /* 开头，以 */ 结尾，可以跨越多行。
• 文档注释：以 /// 或 /** 开头，用于为代码生成文档，在文档注释中使用[](如 [Food]、[feed])，生成文档时，会转换为指向类、方法、变量等的超链接。

2. 变量

以下是变量声明和初始化的示例：

var name = 'Bob';

Dart 是强类型语言，示例中，name 变量的类型会在编译时被推断为 String，也可在声明时显式指定类型，对于局部变量，建议使用 var。如果对象不限于单一类型，可以在声明时指定为 Object 或 dynamic 类型。

[...]

Dart 介绍

Dart 是一种由 Google 开发的开源编程语言，于 2011 年首次发布，目前稳定版本为 Dart 3.x，曾经号称要取代 JavaScript，但过去的几年中一直不温不火，真正使其声名大噪并得到广泛应用的原因是其与 Flutter 框架的完美结合。

如今，Flutter 已成为构建高性能、高质量跨平台应用（Android、IOS、Web、桌面）的首选技术方案之一，尤其是针对希望快速实现跨平台应用的中小团队或个人开发者，Flutter 更是不二之选，而学习 Flutter 的第一步就是先学习其官方编程语言 --- Dart。

边学边记，这篇文章先把 Dart 的开发环境搭建起来！

[...]

近期一直在研究毕业设计，在其中，我涉及到了PaddleYOLO的训练和部署，在网上的教程较少，经过不断努力，我也算是跑出来了，所以在这里分享出来做个记录，防止下次使用又忘记了怎么搞。