成长路线图

这个仓库不是单纯的语法教程，而是一条从 Python 零基础走向 AI Builder 和 Quant Researcher 的成长路径。

阶段视图

双版本定位

• GitHub 版：公开展示，保持简洁，适合外部访客快速理解路线、项目和练习。
• 本地 Obsidian 版：学习实验室，记录真实错误、调试过程、学习日志和认知变化。

成长资产

公开仓库保留课程、练习、项目说明和精选学习方法。本地 Vault 保留更细的真实过程，例如语法错误、缩进错误、REPL 使用、变量命名误区和算法模式沉淀。

这些真实错误不是噪音，而是长期学习资产。它们会逐步转化为 Debug 能力、工程判断和项目复盘能力。

Day01 - Python 环境与第一段程序

> 阶段一：Python 基础

学习定位

今天只学习一个核心主题：把 Python 环境与第一段程序 学成可运行、可解释、可迁移的知识点。

目标不是背 API，而是建立认知地图：这个工具解决什么问题、输入是什么、输出是什么、出错时怎么定位。

Day 主线控制在 4 小时以内，但内容保持足够厚：先理解，再写最小代码，再做小练习。

前置知识

• 上一站：无
• 下一站：Day02
• 必须先会：文件路径、函数、列表或字典的基本操作。

认知地图

先看全局，不直接上复杂代码。

工具地图

今天先把 Python 环境与第一段程序 放进一张工具地图里。你只需要抓住“输入 -> 处理 -> 输出”，不用先背完整 API。

What

Python 环境与第一段程序 是 Python 工业化学习中的一个小能力。

它的核心是把“人能看懂的东西”变成“程序也能稳定读取、处理和复查的结构”。

学习时不要只看函数名，要同时看三件事：

1. 输入数据长什么样。

2. 输出结果长什么样。

3. 错误发生时从哪里开始查。

Why

如果不先建立这张地图，你会出现一种很常见的卡点：代码每一行好像都认识，但不知道为什么要这样组合。

例如你看到一个新库时，真正要问的不是“这个函数怎么背”，而是：

• 它把什么变成什么？
• 它替我省掉了哪一步手工处理？
• 它的返回值还能继续调用什么？
• 它和前一天学过的知识有什么关系？

How：最小流程

先写一个只验证本日核心概念的最小例子。今天的重点不是功能多，而是你能说清楚：哪一行负责输入，哪一行负责处理，哪一行给出输出。

import sys
from pathlib import Path

message = "hello Python100"
workspace = Path.cwd()

print(message)
print("python_version =", sys.version.split()[0])
print("current_folder =", workspace)

参数拆解方法

第一次看到 Python 环境与第一段程序 相关函数、类或配置时，按下面 5 步拆。不要只记名字，要把它放回输入输出关系里。

本日检查顺序：先看输入形状，再看处理动作，最后看输出文件。先 print(type(...))。

和旧知识的连接

新知识不是突然出现的，它通常是旧知识的升级版。

Common Errors

Future Usage

这个知识后面会进入四类场景：

• 数据分析：读取、清洗、聚合、图表、报告。
• Quant：行情、因子、回测、风险指标。
• LLM：上下文、结构化输出、评估样例。
• Agent：Tool 参数、执行日志、状态存储。

4 小时学习节奏

今日强化题（带具体代码）

> 每天正文上限控制在 600 行以内。强化题不是口头描述，必须能落到 main.py 运行。

强化题 1：复现最小案例

任务：把下面参考代码复制到 main.py，先不要改，直接运行。

验收：终端能打印 JSON，且本地生成 outputs/day001/。

强化题 2：替换输入

任务：只改输入数据，至少新增 2 条样例。

验收：输出数量、均值、跳过记录或检索结果发生合理变化。

强化题 3：边界检查

任务：制造 1 个坏输入，例如空值、重复值、非法字段或极端价格。

验收：程序不会静默失败；你能在输出或 errors.md 里解释原因。

强化题 4：结果保存

任务：把运行结果保存到 JSON、CSV、Markdown 或 SQLite 中的一种。

验收：关闭终端后，仍能从文件复查今天结果。

强化题 5：迁移说明

任务：写 3 句话说明 Python 环境与第一段程序 会如何迁移到 Data、Quant、LLM 或 Agent。

验收：不是写“以后有用”，而是写清具体场景。

参考代码：main.py

from pathlib import Path
import json

DAY = 1
TOPIC = "Python 环境与第一段程序"
ROOT = Path(__file__).resolve().parent
OUT = ROOT / "outputs" / f"day{DAY:03d}"


def write_json(name, payload):
    OUT.mkdir(parents=True, exist_ok=True)
    path = OUT / name
    path.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
    return path


def build_environment_report():
    import sys
    return {
        "topic": TOPIC,
        "python_version": sys.version.split()[0],
        "working_directory": str(ROOT),
        "first_output": "hello Python100",
    }


def main():
    report = build_environment_report()
    path = write_json("environment_report.json", report)
    print(json.dumps({"saved_to": str(path), **report}, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

运行命令

python main.py

Debug 记录要求

错误现象：
触发输入：
定位过程：
修复方式：
以后如何避免：

今日复盘模板

Day01：Python 环境与第一段程序

我今天学会了什么：

这个工具的输入是什么：

这个工具的输出是什么：

我遇到的错误：

我是怎么定位的：

未来会在哪个 IC 使用：

加厚理解：具体执行步骤

加厚不是把同一句话重复很多遍，也不是提前做完整项目。

这一节的加厚只做 8 层，每一层都有明确产出。做完这 8 层，才算从“看过知识点”进入“能迁移使用”。

第 1 层：认知地图

回答 3 个问题：

• Python 环境与第一段程序 解决什么问题？
• 它的核心对象、函数或概念有哪些？
• 它和前面已经学过的哪个知识点相连？

产出：在 notes.md 写 5 行以内的知识地图。

第 2 层：输入 -> 处理 -> 输出

把本节内容压成一张表：

产出：写出 1 个最小输入和 1 个最小输出。

第 3 层：最小可运行代码

只写一个最小例子，不加复杂功能。

要求：

• 能直接运行。
• 代码不超过 30 行。
• 只验证一个核心概念。
• 运行后能看到明确输出。

产出：main.py。

第 4 层：逐对象拆解

第一次出现的新函数、新类、新参数，必须拆开。

格式：

对象/函数：
它是什么：
输入是什么：
输出是什么：
为什么不用旧方法：
最容易错在哪里：

产出：notes.md 里的“对象拆解”小节。

第 5 层：错误实验

主动制造 2 个错误，而不是等报错后慌。

例子：

• 路径写错。
• 类型传错。
• 字段名不存在。
• 空数据。
• 编码不对。
• 边界条件为 0 或空列表。

产出：errors.md，记录错误信息、原因和修复方式。

第 6 层：旧知识连接

写清楚它不是凭空出现的新知识。

模板：

昨天/之前我会：
今天升级成：
升级后解决的问题：

产出：3 行连接说明。

第 7 层：迁移场景

至少连接到一个方向：

• Data：它如何帮助数据清洗、分析、可视化或报告。
• Quant：它如何帮助行情、指标、回测、风险或实验记录。
• LLM：它如何帮助 prompt、context、embedding、RAG 或 evaluation。
• Agent：它如何帮助 tool、memory、workflow、logging 或 review。

产出：选择 1 个方向，写 3 句话。

第 8 层：IC100 衔接

找到一个最近的 IC，把今天的知识放进去用一次。

要求：

• 不做大项目。
• 只完成一个小动作。
• 留下 GitHub commit。
• 在 review 里写清今天知识点怎么被用到。

产出：对应 IC 的 review.md 或当天提交说明。

30 分钟加厚执行清单

5 分钟：写认知地图
5 分钟：写输入 -> 处理 -> 输出
10 分钟：跑最小代码
5 分钟：制造并修复 1 个错误
5 分钟：写 IC100 迁移说明

判断标准：如果这 30 分钟做不完，说明加厚范围太大，需要砍掉内容，而不是继续堆字数。

Day02 - 变量、类型与输入输出

> 阶段一：Python 基础

学习定位

今天只学习一个核心主题：把 变量、类型与输入输出 学成可运行、可解释、可迁移的知识点。

目标不是背 API，而是建立认知地图：这个工具解决什么问题、输入是什么、输出是什么、出错时怎么定位。

Day 主线控制在 4 小时以内，但内容保持足够厚：先理解，再写最小代码，再做小练习。

前置知识

• 上一站：Day01
• 下一站：Day03
• 必须先会：文件路径、函数、列表或字典的基本操作。

认知地图

先看全局，不直接上复杂代码。

工具地图

今天先把 变量、类型与输入输出 放进一张工具地图里。你只需要抓住“输入 -> 处理 -> 输出”，不用先背完整 API。

What

变量、类型与输入输出 是 Python 工业化学习中的一个小能力。

它的核心是把“人能看懂的东西”变成“程序也能稳定读取、处理和复查的结构”。

学习时不要只看函数名，要同时看三件事：

1. 输入数据长什么样。

2. 输出结果长什么样。

3. 错误发生时从哪里开始查。

Why

如果不先建立这张地图，你会出现一种很常见的卡点：代码每一行好像都认识，但不知道为什么要这样组合。

例如你看到一个新库时，真正要问的不是“这个函数怎么背”，而是：

• 它把什么变成什么？
• 它替我省掉了哪一步手工处理？
• 它的返回值还能继续调用什么？
• 它和前一天学过的知识有什么关系？

How：最小流程

先写一个只验证本日核心概念的最小例子。今天的重点不是功能多，而是你能说清楚：哪一行负责输入，哪一行负责处理，哪一行给出输出。

name = "Claire"
study_minutes = "45"
minutes = int(study_minutes)

profile = {
    "name": name,
    "minutes": minutes,
    "hours": round(minutes / 60, 2),
}

print(profile)
print(type(profile["minutes"]).__name__)

参数拆解方法

第一次看到 变量、类型与输入输出 相关函数、类或配置时，按下面 5 步拆。不要只记名字，要把它放回输入输出关系里。

本日检查顺序：先看输入形状，再看处理动作，最后看输出文件。先 print(type(...))。

和旧知识的连接

新知识不是突然出现的，它通常是旧知识的升级版。

Common Errors

Future Usage

这个知识后面会进入四类场景：

• 数据分析：读取、清洗、聚合、图表、报告。
• Quant：行情、因子、回测、风险指标。
• LLM：上下文、结构化输出、评估样例。
• Agent：Tool 参数、执行日志、状态存储。

4 小时学习节奏

今日强化题（带具体代码）

> 每天正文上限控制在 600 行以内。强化题不是口头描述，必须能落到 main.py 运行。

强化题 1：复现最小案例

任务：把下面参考代码复制到 main.py，先不要改，直接运行。

验收：终端能打印 JSON，且本地生成 outputs/day002/。

强化题 2：替换输入

任务：只改输入数据，至少新增 2 条样例。

验收：输出数量、均值、跳过记录或检索结果发生合理变化。

强化题 3：边界检查

任务：制造 1 个坏输入，例如空值、重复值、非法字段或极端价格。

验收：程序不会静默失败；你能在输出或 errors.md 里解释原因。

强化题 4：结果保存

任务：把运行结果保存到 JSON、CSV、Markdown 或 SQLite 中的一种。

验收：关闭终端后，仍能从文件复查今天结果。

强化题 5：迁移说明

任务：写 3 句话说明 变量、类型与输入输出 会如何迁移到 Data、Quant、LLM 或 Agent。

验收：不是写“以后有用”，而是写清具体场景。

参考代码：main.py

from pathlib import Path
import json

DAY = 2
TOPIC = "变量、类型与输入输出"
ROOT = Path(__file__).resolve().parent
OUT = ROOT / "outputs" / f"day{DAY:03d}"


def write_json(name, payload):
    OUT.mkdir(parents=True, exist_ok=True)
    path = OUT / name
    path.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
    return path


def build_profile(name, minutes_text, focus):
    minutes = int(minutes_text)
    return {
        "name": name,
        "focus": focus,
        "minutes": minutes,
        "hours": round(minutes / 60, 2),
        "minutes_type": type(minutes).__name__,
    }


def main():
    profile = build_profile("Claire", "50", "Python types")
    path = write_json("variable_type_report.json", profile)
    print(json.dumps({"saved_to": str(path), **profile}, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

运行命令

python main.py

Debug 记录要求

错误现象：
触发输入：
定位过程：
修复方式：
以后如何避免：

今日复盘模板

Day02：变量、类型与输入输出

我今天学会了什么：

这个工具的输入是什么：

这个工具的输出是什么：

我遇到的错误：

我是怎么定位的：

未来会在哪个 IC 使用：

加厚理解：具体执行步骤

加厚不是把同一句话重复很多遍，也不是提前做完整项目。

这一节的加厚只做 8 层，每一层都有明确产出。做完这 8 层，才算从“看过知识点”进入“能迁移使用”。

第 1 层：认知地图

回答 3 个问题：

• 变量、类型与输入输出 解决什么问题？
• 它的核心对象、函数或概念有哪些？
• 它和前面已经学过的哪个知识点相连？

产出：在 notes.md 写 5 行以内的知识地图。

第 2 层：输入 -> 处理 -> 输出

把本节内容压成一张表：

产出：写出 1 个最小输入和 1 个最小输出。

第 3 层：最小可运行代码

只写一个最小例子，不加复杂功能。

要求：

• 能直接运行。
• 代码不超过 30 行。
• 只验证一个核心概念。
• 运行后能看到明确输出。

产出：main.py。

第 4 层：逐对象拆解

第一次出现的新函数、新类、新参数，必须拆开。

格式：

对象/函数：
它是什么：
输入是什么：
输出是什么：
为什么不用旧方法：
最容易错在哪里：

产出：notes.md 里的“对象拆解”小节。

第 5 层：错误实验

主动制造 2 个错误，而不是等报错后慌。

例子：

• 路径写错。
• 类型传错。
• 字段名不存在。
• 空数据。
• 编码不对。
• 边界条件为 0 或空列表。

产出：errors.md，记录错误信息、原因和修复方式。

第 6 层：旧知识连接

写清楚它不是凭空出现的新知识。

模板：

昨天/之前我会：
今天升级成：
升级后解决的问题：

产出：3 行连接说明。

第 7 层：迁移场景

至少连接到一个方向：

• Data：它如何帮助数据清洗、分析、可视化或报告。
• Quant：它如何帮助行情、指标、回测、风险或实验记录。
• LLM：它如何帮助 prompt、context、embedding、RAG 或 evaluation。
• Agent：它如何帮助 tool、memory、workflow、logging 或 review。

产出：选择 1 个方向，写 3 句话。

第 8 层：IC100 衔接

找到一个最近的 IC，把今天的知识放进去用一次。

要求：

• 不做大项目。
• 只完成一个小动作。
• 留下 GitHub commit。
• 在 review 里写清今天知识点怎么被用到。

产出：对应 IC 的 review.md 或当天提交说明。

30 分钟加厚执行清单

5 分钟：写认知地图
5 分钟：写输入 -> 处理 -> 输出
10 分钟：跑最小代码
5 分钟：制造并修复 1 个错误
5 分钟：写 IC100 迁移说明

判断标准：如果这 30 分钟做不完，说明加厚范围太大，需要砍掉内容，而不是继续堆字数。

Day03 - 分支结构与输入验证

> 阶段一：Python 基础

学习定位

今天只学习一个核心主题：把 分支结构与输入验证 学成可运行、可解释、可迁移的知识点。

目标不是背 API，而是建立认知地图：这个工具解决什么问题、输入是什么、输出是什么、出错时怎么定位。

Day 主线控制在 4 小时以内，但内容保持足够厚：先理解，再写最小代码，再做小练习。

前置知识

• 上一站：Day02
• 下一站：Day04
• 必须先会：文件路径、函数、列表或字典的基本操作。

认知地图

先看全局，不直接上复杂代码。

工具地图

今天先把 分支结构与输入验证 放进一张工具地图里。你只需要抓住“输入 -> 处理 -> 输出”，不用先背完整 API。

What

分支结构与输入验证 是 Python 工业化学习中的一个小能力。

它的核心是把“人能看懂的东西”变成“程序也能稳定读取、处理和复查的结构”。

学习时不要只看函数名，要同时看三件事：

1. 输入数据长什么样。

2. 输出结果长什么样。

3. 错误发生时从哪里开始查。

Why

如果不先建立这张地图，你会出现一种很常见的卡点：代码每一行好像都认识，但不知道为什么要这样组合。

例如你看到一个新库时，真正要问的不是“这个函数怎么背”，而是：

• 它把什么变成什么？
• 它替我省掉了哪一步手工处理？
• 它的返回值还能继续调用什么？
• 它和前一天学过的知识有什么关系？

How：最小流程

先写一个只验证本日核心概念的最小例子。今天的重点不是功能多，而是你能说清楚：哪一行负责输入，哪一行负责处理，哪一行给出输出。

score_text = "82"
score = int(score_text)

if score >= 90:
    level = "excellent"
elif score >= 60:
    level = "pass"
else:
    level = "redo"

print({"score": score, "level": level})

参数拆解方法

第一次看到 分支结构与输入验证 相关函数、类或配置时，按下面 5 步拆。不要只记名字，要把它放回输入输出关系里。

本日检查顺序：先看输入形状，再看处理动作，最后看输出文件。先 print(type(...))。

和旧知识的连接

新知识不是突然出现的，它通常是旧知识的升级版。

Common Errors

Future Usage

这个知识后面会进入四类场景：

• 数据分析：读取、清洗、聚合、图表、报告。
• Quant：行情、因子、回测、风险指标。
• LLM：上下文、结构化输出、评估样例。
• Agent：Tool 参数、执行日志、状态存储。

4 小时学习节奏

今日强化题（带具体代码）

> 每天正文上限控制在 600 行以内。强化题不是口头描述，必须能落到 main.py 运行。

强化题 1：复现最小案例

任务：把下面参考代码复制到 main.py，先不要改，直接运行。

验收：终端能打印 JSON，且本地生成 outputs/day003/。

强化题 2：替换输入

任务：只改输入数据，至少新增 2 条样例。

验收：输出数量、均值、跳过记录或检索结果发生合理变化。

强化题 3：边界检查

任务：制造 1 个坏输入，例如空值、重复值、非法字段或极端价格。

验收：程序不会静默失败；你能在输出或 errors.md 里解释原因。

强化题 4：结果保存

任务：把运行结果保存到 JSON、CSV、Markdown 或 SQLite 中的一种。

验收：关闭终端后，仍能从文件复查今天结果。

强化题 5：迁移说明

任务：写 3 句话说明 分支结构与输入验证 会如何迁移到 Data、Quant、LLM 或 Agent。

验收：不是写“以后有用”，而是写清具体场景。

参考代码：main.py

from pathlib import Path
import json

DAY = 3
TOPIC = "分支结构与输入验证"
ROOT = Path(__file__).resolve().parent
OUT = ROOT / "outputs" / f"day{DAY:03d}"


def write_json(name, payload):
    OUT.mkdir(parents=True, exist_ok=True)
    path = OUT / name
    path.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
    return path


def classify_record(record):
    minutes = record.get("minutes", 0)
    if minutes < 0:
        return {**record, "valid": False, "reason": "minutes cannot be negative"}
    if minutes >= 60:
        level = "deep_work"
    elif minutes >= 25:
        level = "normal"
    else:
        level = "too_short"
    return {**record, "valid": True, "level": level}


def main():
    records = [{"topic": "loop", "minutes": 40}, {"topic": "csv", "minutes": -5}, {"topic": "json", "minutes": 75}]
    checked = [classify_record(record) for record in records]
    path = write_json("branch_validation_report.json", {"topic": TOPIC, "records": checked})
    print(json.dumps({"saved_to": str(path), "records": checked}, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

运行命令

python main.py

Debug 记录要求

错误现象：
触发输入：
定位过程：
修复方式：
以后如何避免：

今日复盘模板

Day03：分支结构与输入验证

我今天学会了什么：

这个工具的输入是什么：

这个工具的输出是什么：

我遇到的错误：

我是怎么定位的：

未来会在哪个 IC 使用：

加厚理解：具体执行步骤

加厚不是把同一句话重复很多遍，也不是提前做完整项目。

这一节的加厚只做 8 层，每一层都有明确产出。做完这 8 层，才算从“看过知识点”进入“能迁移使用”。

第 1 层：认知地图

回答 3 个问题：

• 分支结构与输入验证 解决什么问题？
• 它的核心对象、函数或概念有哪些？
• 它和前面已经学过的哪个知识点相连？

产出：在 notes.md 写 5 行以内的知识地图。

第 2 层：输入 -> 处理 -> 输出

把本节内容压成一张表：

产出：写出 1 个最小输入和 1 个最小输出。

第 3 层：最小可运行代码

只写一个最小例子，不加复杂功能。

要求：

• 能直接运行。
• 代码不超过 30 行。
• 只验证一个核心概念。
• 运行后能看到明确输出。

产出：main.py。

第 4 层：逐对象拆解

第一次出现的新函数、新类、新参数，必须拆开。

格式：

对象/函数：
它是什么：
输入是什么：
输出是什么：
为什么不用旧方法：
最容易错在哪里：

产出：notes.md 里的“对象拆解”小节。

第 5 层：错误实验

主动制造 2 个错误，而不是等报错后慌。

例子：

• 路径写错。
• 类型传错。
• 字段名不存在。
• 空数据。
• 编码不对。
• 边界条件为 0 或空列表。

产出：errors.md，记录错误信息、原因和修复方式。

第 6 层：旧知识连接

写清楚它不是凭空出现的新知识。

模板：

昨天/之前我会：
今天升级成：
升级后解决的问题：

产出：3 行连接说明。

第 7 层：迁移场景

至少连接到一个方向：

• Data：它如何帮助数据清洗、分析、可视化或报告。
• Quant：它如何帮助行情、指标、回测、风险或实验记录。
• LLM：它如何帮助 prompt、context、embedding、RAG 或 evaluation。
• Agent：它如何帮助 tool、memory、workflow、logging 或 review。

产出：选择 1 个方向，写 3 句话。

第 8 层：IC100 衔接

找到一个最近的 IC，把今天的知识放进去用一次。

要求：

• 不做大项目。
• 只完成一个小动作。
• 留下 GitHub commit。
• 在 review 里写清今天知识点怎么被用到。

产出：对应 IC 的 review.md 或当天提交说明。

30 分钟加厚执行清单

5 分钟：写认知地图
5 分钟：写输入 -> 处理 -> 输出
10 分钟：跑最小代码
5 分钟：制造并修复 1 个错误
5 分钟：写 IC100 迁移说明

判断标准：如果这 30 分钟做不完，说明加厚范围太大，需要砍掉内容，而不是继续堆字数。

Day04 - 循环、计数器与重复任务

> 阶段一：Python 基础

学习定位

今天只学习一个核心主题：把 循环、计数器与重复任务 学成可运行、可解释、可迁移的知识点。

目标不是背 API，而是建立认知地图：这个工具解决什么问题、输入是什么、输出是什么、出错时怎么定位。

Day 主线控制在 4 小时以内，但内容保持足够厚：先理解，再写最小代码，再做小练习。

前置知识

• 上一站：Day03
• 下一站：Day05
• 必须先会：文件路径、函数、列表或字典的基本操作。

认知地图

先看全局，不直接上复杂代码。

工具地图

今天先把 循环、计数器与重复任务 放进一张工具地图里。你只需要抓住“输入 -> 处理 -> 输出”，不用先背完整 API。

What

循环、计数器与重复任务 是 Python 工业化学习中的一个小能力。

它的核心是把“人能看懂的东西”变成“程序也能稳定读取、处理和复查的结构”。

学习时不要只看函数名，要同时看三件事：

1. 输入数据长什么样。

2. 输出结果长什么样。

3. 错误发生时从哪里开始查。

Why

如果不先建立这张地图，你会出现一种很常见的卡点：代码每一行好像都认识，但不知道为什么要这样组合。

例如你看到一个新库时，真正要问的不是“这个函数怎么背”，而是：

• 它把什么变成什么？
• 它替我省掉了哪一步手工处理？
• 它的返回值还能继续调用什么？
• 它和前一天学过的知识有什么关系？

How：最小流程

先写一个只验证本日核心概念的最小例子。今天的重点不是功能多，而是你能说清楚：哪一行负责输入，哪一行负责处理，哪一行给出输出。

minutes = [25, 0, 40, -5, 30]
total = 0
skipped = []

for value in minutes:
    if value < 0:
        break
    if value == 0:
        skipped.append(value)
        continue
    total += value

print({"total_minutes": total, "skipped": len(skipped)})

参数拆解方法

第一次看到 循环、计数器与重复任务 相关函数、类或配置时，按下面 5 步拆。不要只记名字，要把它放回输入输出关系里。

本日检查顺序：先看输入形状，再看处理动作，最后看输出文件。先 print(type(...))。

和旧知识的连接

新知识不是突然出现的，它通常是旧知识的升级版。

Common Errors

Future Usage

这个知识后面会进入四类场景：

• 数据分析：读取、清洗、聚合、图表、报告。
• Quant：行情、因子、回测、风险指标。
• LLM：上下文、结构化输出、评估样例。
• Agent：Tool 参数、执行日志、状态存储。

4 小时学习节奏

今日强化题（带具体代码）

> 每天正文上限控制在 600 行以内。强化题不是口头描述，必须能落到 main.py 运行。

强化题 1：复现最小案例

任务：把下面参考代码复制到 main.py，先不要改，直接运行。

验收：终端能打印 JSON，且本地生成 outputs/day004/。

强化题 2：替换输入

任务：只改输入数据，至少新增 2 条样例。

验收：输出数量、均值、跳过记录或检索结果发生合理变化。

强化题 3：边界检查

任务：制造 1 个坏输入，例如空值、重复值、非法字段或极端价格。

验收：程序不会静默失败；你能在输出或 errors.md 里解释原因。

强化题 4：结果保存

任务：把运行结果保存到 JSON、CSV、Markdown 或 SQLite 中的一种。

验收：关闭终端后，仍能从文件复查今天结果。

强化题 5：迁移说明

任务：写 3 句话说明 循环、计数器与重复任务 会如何迁移到 Data、Quant、LLM 或 Agent。

验收：不是写“以后有用”，而是写清具体场景。

参考代码：main.py

from pathlib import Path
import json

DAY = 4
TOPIC = "循环、计数器与重复任务"
ROOT = Path(__file__).resolve().parent
OUT = ROOT / "outputs" / f"day{DAY:03d}"


def write_json(name, payload):
    OUT.mkdir(parents=True, exist_ok=True)
    path = OUT / name
    path.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
    return path


def summarize_minutes(values):
    total = 0
    used = []
    skipped = []
    for value in values:
        if value < 0:
            break
        if value == 0:
            skipped.append(value)
            continue
        total += value
        used.append(value)
    return {"used": used, "skipped_count": len(skipped), "total_minutes": total}


def main():
    report = summarize_minutes([25, 0, 45, 30, -1, 90])
    path = write_json("loop_break_continue_report.json", {"topic": TOPIC, **report})
    print(json.dumps({"saved_to": str(path), **report}, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

运行命令

python main.py

Debug 记录要求

错误现象：
触发输入：
定位过程：
修复方式：
以后如何避免：

今日复盘模板

Day04：循环、计数器与重复任务

我今天学会了什么：

这个工具的输入是什么：

这个工具的输出是什么：

我遇到的错误：

我是怎么定位的：

未来会在哪个 IC 使用：

加厚理解：具体执行步骤

加厚不是把同一句话重复很多遍，也不是提前做完整项目。

这一节的加厚只做 8 层，每一层都有明确产出。做完这 8 层，才算从“看过知识点”进入“能迁移使用”。

第 1 层：认知地图

回答 3 个问题：

• 循环、计数器与重复任务 解决什么问题？
• 它的核心对象、函数或概念有哪些？
• 它和前面已经学过的哪个知识点相连？

产出：在 notes.md 写 5 行以内的知识地图。

第 2 层：输入 -> 处理 -> 输出

把本节内容压成一张表：

产出：写出 1 个最小输入和 1 个最小输出。

第 3 层：最小可运行代码

只写一个最小例子，不加复杂功能。

要求：

• 能直接运行。
• 代码不超过 30 行。
• 只验证一个核心概念。
• 运行后能看到明确输出。

产出：main.py。

第 4 层：逐对象拆解

第一次出现的新函数、新类、新参数，必须拆开。

格式：

对象/函数：
它是什么：
输入是什么：
输出是什么：
为什么不用旧方法：
最容易错在哪里：

产出：notes.md 里的“对象拆解”小节。

第 5 层：错误实验

主动制造 2 个错误，而不是等报错后慌。

例子：

• 路径写错。
• 类型传错。
• 字段名不存在。
• 空数据。
• 编码不对。
• 边界条件为 0 或空列表。

产出：errors.md，记录错误信息、原因和修复方式。

第 6 层：旧知识连接

写清楚它不是凭空出现的新知识。

模板：

昨天/之前我会：
今天升级成：
升级后解决的问题：

产出：3 行连接说明。

第 7 层：迁移场景

至少连接到一个方向：

• Data：它如何帮助数据清洗、分析、可视化或报告。
• Quant：它如何帮助行情、指标、回测、风险或实验记录。
• LLM：它如何帮助 prompt、context、embedding、RAG 或 evaluation。
• Agent：它如何帮助 tool、memory、workflow、logging 或 review。

产出：选择 1 个方向，写 3 句话。

第 8 层：IC100 衔接

找到一个最近的 IC，把今天的知识放进去用一次。

要求：

• 不做大项目。
• 只完成一个小动作。
• 留下 GitHub commit。
• 在 review 里写清今天知识点怎么被用到。

产出：对应 IC 的 review.md 或当天提交说明。

30 分钟加厚执行清单

5 分钟：写认知地图
5 分钟：写输入 -> 处理 -> 输出
10 分钟：跑最小代码
5 分钟：制造并修复 1 个错误
5 分钟：写 IC100 迁移说明

判断标准：如果这 30 分钟做不完，说明加厚范围太大，需要砍掉内容，而不是继续堆字数。

Day05 - 列表与最小算法

> 阶段一：Python 基础

学习定位

今天只学习一个核心主题：把 列表与最小算法 学成可运行、可解释、可迁移的知识点。

目标不是背 API，而是建立认知地图：这个工具解决什么问题、输入是什么、输出是什么、出错时怎么定位。

Day 主线控制在 4 小时以内，但内容保持足够厚：先理解，再写最小代码，再做小练习。

前置知识

• 上一站：Day04
• 下一站：Day06
• 必须先会：文件路径、函数、列表或字典的基本操作。

认知地图

先看全局，不直接上复杂代码。

工具地图

今天先把 列表与最小算法 放进一张工具地图里。你只需要抓住“输入 -> 处理 -> 输出”，不用先背完整 API。

What

列表与最小算法 是 Python 工业化学习中的一个小能力。

它的核心是把“人能看懂的东西”变成“程序也能稳定读取、处理和复查的结构”。

学习时不要只看函数名，要同时看三件事：

1. 输入数据长什么样。

2. 输出结果长什么样。

3. 错误发生时从哪里开始查。

Why

如果不先建立这张地图，你会出现一种很常见的卡点：代码每一行好像都认识，但不知道为什么要这样组合。

例如你看到一个新库时，真正要问的不是“这个函数怎么背”，而是：

• 它把什么变成什么？
• 它替我省掉了哪一步手工处理？
• 它的返回值还能继续调用什么？
• 它和前一天学过的知识有什么关系？

How：最小流程

先写一个只验证本日核心概念的最小例子。今天的重点不是功能多，而是你能说清楚：哪一行负责输入，哪一行负责处理，哪一行给出输出。

scores = [72, 88, 91, 66, 88]
passed = [score for score in scores if score >= 80]
unique_scores = sorted(set(scores), reverse=True)

print({"passed": passed, "best": unique_scores[0], "unique": unique_scores})

参数拆解方法

第一次看到 列表与最小算法 相关函数、类或配置时，按下面 5 步拆。不要只记名字，要把它放回输入输出关系里。

本日检查顺序：先看输入形状，再看处理动作，最后看输出文件。先 print(type(...))。

和旧知识的连接

新知识不是突然出现的，它通常是旧知识的升级版。

Common Errors

Future Usage

这个知识后面会进入四类场景：

• 数据分析：读取、清洗、聚合、图表、报告。
• Quant：行情、因子、回测、风险指标。
• LLM：上下文、结构化输出、评估样例。
• Agent：Tool 参数、执行日志、状态存储。

4 小时学习节奏

今日强化题（带具体代码）

> 每天正文上限控制在 600 行以内。强化题不是口头描述，必须能落到 main.py 运行。

强化题 1：复现最小案例

任务：把下面参考代码复制到 main.py，先不要改，直接运行。

验收：终端能打印 JSON，且本地生成 outputs/day005/。

强化题 2：替换输入

任务：只改输入数据，至少新增 2 条样例。

验收：输出数量、均值、跳过记录或检索结果发生合理变化。

强化题 3：边界检查

任务：制造 1 个坏输入，例如空值、重复值、非法字段或极端价格。

验收：程序不会静默失败；你能在输出或 errors.md 里解释原因。

强化题 4：结果保存

任务：把运行结果保存到 JSON、CSV、Markdown 或 SQLite 中的一种。

验收：关闭终端后，仍能从文件复查今天结果。

强化题 5：迁移说明

任务：写 3 句话说明 列表与最小算法 会如何迁移到 Data、Quant、LLM 或 Agent。

验收：不是写“以后有用”，而是写清具体场景。

参考代码：main.py

from pathlib import Path
import json

DAY = 5
TOPIC = "列表与最小算法"
ROOT = Path(__file__).resolve().parent
OUT = ROOT / "outputs" / f"day{DAY:03d}"


def write_json(name, payload):
    OUT.mkdir(parents=True, exist_ok=True)
    path = OUT / name
    path.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
    return path


def analyze_scores(scores):
    clean_scores = [score for score in scores if isinstance(score, (int, float))]
    passed = [score for score in clean_scores if score >= 80]
    return {
        "count": len(clean_scores),
        "best": max(clean_scores),
        "passed": passed,
        "unique_desc": sorted(set(clean_scores), reverse=True),
    }


def main():
    result = analyze_scores([72, 88, 91, 66, 88])
    path = write_json("list_algorithm_report.json", {"topic": TOPIC, **result})
    print(json.dumps({"saved_to": str(path), **result}, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

运行命令

python main.py

Debug 记录要求

错误现象：
触发输入：
定位过程：
修复方式：
以后如何避免：

今日复盘模板

Day05：列表与最小算法

我今天学会了什么：

这个工具的输入是什么：

这个工具的输出是什么：

我遇到的错误：

我是怎么定位的：

未来会在哪个 IC 使用：

加厚理解：具体执行步骤

加厚不是把同一句话重复很多遍，也不是提前做完整项目。

这一节的加厚只做 8 层，每一层都有明确产出。做完这 8 层，才算从“看过知识点”进入“能迁移使用”。

第 1 层：认知地图

回答 3 个问题：

• 列表与最小算法 解决什么问题？
• 它的核心对象、函数或概念有哪些？
• 它和前面已经学过的哪个知识点相连？

产出：在 notes.md 写 5 行以内的知识地图。

第 2 层：输入 -> 处理 -> 输出

把本节内容压成一张表：

产出：写出 1 个最小输入和 1 个最小输出。

第 3 层：最小可运行代码

只写一个最小例子，不加复杂功能。

要求：

• 能直接运行。
• 代码不超过 30 行。
• 只验证一个核心概念。
• 运行后能看到明确输出。

产出：main.py。

第 4 层：逐对象拆解

第一次出现的新函数、新类、新参数，必须拆开。

格式：

对象/函数：
它是什么：
输入是什么：
输出是什么：
为什么不用旧方法：
最容易错在哪里：

产出：notes.md 里的“对象拆解”小节。

第 5 层：错误实验

主动制造 2 个错误，而不是等报错后慌。

例子：

• 路径写错。
• 类型传错。
• 字段名不存在。
• 空数据。
• 编码不对。
• 边界条件为 0 或空列表。

产出：errors.md，记录错误信息、原因和修复方式。

第 6 层：旧知识连接

写清楚它不是凭空出现的新知识。

模板：

昨天/之前我会：
今天升级成：
升级后解决的问题：

产出：3 行连接说明。

第 7 层：迁移场景

至少连接到一个方向：

• Data：它如何帮助数据清洗、分析、可视化或报告。
• Quant：它如何帮助行情、指标、回测、风险或实验记录。
• LLM：它如何帮助 prompt、context、embedding、RAG 或 evaluation。
• Agent：它如何帮助 tool、memory、workflow、logging 或 review。

产出：选择 1 个方向，写 3 句话。

第 8 层：IC100 衔接

找到一个最近的 IC，把今天的知识放进去用一次。

要求：

• 不做大项目。
• 只完成一个小动作。
• 留下 GitHub commit。
• 在 review 里写清今天知识点怎么被用到。

产出：对应 IC 的 review.md 或当天提交说明。

30 分钟加厚执行清单

5 分钟：写认知地图
5 分钟：写输入 -> 处理 -> 输出
10 分钟：跑最小代码
5 分钟：制造并修复 1 个错误
5 分钟：写 IC100 迁移说明

判断标准：如果这 30 分钟做不完，说明加厚范围太大，需要砍掉内容，而不是继续堆字数。

Day06 - 函数、参数与返回值

> 阶段一：Python 基础

学习定位

今天只学习一个核心主题：把 函数、参数与返回值 学成可运行、可解释、可迁移的知识点。

目标不是背 API，而是建立认知地图：这个工具解决什么问题、输入是什么、输出是什么、出错时怎么定位。

Day 主线控制在 4 小时以内，但内容保持足够厚：先理解，再写最小代码，再做小练习。

前置知识

• 上一站：Day05
• 下一站：Day07
• 必须先会：文件路径、函数、列表或字典的基本操作。

认知地图

先看全局，不直接上复杂代码。

工具地图

今天先把 函数、参数与返回值 放进一张工具地图里。你只需要抓住“输入 -> 处理 -> 输出”，不用先背完整 API。

What

函数、参数与返回值 是 Python 工业化学习中的一个小能力。

它的核心是把“人能看懂的东西”变成“程序也能稳定读取、处理和复查的结构”。

学习时不要只看函数名，要同时看三件事：

1. 输入数据长什么样。

2. 输出结果长什么样。

3. 错误发生时从哪里开始查。

Why

如果不先建立这张地图，你会出现一种很常见的卡点：代码每一行好像都认识，但不知道为什么要这样组合。

例如你看到一个新库时，真正要问的不是“这个函数怎么背”，而是：

• 它把什么变成什么？
• 它替我省掉了哪一步手工处理？
• 它的返回值还能继续调用什么？
• 它和前一天学过的知识有什么关系？

How：最小流程

先写一个只验证本日核心概念的最小例子。今天的重点不是功能多，而是你能说清楚：哪一行负责输入，哪一行负责处理，哪一行给出输出。

def calc_efficiency(done_tasks, minutes):
    if minutes <= 0:
        return 0
    return round(done_tasks / minutes * 60, 2)

result = calc_efficiency(done_tasks=3, minutes=45)
print({"tasks_per_hour": result})

参数拆解方法

第一次看到 函数、参数与返回值 相关函数、类或配置时，按下面 5 步拆。不要只记名字，要把它放回输入输出关系里。

本日检查顺序：先看输入形状，再看处理动作，最后看输出文件。先 print(type(...))。

和旧知识的连接

新知识不是突然出现的，它通常是旧知识的升级版。

Common Errors

Future Usage

这个知识后面会进入四类场景：

• 数据分析：读取、清洗、聚合、图表、报告。
• Quant：行情、因子、回测、风险指标。
• LLM：上下文、结构化输出、评估样例。
• Agent：Tool 参数、执行日志、状态存储。

4 小时学习节奏

今日强化题（带具体代码）

> 每天正文上限控制在 600 行以内。强化题不是口头描述，必须能落到 main.py 运行。

强化题 1：复现最小案例

任务：把下面参考代码复制到 main.py，先不要改，直接运行。

验收：终端能打印 JSON，且本地生成 outputs/day006/。

强化题 2：替换输入

任务：只改输入数据，至少新增 2 条样例。

验收：输出数量、均值、跳过记录或检索结果发生合理变化。

强化题 3：边界检查

任务：制造 1 个坏输入，例如空值、重复值、非法字段或极端价格。

验收：程序不会静默失败；你能在输出或 errors.md 里解释原因。

强化题 4：结果保存

任务：把运行结果保存到 JSON、CSV、Markdown 或 SQLite 中的一种。

验收：关闭终端后，仍能从文件复查今天结果。

强化题 5：迁移说明

任务：写 3 句话说明 函数、参数与返回值 会如何迁移到 Data、Quant、LLM 或 Agent。

验收：不是写“以后有用”，而是写清具体场景。

参考代码：main.py

from pathlib import Path
import json

DAY = 6
TOPIC = "函数、参数与返回值"
ROOT = Path(__file__).resolve().parent
OUT = ROOT / "outputs" / f"day{DAY:03d}"


def write_json(name, payload):
    OUT.mkdir(parents=True, exist_ok=True)
    path = OUT / name
    path.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
    return path


def efficiency(done_tasks, minutes):
    if minutes <= 0:
        return 0
    return round(done_tasks / minutes * 60, 2)


def build_day_summary(topic, done_tasks, minutes):
    return {
        "topic": topic,
        "done_tasks": done_tasks,
        "minutes": minutes,
        "tasks_per_hour": efficiency(done_tasks, minutes),
    }


def main():
    summary = build_day_summary("function practice", done_tasks=4, minutes=50)
    path = write_json("function_return_report.json", {"course_topic": TOPIC, **summary})
    print(json.dumps({"saved_to": str(path), **summary}, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

运行命令

python main.py

Debug 记录要求

错误现象：
触发输入：
定位过程：
修复方式：
以后如何避免：

今日复盘模板

Day06：函数、参数与返回值

我今天学会了什么：

这个工具的输入是什么：

这个工具的输出是什么：

我遇到的错误：

我是怎么定位的：

未来会在哪个 IC 使用：

加厚理解：具体执行步骤

加厚不是把同一句话重复很多遍，也不是提前做完整项目。

这一节的加厚只做 8 层，每一层都有明确产出。做完这 8 层，才算从“看过知识点”进入“能迁移使用”。

第 1 层：认知地图

回答 3 个问题：

• 函数、参数与返回值 解决什么问题？
• 它的核心对象、函数或概念有哪些？
• 它和前面已经学过的哪个知识点相连？

产出：在 notes.md 写 5 行以内的知识地图。

第 2 层：输入 -> 处理 -> 输出

把本节内容压成一张表：

产出：写出 1 个最小输入和 1 个最小输出。

第 3 层：最小可运行代码

只写一个最小例子，不加复杂功能。

要求：

• 能直接运行。
• 代码不超过 30 行。
• 只验证一个核心概念。
• 运行后能看到明确输出。

产出：main.py。

第 4 层：逐对象拆解

第一次出现的新函数、新类、新参数，必须拆开。

格式：

对象/函数：
它是什么：
输入是什么：
输出是什么：
为什么不用旧方法：
最容易错在哪里：

产出：notes.md 里的“对象拆解”小节。

第 5 层：错误实验

主动制造 2 个错误，而不是等报错后慌。

例子：

• 路径写错。
• 类型传错。
• 字段名不存在。
• 空数据。
• 编码不对。
• 边界条件为 0 或空列表。

产出：errors.md，记录错误信息、原因和修复方式。

第 6 层：旧知识连接

写清楚它不是凭空出现的新知识。

模板：

昨天/之前我会：
今天升级成：
升级后解决的问题：

产出：3 行连接说明。

第 7 层：迁移场景

至少连接到一个方向：

• Data：它如何帮助数据清洗、分析、可视化或报告。
• Quant：它如何帮助行情、指标、回测、风险或实验记录。
• LLM：它如何帮助 prompt、context、embedding、RAG 或 evaluation。
• Agent：它如何帮助 tool、memory、workflow、logging 或 review。

产出：选择 1 个方向，写 3 句话。

第 8 层：IC100 衔接

找到一个最近的 IC，把今天的知识放进去用一次。

要求：

• 不做大项目。
• 只完成一个小动作。
• 留下 GitHub commit。
• 在 review 里写清今天知识点怎么被用到。

产出：对应 IC 的 review.md 或当天提交说明。

30 分钟加厚执行清单

5 分钟：写认知地图
5 分钟：写输入 -> 处理 -> 输出
10 分钟：跑最小代码
5 分钟：制造并修复 1 个错误
5 分钟：写 IC100 迁移说明

判断标准：如果这 30 分钟做不完，说明加厚范围太大，需要砍掉内容，而不是继续堆字数。

Day07 - 字符串、字典与集合

> 阶段一：Python 基础

学习定位

今天只学习一个核心主题：把 字符串、字典与集合 学成可运行、可解释、可迁移的知识点。

目标不是背 API，而是建立认知地图：这个工具解决什么问题、输入是什么、输出是什么、出错时怎么定位。

Day 主线控制在 4 小时以内，但内容保持足够厚：先理解，再写最小代码，再做小练习。

前置知识

• 上一站：Day06
• 下一站：Day08
• 必须先会：文件路径、函数、列表或字典的基本操作。

认知地图

先看全局，不直接上复杂代码。

工具地图

今天先把 字符串、字典与集合 放进一张工具地图里。你只需要抓住“输入 -> 处理 -> 输出”，不用先背完整 API。

What

字符串、字典与集合 是 Python 工业化学习中的一个小能力。

它的核心是把“人能看懂的东西”变成“程序也能稳定读取、处理和复查的结构”。

学习时不要只看函数名，要同时看三件事：

1. 输入数据长什么样。

2. 输出结果长什么样。

3. 错误发生时从哪里开始查。

Why

如果不先建立这张地图，你会出现一种很常见的卡点：代码每一行好像都认识，但不知道为什么要这样组合。

例如你看到一个新库时，真正要问的不是“这个函数怎么背”，而是：

• 它把什么变成什么？
• 它替我省掉了哪一步手工处理？
• 它的返回值还能继续调用什么？
• 它和前一天学过的知识有什么关系？

How：最小流程

先写一个只验证本日核心概念的最小例子。今天的重点不是功能多，而是你能说清楚：哪一行负责输入，哪一行负责处理，哪一行给出输出。

text = "csv json csv python agent"
words = text.split()
counts = {}

for word in words:
    counts[word] = counts.get(word, 0) + 1

print({"counts": counts, "unique_words": set(words)})

参数拆解方法

第一次看到 字符串、字典与集合 相关函数、类或配置时，按下面 5 步拆。不要只记名字，要把它放回输入输出关系里。

本日检查顺序：先看输入形状，再看处理动作，最后看输出文件。先 print(type(...))。

和旧知识的连接

新知识不是突然出现的，它通常是旧知识的升级版。

Common Errors

Future Usage

这个知识后面会进入四类场景：

• 数据分析：读取、清洗、聚合、图表、报告。
• Quant：行情、因子、回测、风险指标。
• LLM：上下文、结构化输出、评估样例。
• Agent：Tool 参数、执行日志、状态存储。

4 小时学习节奏

今日强化题（带具体代码）

> 每天正文上限控制在 600 行以内。强化题不是口头描述，必须能落到 main.py 运行。

强化题 1：复现最小案例

任务：把下面参考代码复制到 main.py，先不要改，直接运行。

验收：终端能打印 JSON，且本地生成 outputs/day007/。

强化题 2：替换输入

任务：只改输入数据，至少新增 2 条样例。

验收：输出数量、均值、跳过记录或检索结果发生合理变化。

强化题 3：边界检查

任务：制造 1 个坏输入，例如空值、重复值、非法字段或极端价格。

验收：程序不会静默失败；你能在输出或 errors.md 里解释原因。

强化题 4：结果保存

任务：把运行结果保存到 JSON、CSV、Markdown 或 SQLite 中的一种。

验收：关闭终端后，仍能从文件复查今天结果。

强化题 5：迁移说明

任务：写 3 句话说明 字符串、字典与集合 会如何迁移到 Data、Quant、LLM 或 Agent。

验收：不是写“以后有用”，而是写清具体场景。

参考代码：main.py

from pathlib import Path
import json

DAY = 7
TOPIC = "字符串、字典与集合"
ROOT = Path(__file__).resolve().parent
OUT = ROOT / "outputs" / f"day{DAY:03d}"


def write_json(name, payload):
    OUT.mkdir(parents=True, exist_ok=True)
    path = OUT / name
    path.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
    return path


def count_keywords(text):
    words = text.lower().split()
    counts = {}
    for word in words:
        counts[word] = counts.get(word, 0) + 1
    return {"counts": counts, "unique_words": sorted(set(words))}


def main():
    result = count_keywords("csv json csv python agent json")
    path = write_json("string_dict_set_report.json", {"topic": TOPIC, **result})
    print(json.dumps({"saved_to": str(path), **result}, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

运行命令

python main.py

Debug 记录要求

错误现象：
触发输入：
定位过程：
修复方式：
以后如何避免：

今日复盘模板

Day07：字符串、字典与集合

我今天学会了什么：

这个工具的输入是什么：

这个工具的输出是什么：

我遇到的错误：

我是怎么定位的：

未来会在哪个 IC 使用：

加厚理解：具体执行步骤

加厚不是把同一句话重复很多遍，也不是提前做完整项目。

这一节的加厚只做 8 层，每一层都有明确产出。做完这 8 层，才算从“看过知识点”进入“能迁移使用”。

第 1 层：认知地图

回答 3 个问题：

• 字符串、字典与集合 解决什么问题？
• 它的核心对象、函数或概念有哪些？
• 它和前面已经学过的哪个知识点相连？

产出：在 notes.md 写 5 行以内的知识地图。

第 2 层：输入 -> 处理 -> 输出

把本节内容压成一张表：

产出：写出 1 个最小输入和 1 个最小输出。

第 3 层：最小可运行代码

只写一个最小例子，不加复杂功能。

要求：

• 能直接运行。
• 代码不超过 30 行。
• 只验证一个核心概念。
• 运行后能看到明确输出。

产出：main.py。

第 4 层：逐对象拆解

第一次出现的新函数、新类、新参数，必须拆开。

格式：

对象/函数：
它是什么：
输入是什么：
输出是什么：
为什么不用旧方法：
最容易错在哪里：

产出：notes.md 里的“对象拆解”小节。

第 5 层：错误实验

主动制造 2 个错误，而不是等报错后慌。

例子：

• 路径写错。
• 类型传错。
• 字段名不存在。
• 空数据。
• 编码不对。
• 边界条件为 0 或空列表。

产出：errors.md，记录错误信息、原因和修复方式。

第 6 层：旧知识连接

写清楚它不是凭空出现的新知识。

模板：

昨天/之前我会：
今天升级成：
升级后解决的问题：

产出：3 行连接说明。

第 7 层：迁移场景

至少连接到一个方向：

• Data：它如何帮助数据清洗、分析、可视化或报告。
• Quant：它如何帮助行情、指标、回测、风险或实验记录。
• LLM：它如何帮助 prompt、context、embedding、RAG 或 evaluation。
• Agent：它如何帮助 tool、memory、workflow、logging 或 review。

产出：选择 1 个方向，写 3 句话。

第 8 层：IC100 衔接

找到一个最近的 IC，把今天的知识放进去用一次。

要求：

• 不做大项目。
• 只完成一个小动作。
• 留下 GitHub commit。
• 在 review 里写清今天知识点怎么被用到。

产出：对应 IC 的 review.md 或当天提交说明。

30 分钟加厚执行清单

5 分钟：写认知地图
5 分钟：写输入 -> 处理 -> 输出
10 分钟：跑最小代码
5 分钟：制造并修复 1 个错误
5 分钟：写 IC100 迁移说明

判断标准：如果这 30 分钟做不完，说明加厚范围太大，需要砍掉内容，而不是继续堆字数。

Day08 - 文件读写与异常处理

> 阶段一：Python 零基础与语法地基

学习定位

读写文本文件，并处理文件不存在的情况。

今天的目标不是背语法，而是产出：一个能保存学习记录的脚本。

前置知识

• 推荐前置：Day07 字符串和函数
• 上一站：Day07
• 下一站：Day09

今日知识地图

• Path
• read_text/write_text
• try/except

核心讲解

今天的关键词是 读写文本文件，并处理文件不存在的情况。学习时不要只看语法表面，而要始终追问三件事：输入是什么、处理逻辑是什么、输出要给谁使用。这个习惯会贯穿数据分析、Quant、LLM 应用和 Agent tool 设计。

从工程角度看，今天的能力要服务于 日志、报告、配置和本地缓存。也就是说，代码不只是“能跑”，还要能被未来的自己复查：文件名清楚、变量名能表达含义、失败时有可读错误、结果能保存。

难度承接上，今天依赖 Day07 字符串和函数；完成后会自然进入 Day09。如果今天卡住，优先回看 Day07，不要跳到更复杂的库或主题。

知识点结构

定义

读写文本文件，并处理文件不存在的情况，是把一个具体问题拆成可运行、可检查、可复用代码的过程。

为什么存在

它让学习从临时笔记变成长期资产。公开仓库里的每一天都应该能让读者看到：今天学什么、为什么学、怎么运行、如何检查结果。

最小案例

from pathlib import Path

path = Path("learning_log.txt")
path.write_text("Day08: 文件读写\n", encoding="utf-8")
try:
    print(path.read_text(encoding="utf-8"))
except FileNotFoundError:
    print("文件不存在，请先生成")

常见错误

• 文件路径写错后不检查当前目录。
• 打开文件时忘记指定 encoding="utf-8"。
• 用异常处理掩盖真正的数据问题。

工程应用

• 数据分析脚本
• Quant 研究模块
• LLM 报告助手
• Agent tool / workflow

未来扩展

今天只做最小闭环。后续可以逐步加入测试、日志、配置、页面、API 或主题文档，但不要牺牲可解释性。

基础详细讲解

如果你完全看不懂，先只抓这一句话

今天学的是：程序不仅能在终端显示结果，还能把结果写进文件，下次再读回来。

内存里的数据 -> 写入文件 -> 程序结束后仍然存在
文件里的数据 -> 读取出来 -> 继续处理

前几天你的数据都在代码里，程序一关就没了。文件读写让代码有了“长期记忆”。

文件读写到底发生了什么

from pathlib import Path

path = Path("note.txt")
path.write_text("hello", encoding="utf-8")
content = path.read_text(encoding="utf-8")
print(content)

执行顺序：

路径为什么容易错

相对路径是相对“你运行命令的目录”，不是永远相对 .py 文件。看不懂路径时，先运行：

from pathlib import Path
print(Path.cwd())

它会告诉你当前工作目录。

Mac 终端、当前目录与 Path

你在 Mac 终端里运行 Python 时，路径会和终端当前所在目录绑定。先记住这条线：

终端当前目录 pwd -> Python 的 Path.cwd() -> 相对路径从这里开始找

在终端里：

pwd
ls
python3 day08_file.py

在 Python 里：

from pathlib import Path

script_folder = Path(__file__).resolve().parent
print("script_folder =", script_folder)
print("run_from =", Path.cwd())

pwd 和 Path.cwd() 通常应该对应同一个目录。比如你在桌面运行脚本，Path("log.txt") 就会在桌面生成 log.txt；你在主题目录运行脚本，它就会在主题目录生成。

Path 和 Mac 终端命令的对应关系

终端命令更像“你手动操作文件系统”；Path 更像“让 Python 自动操作文件系统”。工程化脚本的价值就在这里：你不用每天手动 mkdir、touch，可以让 Python 按规则批量生成。

工程化例子：批量生成每日学习文件

假设你想一次性生成 Day09-Day20 的学习文件，不要手动一个个建。可以这样写：

from pathlib import Path

root = Path("Learning-Journal")
root.mkdir(exist_ok=True)

days = range(9, 21)

for day in days:
    file_path = root / f"Day{day:02d}.md"
    content = f"""# Day{day:02d} 学习日志

## 今日主题

## 练习记录

## Debug

## 明天要复习
"""
    file_path.write_text(content, encoding="utf-8")
    print("created", file_path)

这段代码的工程含义：

为什么工程里喜欢 Path，而不是手写字符串路径

不要这样拼路径：

file_path = "Learning-Journal/" + "Day09.md"

更推荐：

from pathlib import Path

file_path = Path("Learning-Journal") / "Day09.md"
print(file_path)

原因是：Path 更清楚、更稳，也更容易迁移。以后你做数据主题，会经常写：

from pathlib import Path

project_root = Path.cwd()
raw_data = project_root / "data" / "raw" / "prices.csv"
report = project_root / "reports" / "summary.md"
print(raw_data)
print(report)

这就是工程化路径管理。

异常处理先这样理解

from pathlib import Path

path = Path("missing_note.txt")
try:
    content = path.read_text(encoding="utf-8")
except FileNotFoundError:
    content = ""
print({"content": content, "exists": path.exists()})

意思是：先尝试读文件；如果文件不存在，不要让程序直接崩掉，而是给一个可解释的处理方式。

Debug 对照表

文件读写与异常处理

程序真正有用，往往从“能读外部文件、能保存结果”开始。文件读写让代码和数据发生连接，异常处理让程序在失败时给出解释，而不是直接中断。

基础知识深讲：文件系统、持久化与异常

程序运行时的数据通常只存在内存里，程序结束就消失。文件读写解决的是持久化问题：把结果保存到硬盘，下次还能读取。学习文件不是为了背 open()，而是理解输入输出从终端扩展到了文件系统。

路径是文件读写最容易混乱的地方。相对路径不是相对文件所在位置，而是相对当前运行命令的工作目录。Path.cwd() 能告诉你当前目录。后面主题里推荐使用 pathlib.Path，因为它能让路径拼接更清楚，例如 root / "data" / "sample.csv"。

异常处理不是“掩盖错误”，而是把失败变成可解释流程。文件不存在、格式不对、权限不足，都应该有明确反馈。try / except 应该包住可能失败的最小代码块；包太大，会让你不知道到底哪一步失败。

读写文件还要区分文本和结构化数据。普通 .txt 适合自由文本，.json 适合字典/列表结构，.csv 适合表格。选择文件格式，就是选择未来如何复查和复用数据。

手写顺序

• 优先使用 Path 管理路径，减少目录混乱。
• 读文件时先确认文件是否存在，再处理内容。
• try / except 只包住可能失败的那一小段，错误信息要能帮助定位。

今天必须真正弄懂

• 输入：今天这段代码从哪里拿到数据，是手写值、终端输入、文件，还是函数参数。
• 处理：每一行代码改变了什么状态，例如变量变了、列表多了一个元素、判断走了某个分支。
• 输出：结果给谁看，是终端输出、返回值、文件，还是后面函数继续使用。

和后续知识的关系

日志、CSV、Markdown 报告、RAG 文档、回测结果都需要文件读写。今天练的是主题的输入输出层。

零基础拆解：文件输入输出和失败处理

这一天到底在练什么

文件让程序有了长期记忆。读文件是输入，写文件是输出，异常处理负责让失败变得可解释。

手写时按这个顺序

• 先用 Path("notes.txt") 表示路径。
• 写入一行内容，再读出来打印。
• 把可能失败的读取放进 try/except，记录错误原因。

最常见卡点

路径错误最常见。先打印 Path.cwd() 看当前目录，再确认文件名、后缀和大小写。

自查问题

• 我能解释相对路径相对哪里。
• 我能写入并重新读出一个文本文件。
• 我能处理文件不存在的情况。

2 小时学习节奏

• 15 分钟：读定位、前置和知识地图。
• 25 分钟：手打最小案例并运行。
• 35 分钟：完成 7 道简单路线题。
• 35 分钟：完成 5 道基础巩固题。
• 10 分钟：记录 Debug、结果和下一步。

简单路线 7 题

1. 新建 day08_file.py。

2. 用 Path 创建 learning_log.txt。

3. 写入一行学习记录。

4. 读取文件并打印。

5. 删除文件后运行，观察 FileNotFoundError。

6. 用 try/except 输出清晰提示。

7. 写下文件输入和输出分别是什么。

今日强化题（带具体代码）

> 每天正文上限控制在 600 行以内。强化题不是口头描述，必须能落到 main.py 运行。

强化题 1：复现最小案例

任务：把下面参考代码复制到 main.py，先不要改，直接运行。

验收：终端能打印 JSON，且本地生成 outputs/day008/。

强化题 2：替换输入

任务：只改输入数据，至少新增 2 条样例。

验收：输出数量、均值、跳过记录或检索结果发生合理变化。

强化题 3：边界检查

任务：制造 1 个坏输入，例如空值、重复值、非法字段或极端价格。

验收：程序不会静默失败；你能在输出或 errors.md 里解释原因。

强化题 4：结果保存

任务：把运行结果保存到 JSON、CSV、Markdown 或 SQLite 中的一种。

验收：关闭终端后，仍能从文件复查今天结果。

强化题 5：迁移说明

任务：写 3 句话说明 文件读写与异常处理 会如何迁移到 Data、Quant、LLM 或 Agent。

验收：不是写“以后有用”，而是写清具体场景。

参考代码：main.py

from pathlib import Path
import json

DAY = 8
TOPIC = "文件读写与异常处理"
ROOT = Path(__file__).resolve().parent
OUT = ROOT / "outputs" / f"day{DAY:03d}"


def write_json(name, payload):
    OUT.mkdir(parents=True, exist_ok=True)
    path = OUT / name
    path.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
    return path


def safe_write_and_read(filename, content):
    OUT.mkdir(parents=True, exist_ok=True)
    path = OUT / filename
    try:
        path.write_text(content, encoding="utf-8")
        return {"ok": True, "path": str(path), "content": path.read_text(encoding="utf-8").strip()}
    except OSError as exc:
        return {"ok": False, "error": str(exc)}


def main():
    file_result = safe_write_and_read("learning_note.txt", "Day08 file io and exception")
    path = write_json("file_exception_report.json", {"topic": TOPIC, "file_result": file_result})
    print(json.dumps({"saved_to": str(path), **file_result}, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

运行命令

python main.py

Debug 记录要求

错误现象：
触发输入：
定位过程：
修复方式：
以后如何避免：

Debug 记录模板

错误现象：
触发输入：
定位过程：
修复方式：
以后如何避免：

复习检查

• [ ] 我能解释今天能力的输入、处理和输出。
• [ ] 我能从零手打最小案例。
• [ ] 我完成了今日强化题，并运行了 main.py 参考代码。
• [ ] 我把结果保存成可复查产物。

参考资料

• Python 官方文档

Day09 - 模块、包与可复用脚本

> 阶段一：Python 基础

学习定位

今天只学习一个核心主题：把 模块、包与可复用脚本 学成可运行、可解释、可迁移的知识点。

目标不是背 API，而是建立认知地图：这个工具解决什么问题、输入是什么、输出是什么、出错时怎么定位。

Day 主线控制在 4 小时以内，但内容保持足够厚：先理解，再写最小代码，再做小练习。

前置知识

• 上一站：Day08
• 下一站：Day10
• 必须先会：文件路径、函数、列表或字典的基本操作。

认知地图

先看全局，不直接上复杂代码。

工具地图

今天先把 模块、包与可复用脚本 放进一张工具地图里。你只需要抓住“输入 -> 处理 -> 输出”，不用先背完整 API。

What

模块、包与可复用脚本 是 Python 工业化学习中的一个小能力。

它的核心是把“人能看懂的东西”变成“程序也能稳定读取、处理和复查的结构”。

学习时不要只看函数名，要同时看三件事：

1. 输入数据长什么样。

2. 输出结果长什么样。

3. 错误发生时从哪里开始查。

Why

如果不先建立这张地图，你会出现一种很常见的卡点：代码每一行好像都认识，但不知道为什么要这样组合。

例如你看到一个新库时，真正要问的不是“这个函数怎么背”，而是：

• 它把什么变成什么？
• 它替我省掉了哪一步手工处理？
• 它的返回值还能继续调用什么？
• 它和前一天学过的知识有什么关系？

How：最小流程

先写一个只验证本日核心概念的最小例子。今天的重点不是功能多，而是你能说清楚：哪一行负责输入，哪一行负责处理，哪一行给出输出。

def normalize_topic(topic):
    return topic.strip().lower().replace(" ", "-")

def build_filename(day, topic):
    return f"day{day:03d}-{normalize_topic(topic)}.md"

print(build_filename(9, "Reusable Script"))

参数拆解方法

第一次看到 模块、包与可复用脚本 相关函数、类或配置时，按下面 5 步拆。不要只记名字，要把它放回输入输出关系里。

本日检查顺序：先看输入形状，再看处理动作，最后看输出文件。先 print(type(...))。

和旧知识的连接

新知识不是突然出现的，它通常是旧知识的升级版。

Common Errors

Future Usage

这个知识后面会进入四类场景：

• 数据分析：读取、清洗、聚合、图表、报告。
• Quant：行情、因子、回测、风险指标。
• LLM：上下文、结构化输出、评估样例。
• Agent：Tool 参数、执行日志、状态存储。

4 小时学习节奏

今日强化题（带具体代码）

> 每天正文上限控制在 600 行以内。强化题不是口头描述，必须能落到 main.py 运行。

强化题 1：复现最小案例

任务：把下面参考代码复制到 main.py，先不要改，直接运行。

验收：终端能打印 JSON，且本地生成 outputs/day009/。

强化题 2：替换输入

任务：只改输入数据，至少新增 2 条样例。

验收：输出数量、均值、跳过记录或检索结果发生合理变化。

强化题 3：边界检查

任务：制造 1 个坏输入，例如空值、重复值、非法字段或极端价格。

验收：程序不会静默失败；你能在输出或 errors.md 里解释原因。

强化题 4：结果保存

任务：把运行结果保存到 JSON、CSV、Markdown 或 SQLite 中的一种。

验收：关闭终端后，仍能从文件复查今天结果。

强化题 5：迁移说明

任务：写 3 句话说明 模块、包与可复用脚本 会如何迁移到 Data、Quant、LLM 或 Agent。

验收：不是写“以后有用”，而是写清具体场景。

参考代码：main.py

from pathlib import Path
import json

DAY = 9
TOPIC = "模块、包与可复用脚本"
ROOT = Path(__file__).resolve().parent
OUT = ROOT / "outputs" / f"day{DAY:03d}"


def write_json(name, payload):
    OUT.mkdir(parents=True, exist_ok=True)
    path = OUT / name
    path.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
    return path


def normalize_name(name):
    return name.strip().lower().replace(" ", "_")


def build_module_plan(functions):
    return {
        "module": "learning_utils.py",
        "functions": [normalize_name(name) for name in functions],
        "import_example": "from learning_utils import normalize_name",
    }


def main():
    plan = build_module_plan(["Clean Topic", "Save Report", "Load Config"])
    path = write_json("module_reuse_plan.json", {"topic": TOPIC, **plan})
    print(json.dumps({"saved_to": str(path), **plan}, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

运行命令

python main.py

Debug 记录要求

错误现象：
触发输入：
定位过程：
修复方式：
以后如何避免：

今日复盘模板

Day09：模块、包与可复用脚本

我今天学会了什么：

这个工具的输入是什么：

这个工具的输出是什么：

我遇到的错误：

我是怎么定位的：

未来会在哪个 IC 使用：

加厚理解：具体执行步骤

加厚不是把同一句话重复很多遍，也不是提前做完整项目。

这一节的加厚只做 8 层，每一层都有明确产出。做完这 8 层，才算从“看过知识点”进入“能迁移使用”。

第 1 层：认知地图

回答 3 个问题：

• 模块、包与可复用脚本 解决什么问题？
• 它的核心对象、函数或概念有哪些？
• 它和前面已经学过的哪个知识点相连？

产出：在 notes.md 写 5 行以内的知识地图。

第 2 层：输入 -> 处理 -> 输出

把本节内容压成一张表：

产出：写出 1 个最小输入和 1 个最小输出。

第 3 层：最小可运行代码

只写一个最小例子，不加复杂功能。

要求：

• 能直接运行。
• 代码不超过 30 行。
• 只验证一个核心概念。
• 运行后能看到明确输出。

产出：main.py。

第 4 层：逐对象拆解

第一次出现的新函数、新类、新参数，必须拆开。

格式：

对象/函数：
它是什么：
输入是什么：
输出是什么：
为什么不用旧方法：
最容易错在哪里：

产出：notes.md 里的“对象拆解”小节。

第 5 层：错误实验

主动制造 2 个错误，而不是等报错后慌。

例子：

• 路径写错。
• 类型传错。
• 字段名不存在。
• 空数据。
• 编码不对。
• 边界条件为 0 或空列表。

产出：errors.md，记录错误信息、原因和修复方式。

第 6 层：旧知识连接

写清楚它不是凭空出现的新知识。

模板：

昨天/之前我会：
今天升级成：
升级后解决的问题：

产出：3 行连接说明。

第 7 层：迁移场景

至少连接到一个方向：

• Data：它如何帮助数据清洗、分析、可视化或报告。
• Quant：它如何帮助行情、指标、回测、风险或实验记录。
• LLM：它如何帮助 prompt、context、embedding、RAG 或 evaluation。
• Agent：它如何帮助 tool、memory、workflow、logging 或 review。

产出：选择 1 个方向，写 3 句话。

第 8 层：IC100 衔接

找到一个最近的 IC，把今天的知识放进去用一次。

要求：

• 不做大项目。
• 只完成一个小动作。
• 留下 GitHub commit。
• 在 review 里写清今天知识点怎么被用到。

产出：对应 IC 的 review.md 或当天提交说明。

30 分钟加厚执行清单

5 分钟：写认知地图
5 分钟：写输入 -> 处理 -> 输出
10 分钟：跑最小代码
5 分钟：制造并修复 1 个错误
5 分钟：写 IC100 迁移说明

判断标准：如果这 30 分钟做不完，说明加厚范围太大，需要砍掉内容，而不是继续堆字数。

Day10 - 学习记录 CLI 基础

> 阶段一：Python 基础

学习定位

今天只学习一个核心主题：把 学习记录 CLI 基础 学成可运行、可解释、可迁移的知识点。

目标不是背 API，而是建立认知地图：这个工具解决什么问题、输入是什么、输出是什么、出错时怎么定位。

Day 主线控制在 4 小时以内，但内容保持足够厚：先理解，再写最小代码，再做小练习。

前置知识

• 上一站：Day09
• 下一站：Day11
• 必须先会：文件路径、函数、列表或字典的基本操作。

认知地图

先看全局，不直接上复杂代码。

工具地图

今天先把 学习记录 CLI 基础 放进一张工具地图里。你只需要抓住“输入 -> 处理 -> 输出”，不用先背完整 API。

What

学习记录 CLI 基础 是 Python 工业化学习中的一个小能力。

它的核心是把“人能看懂的东西”变成“程序也能稳定读取、处理和复查的结构”。

学习时不要只看函数名，要同时看三件事：

1. 输入数据长什么样。

2. 输出结果长什么样。

3. 错误发生时从哪里开始查。

Why

如果不先建立这张地图，你会出现一种很常见的卡点：代码每一行好像都认识，但不知道为什么要这样组合。

例如你看到一个新库时，真正要问的不是“这个函数怎么背”，而是：

• 它把什么变成什么？
• 它替我省掉了哪一步手工处理？
• 它的返回值还能继续调用什么？
• 它和前一天学过的知识有什么关系？

How：最小流程

先写一个只验证本日核心概念的最小例子。今天的重点不是功能多，而是你能说清楚：哪一行负责输入，哪一行负责处理，哪一行给出输出。

import argparse

parser = argparse.ArgumentParser()
parser.add_argument("--minutes", type=int, default=30)
parser.add_argument("--topic", default="csv")
args = parser.parse_args([])

print({"topic": args.topic, "minutes": args.minutes})

参数拆解方法

第一次看到 学习记录 CLI 基础 相关函数、类或配置时，按下面 5 步拆。不要只记名字，要把它放回输入输出关系里。

本日检查顺序：先看输入形状，再看处理动作，最后看输出文件。先 print(type(...))。

和旧知识的连接

新知识不是突然出现的，它通常是旧知识的升级版。

Common Errors

Future Usage

这个知识后面会进入四类场景：

• 数据分析：读取、清洗、聚合、图表、报告。
• Quant：行情、因子、回测、风险指标。
• LLM：上下文、结构化输出、评估样例。
• Agent：Tool 参数、执行日志、状态存储。

4 小时学习节奏

今日强化题（带具体代码）

> 每天正文上限控制在 600 行以内。强化题不是口头描述，必须能落到 main.py 运行。

强化题 1：复现最小案例

任务：把下面参考代码复制到 main.py，先不要改，直接运行。

验收：终端能打印 JSON，且本地生成 outputs/day010/。

强化题 2：替换输入

任务：只改输入数据，至少新增 2 条样例。

验收：输出数量、均值、跳过记录或检索结果发生合理变化。

强化题 3：边界检查

任务：制造 1 个坏输入，例如空值、重复值、非法字段或极端价格。

验收：程序不会静默失败；你能在输出或 errors.md 里解释原因。

强化题 4：结果保存

任务：把运行结果保存到 JSON、CSV、Markdown 或 SQLite 中的一种。

验收：关闭终端后，仍能从文件复查今天结果。

强化题 5：迁移说明

任务：写 3 句话说明 学习记录 CLI 基础 会如何迁移到 Data、Quant、LLM 或 Agent。

验收：不是写“以后有用”，而是写清具体场景。

参考代码：main.py

from pathlib import Path
import json

DAY = 10
TOPIC = "学习记录 CLI 基础"
ROOT = Path(__file__).resolve().parent
OUT = ROOT / "outputs" / f"day{DAY:03d}"


def write_json(name, payload):
    OUT.mkdir(parents=True, exist_ok=True)
    path = OUT / name
    path.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
    return path


def parse_cli_like_args(args):
    result = {"topic": "unknown", "minutes": 0}
    for index, value in enumerate(args):
        if value == "--topic" and index + 1 < len(args):
            result["topic"] = args[index + 1]
        if value == "--minutes" and index + 1 < len(args):
            result["minutes"] = int(args[index + 1])
    return result


def main():
    parsed = parse_cli_like_args(["--topic", "csv", "--minutes", "45"])
    path = write_json("cli_learning_record.json", {"course_topic": TOPIC, **parsed})
    print(json.dumps({"saved_to": str(path), **parsed}, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

运行命令

python main.py

Debug 记录要求

错误现象：
触发输入：
定位过程：
修复方式：
以后如何避免：

今日复盘模板

Day10：学习记录 CLI 基础

我今天学会了什么：

这个工具的输入是什么：

这个工具的输出是什么：

我遇到的错误：

我是怎么定位的：

未来会在哪个 IC 使用：

加厚理解：具体执行步骤

加厚不是把同一句话重复很多遍，也不是提前做完整项目。

这一节的加厚只做 8 层，每一层都有明确产出。做完这 8 层，才算从“看过知识点”进入“能迁移使用”。

第 1 层：认知地图

回答 3 个问题：

• 学习记录 CLI 基础 解决什么问题？
• 它的核心对象、函数或概念有哪些？
• 它和前面已经学过的哪个知识点相连？

产出：在 notes.md 写 5 行以内的知识地图。

第 2 层：输入 -> 处理 -> 输出

把本节内容压成一张表：

产出：写出 1 个最小输入和 1 个最小输出。

第 3 层：最小可运行代码

只写一个最小例子，不加复杂功能。

要求：

• 能直接运行。
• 代码不超过 30 行。
• 只验证一个核心概念。
• 运行后能看到明确输出。

产出：main.py。

第 4 层：逐对象拆解

第一次出现的新函数、新类、新参数，必须拆开。

格式：

对象/函数：
它是什么：
输入是什么：
输出是什么：
为什么不用旧方法：
最容易错在哪里：

产出：notes.md 里的“对象拆解”小节。

第 5 层：错误实验

主动制造 2 个错误，而不是等报错后慌。

例子：

• 路径写错。
• 类型传错。
• 字段名不存在。
• 空数据。
• 编码不对。
• 边界条件为 0 或空列表。

产出：errors.md，记录错误信息、原因和修复方式。

第 6 层：旧知识连接

写清楚它不是凭空出现的新知识。

模板：

昨天/之前我会：
今天升级成：
升级后解决的问题：

产出：3 行连接说明。

第 7 层：迁移场景

至少连接到一个方向：

• Data：它如何帮助数据清洗、分析、可视化或报告。
• Quant：它如何帮助行情、指标、回测、风险或实验记录。
• LLM：它如何帮助 prompt、context、embedding、RAG 或 evaluation。
• Agent：它如何帮助 tool、memory、workflow、logging 或 review。

产出：选择 1 个方向，写 3 句话。

第 8 层：IC100 衔接

找到一个最近的 IC，把今天的知识放进去用一次。

要求：

• 不做大项目。
• 只完成一个小动作。
• 留下 GitHub commit。
• 在 review 里写清今天知识点怎么被用到。

产出：对应 IC 的 review.md 或当天提交说明。

30 分钟加厚执行清单

5 分钟：写认知地图
5 分钟：写输入 -> 处理 -> 输出
10 分钟：跑最小代码
5 分钟：制造并修复 1 个错误
5 分钟：写 IC100 迁移说明

判断标准：如果这 30 分钟做不完，说明加厚范围太大，需要砍掉内容，而不是继续堆字数。

Day11 - CSV 基础 reader / writer

> 阶段二：Python 工程化基本功

学习定位

今天只学习一个核心主题：csv.reader / csv.writer：CSV -> list，list -> CSV。

你已经会 Day10 的本地 CLI，也会 open()、f.write()、列表和循环。今天不是突然背一个新库，而是把“手工写文本”升级成“按表格结构读写数据”。

Day 主线控制在 4 小时以内：先建立 CSV 库认知地图，再写最小 reader / writer，再做边界实验。

前置知识

• 上一站：Day10 CLI 基础
• 下一站：Day12 CSV 进阶 DictReader / DictWriter
• 必须先会：文件路径、with open(...) as f、列表、循环、int() 类型转换。

认知地图

CSV 可以先理解成“纯文本表格”。

topic,minutes
python,120
sql,90

它看起来像 Excel，但本质还是文本文件：逗号分隔列，换行分隔行。

今天只学这四个点，不学 DictReader 和 DictWriter。后者留到 Day12。

What

csv 是 Python 标准库里专门处理 CSV 的工具箱。

reader / writer 是最基础的一对工具：

reader: CSV 文件 -> 一行行 list
writer: list 行 -> CSV 文件

这比手写 "a,b,c\n" 稳，因为 CSV 里会遇到逗号、换行、空字段、引号等细节。库的价值就是替你处理这些格式细节。

Why

昨天如果要保存一组表格记录，你可能会这样写：

from pathlib import Path

path = Path("manual_records.csv")
with path.open("w", encoding="utf-8") as f:
    f.write("day,topic,minutes\n")
    f.write("11,csv,35\n")
print(path.read_text(encoding="utf-8"))

这能跑，但问题是：

• 字段顺序靠你手工记。
• 值里有逗号时容易乱。
• 多写几行后换行和空格容易出错。
• 读回来时还要自己 split(",")。

csv.writer 和 csv.reader 的意义是：把“文本拼接”升级成“表格行读写”。

How：从旧方法升级到 reader / writer

先看数据流，不直接背 API。

list 行数据
  ↓
csv.writer(f).writerows(rows)
  ↓
records.csv
  ↓
csv.reader(f)
  ↓
一行行 list
  ↓
跳过表头、转换 minutes、汇总

最小写入

import csv
from pathlib import Path

path = Path("records.csv")
rows = [
    ["day", "topic", "minutes"],
    ["11", "csv reader writer", "35"],
    ["12", "dict csv", "45"],
]

with path.open("w", newline="", encoding="utf-8") as f:
    writer = csv.writer(f)
    writer.writerows(rows)

最小读取

import csv
from pathlib import Path

path = Path("records.csv")
rows = [
    ["day", "topic", "minutes"],
    ["11", "csv reader writer", "35"],
]
with path.open("w", newline="", encoding="utf-8") as f:
    csv.writer(f).writerows(rows)

with path.open("r", newline="", encoding="utf-8") as f:
    reader = csv.reader(f)
    for row in reader:
        print(row)

你会看到每一行都是 list：

['day', 'topic', 'minutes']
['11', 'csv reader writer', '35']
['12', 'dict csv', '45']

参数拆解方法

第一次看到 csv.writer(f)，不要只记函数名，按对象拆。

csv.writer(f)

csv.reader(f)

和旧知识的连接

Common Errors

Future Usage

• Data：读取外部原始 CSV，先检查表头和前 5 行。
• Quant：读取行情样例，先把价格、成交量从字符串转成数字。
• LLM：把评估样例保存成 CSV，方便批量对比。
• Agent：把 tool 执行日志先落成表格，后续再分析。

4 小时学习节奏

今日强化题（带具体代码）

强化题 1：复现最小案例

任务：复制下面代码到 main.py 并运行。

验收：终端打印 JSON，生成 outputs/day011/records.csv 和 summary.json。

强化题 2：替换输入

任务：新增 2 行样例记录，至少一行数值字段大于当前样例。

验收：total_minutes 和 long_sessions 会变化。

强化题 3：边界检查

任务：把一行 minutes 改成空字符串或 abc。

验收：程序不会崩溃，坏行进入 skipped。

强化题 4：结果保存

任务：保留 CSV 原始记录，同时保存 JSON 汇总。

验收：关闭终端后还能复查两个文件。

强化题 5：迁移说明

任务：写 3 句话说明 CSV reader / writer 如何迁移到 Data、Quant、LLM 或 Agent。

参考代码：main.py

from pathlib import Path
import csv
import json

DAY = 11
TOPIC = "CSV reader / writer"
ROOT = Path(__file__).resolve().parent
OUT = ROOT / "outputs" / f"day{DAY:03d}"


def ensure_dirs():
    OUT.mkdir(parents=True, exist_ok=True)


def write_csv(path: Path):
    rows = [
        ["day", "topic", "minutes"],
        ["11", "csv reader writer", "35"],
        ["12", "dict csv preview", "45"],
        ["13", "json preview", ""],
    ]
    with path.open("w", newline="", encoding="utf-8") as f:
        writer = csv.writer(f)
        writer.writerows(rows)


def read_csv(path: Path):
    valid = []
    skipped = []
    with path.open("r", newline="", encoding="utf-8") as f:
        reader = csv.reader(f)
        header = next(reader)
        for line_no, row in enumerate(reader, start=2):
            try:
                minutes = int(row[2])
            except (IndexError, ValueError):
                skipped.append({"line": line_no, "row": row, "reason": "bad minutes"})
                continue
            valid.append({"day": row[0], "topic": row[1], "minutes": minutes})
    return header, valid, skipped


def main():
    ensure_dirs()
    csv_path = OUT / "records.csv"
    write_csv(csv_path)
    header, valid, skipped = read_csv(csv_path)
    summary = {
        "topic": TOPIC,
        "header": header,
        "valid_count": len(valid),
        "total_minutes": sum(item["minutes"] for item in valid),
        "long_sessions": [item for item in valid if item["minutes"] >= 45],
        "skipped": skipped,
    }
    (OUT / "summary.json").write_text(json.dumps(summary, ensure_ascii=False, indent=2), encoding="utf-8")
    print(json.dumps(summary, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

Debug 记录要求

错误现象：
触发输入：
定位过程：
修复方式：
以后如何避免：

今日复盘模板

Day11：CSV reader / writer

CSV 的输入是什么：
reader 的输出是什么：
writer 的输入是什么：
我今天最容易错在哪里：
未来会在哪个 IC 使用：

Day12 - CSV 进阶 DictReader / DictWriter

> 阶段二：Python 工程化基本功

学习定位

今天只学习一个核心主题：csv.DictReader / csv.DictWriter：CSV -> dict，dict -> CSV。

Day11 你已经知道 reader 读出来是一行行 list。今天升级成“用字段名读写”，让代码从 row[2] 变成 row["minutes"]。

这一天的核心不是更高级，而是更可读、更稳、更接近真实数据分析。

前置知识

• 上一站：Day11 CSV reader / writer
• 下一站：Day13 JSON 基础 loads / dumps
• 必须先会：dict、字段名、文件读写、int() 类型转换。

认知地图

What

DictReader / DictWriter 是 CSV 工具里的“字段名版本”。

DictReader: CSV -> dict
DictWriter: dict -> CSV

Day11 的 row[2] 依赖列位置；Day12 的 row["minutes"] 依赖字段名。

真实数据里，字段名比位置更重要。你以后读外部数据、行情、评估集时，通常会关心 date、close、label、question 这些字段，而不是“第 3 列”。

Why

不用 DictReader 也能读 CSV，但代码会变脆：

row = ["12", "dict csv", "45"]
minutes = int(row[2])
print(minutes)

如果以后表格列顺序变了，row[2] 可能不再是 minutes。

改成字段名后：

row = {"day": "12", "topic": "dict csv", "minutes": "45"}
minutes = int(row["minutes"])
print(minutes)

你一眼能看懂这行在取什么。字段名也是数据分析里的“变量名”，它让数据有语义。

How：从 list 行升级成 dict 行

数据流是：

dict 记录
  ↓
DictWriter(fieldnames)
  ↓
带表头 CSV
  ↓
DictReader
  ↓
一行行 dict
  ↓
按字段名取值、校验、汇总

最小写入

import csv
from pathlib import Path

path = Path("records.csv")
records = [
    {"day": "11", "topic": "csv reader writer", "minutes": "35"},
    {"day": "12", "topic": "dict csv", "minutes": "45"},
]

with path.open("w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=["day", "topic", "minutes"])
    writer.writeheader()
    writer.writerows(records)

最小读取

import csv
from pathlib import Path

path = Path("records.csv")
records = [
    {"day": "11", "topic": "csv reader writer", "minutes": "35"},
    {"day": "12", "topic": "dict csv", "minutes": "45"},
]
with path.open("w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=["day", "topic", "minutes"])
    writer.writeheader()
    writer.writerows(records)

with path.open("r", newline="", encoding="utf-8") as f:
    reader = csv.DictReader(f)
    for row in reader:
        print(row["topic"], int(row["minutes"]))

参数拆解方法

csv.DictWriter(f, fieldnames=[...])

writer.writeheader()

csv.DictReader(f)

和旧知识的连接

Common Errors

Future Usage

• Data：清洗 CSV 原始数据时，字段名就是变量名。
• Quant：行情字段 date/open/high/low/close/volume 要稳定。
• LLM：评估集字段 question/answer/score 适合 CSV。
• Agent：执行日志里的 step/tool/status/error 可以先用 CSV 复盘。

4 小时学习节奏

今日强化题（带具体代码）

强化题 1：复现最小案例

任务：复制下面代码到 main.py 并运行。

验收：生成 outputs/day012/records.csv 和 summary.json。

强化题 2：替换输入

任务：新增字段 source，例如 book、video、codex。

验收：你能说明为什么 fieldnames 也要同步改。

强化题 3：边界检查

任务：删除一行的 minutes 或把它改成 abc。

验收：坏行进入 skipped，程序继续跑。

强化题 4：结果保存

任务：把有效记录和跳过记录分别保存。

验收：能复查哪些数据被排除。

强化题 5：迁移说明

任务：写 3 句话说明字段意识为什么是 Pandas、SQL、LLM 评估集的基础。

参考代码：main.py

from pathlib import Path
import csv
import json

DAY = 12
TOPIC = "CSV DictReader / DictWriter"
ROOT = Path(__file__).resolve().parent
OUT = ROOT / "outputs" / f"day{DAY:03d}"
FIELDS = ["day", "topic", "minutes", "source"]


def ensure_dirs():
    OUT.mkdir(parents=True, exist_ok=True)


def write_records(path: Path):
    records = [
        {"day": "11", "topic": "csv reader writer", "minutes": "35", "source": "course"},
        {"day": "12", "topic": "dict csv", "minutes": "45", "source": "course"},
        {"day": "12", "topic": "bad row", "minutes": "abc", "source": "manual"},
    ]
    with path.open("w", newline="", encoding="utf-8") as f:
        writer = csv.DictWriter(f, fieldnames=FIELDS)
        writer.writeheader()
        writer.writerows(records)


def load_records(path: Path):
    valid = []
    skipped = []
    with path.open("r", newline="", encoding="utf-8") as f:
        reader = csv.DictReader(f)
        for line_no, row in enumerate(reader, start=2):
            try:
                minutes = int(row["minutes"])
            except ValueError:
                skipped.append({"line": line_no, "row": row, "reason": "minutes is not int"})
                continue
            row["minutes"] = minutes
            valid.append(row)
    return valid, skipped


def main():
    ensure_dirs()
    csv_path = OUT / "records.csv"
    write_records(csv_path)
    valid, skipped = load_records(csv_path)
    summary = {
        "topic": TOPIC,
        "fields": FIELDS,
        "valid_count": len(valid),
        "total_minutes": sum(row["minutes"] for row in valid),
        "sources": sorted({row["source"] for row in valid}),
        "skipped": skipped,
    }
    (OUT / "summary.json").write_text(json.dumps(summary, ensure_ascii=False, indent=2), encoding="utf-8")
    print(json.dumps(summary, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

今日复盘模板

Day12：CSV DictReader / DictWriter

DictReader 的输入是什么：
DictReader 的输出是什么：
fieldnames 决定了什么：
我今天制造了什么错误：
未来会在哪个 IC 使用：

Day13 - JSON 完整学习

> 阶段二：基础 Python 收束

学习定位

今天把 JSON 一次讲完整：JSON 是跨程序传递结构化数据的文本格式；Python 用 json 标准库完成字符串和文件的读写。

前两天你已经学了 CSV。CSV 适合二维表，JSON 适合 dict/list 嵌套结构。今天只聚焦 JSON，不再拆到后面。

认知地图

JSON 与 Python 类型对应

What

JSON 本质是“长得像 dict/list 的文本”。它不是 Python 对象，必须经过解析。

import json

text = '{"name": "item_a", "value": 10}'
data = json.loads(text)
print(data)

text 是字符串，data 是 dict。这个区别非常重要。

Why

JSON 存在的原因是：不同程序、不同语言、不同机器之间需要一种通用结构化格式。

• 配置文件需要保存参数。
• API 需要返回结构化结果。
• LLM 需要输出可校验字段。
• Agent 需要保存 tool 调用状态。
• Quant 实验需要保存参数、指标、错误信息。

How：四个函数一次打通

JSON 字符串 --loads--> Python 对象 --dumps--> JSON 字符串
JSON 文件   --load ---> Python 对象 --dump ---> JSON 文件

字符串读写

import json

text = '{"name": "item_a", "value": 10}'
data = json.loads(text)
print(data["value"])

json_text = json.dumps(data, ensure_ascii=False, indent=2)
print(json_text)

文件读写

from pathlib import Path
import json

path = Path("data.json")
with path.open("w", encoding="utf-8") as f:
    json.dump({"items": [{"name": "item_a", "value": 10}]}, f, ensure_ascii=False, indent=2)

with path.open("r", encoding="utf-8") as f:
    data = json.load(f)

嵌套路径

data = {"items": [{"name": "item_a", "value": 10}]}
value = data["items"][0]["value"]
print(value)

读法：

dict -> key "items" -> list -> index 0 -> dict -> key "value"

参数拆解方法

json.dumps(obj, ensure_ascii=False, indent=2)

json.dump(obj, f, ensure_ascii=False, indent=2)

Common Errors

今日强化题（带具体代码）

强化题 1：跑通四个函数

任务：运行下面代码，确认 loads/dumps/load/dump 都出现。

验收：生成 outputs/day013/records.json 和 summary.json。

强化题 2：替换输入

任务：新增一条 record，并修改一个嵌套字段。

强化题 3：边界检查

任务：把一条 value 改成 null，观察 skipped。

强化题 4：总结 JSON vs CSV

任务：写 3 句话说明什么时候 JSON 比 CSV 更合适。

参考代码：main.py

from pathlib import Path
import json

DAY = 13
OUT = Path(__file__).resolve().parent / "outputs" / f"day{DAY:03d}"


def parse_json_text(text):
    data = json.loads(text)
    return data


def validate_records(data):
    valid = []
    skipped = []
    for index, item in enumerate(data.get("records", [])):
        value = item.get("metrics", {}).get("value")
        if not isinstance(value, (int, float)):
            skipped.append({"index": index, "item": item, "reason": "value must be numeric"})
            continue
        valid.append(item)
    return valid, skipped


def main():
    OUT.mkdir(parents=True, exist_ok=True)
    raw_text = """
    {
      "metadata": {"source": "demo", "schema_version": 1},
      "records": [
        {"name": "item_a", "group": "A", "metrics": {"value": 10}},
        {"name": "item_b", "group": "A", "metrics": {"value": 15}},
        {"name": "item_c", "group": "B", "metrics": {"value": null}}
      ]
    }
    """
    data = parse_json_text(raw_text)
    valid, skipped = validate_records(data)
    with (OUT / "records.json").open("w", encoding="utf-8") as f:
        json.dump(data, f, ensure_ascii=False, indent=2)
    with (OUT / "records.json").open("r", encoding="utf-8") as f:
        loaded = json.load(f)
    summary = {
        "topic": "complete json basics",
        "source": loaded["metadata"]["source"],
        "valid_count": len(valid),
        "total_value": sum(item["metrics"]["value"] for item in valid),
        "skipped": skipped,
    }
    summary_text = json.dumps(summary, ensure_ascii=False, indent=2)
    (OUT / "summary.json").write_text(summary_text, encoding="utf-8")
    print(summary_text)


if __name__ == "__main__":
    main()

今日复盘模板

Day13：JSON 完整学习

loads / dumps 的区别：
load / dump 的区别：
JSON 和 dict/list 的关系：
我今天读懂的一条嵌套路径：
JSON 最常见错误：

Day14 - class、对象、方法与 self

> 阶段二：基础 Python 收束：面向对象

学习定位

今天正式进入 class。目标不是背面向对象术语，而是看懂：class 是模板，对象是实例，属性保存状态，方法保存行为，self 代表当前对象。

认知地图

What

dict 可以保存数据：

row = {"name": "item_a", "value": 10}

class 可以把数据和行为放在一起：

class Record:
    def __init__(self, name, value):
        self.name = name
        self.value = value

    def is_valid(self):
        return self.value >= 0

Why

只用 dict 时，字段和行为分散：

• 字段名容易写错。
• 校验逻辑到处复制。
• 相关函数不知道应该放哪里。
• 程序变大后边界不清楚。

class 的作用是把“某类数据的结构和行为”集中到一个地方。

How：从 JSON/dict 进入 class

dict 数据
  ↓
__init__ 初始化字段
  ↓
self 保存状态
  ↓
方法读取 self 完成计算
  ↓
to_dict 输出回 JSON

最小正规 class

class Record:
    def __init__(self, name, value):
        self.name = name
        self.value = value

    def is_valid(self):
        return isinstance(self.value, (int, float))

对象拆解方法

Common Errors

今日强化题（带具体代码）

强化题 1：复现 class 完整流程

任务：运行下面代码。

验收：生成 outputs/day014/class_records.json。

强化题 2：替换输入

任务：新增一条 raw dict，再转成对象。

强化题 3：边界检查

任务：把 value 改成字符串，确认错误进入 errors。

参考代码：main.py

from pathlib import Path
import json

DAY = 14
OUT = Path(__file__).resolve().parent / "outputs" / f"day{DAY:03d}"


class Record:
    def __init__(self, name, value, group="default"):
        if not name:
            raise ValueError("name is required")
        self.name = name
        self.value = value
        self.group = group

    def is_valid(self):
        return isinstance(self.value, (int, float)) and self.value >= 0

    def score(self, baseline):
        if not self.is_valid() or baseline == 0:
            return None
        return round(self.value / baseline, 4)

    def to_dict(self, baseline):
        return {
            "class": type(self).__name__,
            "name": self.name,
            "group": self.group,
            "value": self.value,
            "valid": self.is_valid(),
            "score": self.score(baseline),
        }


def build_records(raw_items):
    records = []
    errors = []
    for index, item in enumerate(raw_items):
        try:
            record = Record(item.get("name"), item.get("value"), item.get("group", "default"))
        except ValueError as exc:
            errors.append({"index": index, "item": item, "error": str(exc)})
            continue
        records.append(record)
    return records, errors


def main():
    OUT.mkdir(parents=True, exist_ok=True)
    raw_items = [
        {"name": "item_a", "value": 10, "group": "A"},
        {"name": "item_b", "value": 15, "group": "A"},
        {"name": "item_c", "value": "bad", "group": "B"},
        {"name": "", "value": 8, "group": "B"},
    ]
    records, errors = build_records(raw_items)
    valid_values = [record.value for record in records if record.is_valid()]
    baseline = sum(valid_values) / len(valid_values)
    payload = {
        "topic": "class object method self",
        "baseline": baseline,
        "items": [record.to_dict(baseline) for record in records],
        "errors": errors,
    }
    (OUT / "class_records.json").write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
    print(json.dumps(payload, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

今日复盘模板

Day14：class、对象、方法与 self

class 是什么：
对象是什么：
self 代表什么：
__init__ 做什么：
方法和函数的区别：

Day15 - class 正规化与 dataclass

> 阶段二：基础 Python 收束：面向对象

学习定位

今天把 class 学到“够用、正规、能接工程”的水平：dataclass、类型标注、默认值、from_dict、to_dict、对象校验。

学完今天，基础 Python 第一阶段结束。Day16 开始进入数据分析三大库：NumPy、pandas、Matplotlib。

认知地图

What

普通 class：

class Record:
    def __init__(self, name, value):
        self.name = name
        self.value = value

dataclass：

from dataclasses import dataclass

@dataclass
class Record:
    name: str
    value: float

record = Record(name="item_a", value=10.0)
print(record)

它们都能创建对象。dataclass 更适合“主要保存结构化数据”的类。

Why

当对象字段比较固定时，dataclass 能减少重复代码，并让结构更清楚。

它适合：

• 配置对象。
• 数据记录对象。
• API 输入输出对象。
• LLM/Agent 的结构化结果。
• Quant 参数和指标结果。

How：正规对象边界

raw dict
  ↓
from_dict 校验和转换
  ↓
dataclass 对象
  ↓
方法计算
  ↓
to_dict / asdict
  ↓
JSON 保存

参数拆解方法

@dataclass

@classmethod

Common Errors

Future Usage

• NumPy/pandas 里用 dataclass 保存分析配置。
• Matplotlib 里用 dataclass 保存图表参数。
• Quant 里用 dataclass 保存策略参数。
• LLM/Agent 里用 dataclass 保存结构化输入输出。

今日强化题（带具体代码）

强化题 1：复现 dataclass 流程

任务：运行下面代码。

验收：生成 outputs/day015/dataclass_records.json。

强化题 2：替换输入

任务：新增一条 raw dict，并添加 tags。

强化题 3：边界检查

任务：把 value 改成无法转成数字的字符串。

强化题 4：总结

任务：写 3 句话说明普通 class 和 dataclass 的区别。

参考代码：main.py

from dataclasses import dataclass, field, asdict
from pathlib import Path
import json

DAY = 15
OUT = Path(__file__).resolve().parent / "outputs" / f"day{DAY:03d}"


@dataclass
class Record:
    name: str
    value: float
    group: str = "default"
    tags: list[str] = field(default_factory=list)

    @classmethod
    def from_dict(cls, data):
        if not data.get("name"):
            raise ValueError("name is required")
        try:
            value = float(data.get("value"))
        except (TypeError, ValueError):
            raise ValueError("value must be numeric")
        tags = data.get("tags", [])
        if not isinstance(tags, list):
            raise ValueError("tags must be list")
        return cls(
            name=data["name"],
            value=value,
            group=data.get("group", "default"),
            tags=tags,
        )

    def is_high_value(self, threshold):
        return self.value >= threshold

    def to_dict(self, threshold):
        output = asdict(self)
        output["high_value"] = self.is_high_value(threshold)
        return output


def build_records(raw_items):
    records = []
    errors = []
    for index, item in enumerate(raw_items):
        try:
            records.append(Record.from_dict(item))
        except ValueError as exc:
            errors.append({"index": index, "item": item, "error": str(exc)})
    return records, errors


def main():
    OUT.mkdir(parents=True, exist_ok=True)
    raw_items = [
        {"name": "item_a", "value": "10", "group": "A", "tags": ["clean"]},
        {"name": "item_b", "value": 18, "group": "A", "tags": ["important"]},
        {"name": "item_c", "value": "bad", "group": "B"},
    ]
    records, errors = build_records(raw_items)
    values = [record.value for record in records]
    threshold = sum(values) / len(values)
    payload = {
        "topic": "dataclass and typed object boundary",
        "threshold": threshold,
        "items": [record.to_dict(threshold) for record in records],
        "errors": errors,
    }
    (OUT / "dataclass_records.json").write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
    print(json.dumps(payload, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

今日复盘模板

Day15：class 正规化与 dataclass

dataclass 解决什么重复：
类型标注能做什么、不能做什么：
from_dict 的作用：
to_dict 的作用：
基础 Python 到这里结束，我最稳的 5 个能力：

Day16 - NumPy 数组基础

> 阶段三：数据分析三大库

学习定位

今天开始数据分析库。第一站是 NumPy：它把 Python list 升级成可以高速计算的数组。

认知地图

What

NumPy 数组不是普通 list。list 更像容器，NumPy array 更像数学对象。

import numpy as np

arr = np.array([1, 2, 3])
print(arr + 10)  # [11 12 13]

list 不能这样直接做向量计算。

Why

数据分析、机器学习、深度学习和量化都离不开矩阵和向量。NumPy 是这些库的底层基础。

你先要掌握三件事：

1. 数组长什么样：.shape。

2. 数组里面是什么类型：.dtype。

3. 数组如何整体计算：向量化。

How：list -> array -> 计算

Python list
  ↓
np.array
  ↓
ndarray
  ↓
shape / dtype / slicing
  ↓
sum / mean / min / max

参数拆解方法

np.array(data, dtype=float)

Common Errors

今日强化题（带具体代码）

强化题 1：创建一维和二维数组

验收：输出 shape、dtype、列均值。

强化题 2：替换输入

任务：新增一行二维数据。

强化题 3：边界检查

任务：尝试加入字符串，解释为什么要先清洗。

参考代码：main.py

from pathlib import Path
import json
import numpy as np

DAY = 16
OUT = Path(__file__).resolve().parent / "outputs" / f"day{DAY:03d}"


def describe_array(matrix):
    arr = np.array(matrix, dtype=float)
    return {
        "shape": list(arr.shape),
        "dtype": str(arr.dtype),
        "column_sum": arr.sum(axis=0).round(4).tolist(),
        "column_mean": arr.mean(axis=0).round(4).tolist(),
        "first_row": arr[0].tolist(),
    }


def main():
    OUT.mkdir(parents=True, exist_ok=True)
    matrix = [
        [10, 1.2, 0],
        [12, 1.5, 1],
        [9, 1.1, 0],
        [15, 1.8, 1],
    ]
    payload = {"topic": "numpy array basics", "summary": describe_array(matrix)}
    (OUT / "numpy_array_summary.json").write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
    print(json.dumps(payload, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

今日复盘模板

Day16：NumPy 数组基础

ndarray 和 list 的区别：
shape 表示什么：
dtype 表示什么：
axis=0 和 axis=1 的区别：

Day17 - NumPy 向量化与统计

> 阶段三：数据分析三大库

学习定位

今天学习 NumPy 的核心价值：不用手写循环，对整列数据一次性计算。

认知地图

What

向量化就是把“一个一个算”改成“一整列一起算”。

import numpy as np

prices = np.array([100, 102, 101, 105], dtype=float)
returns = prices[1:] / prices[:-1] - 1
print(returns)

这行代码一次性计算所有相邻收益率。

Why

数据分析和 Quant 中，循环容易慢，也容易写错边界。NumPy 用数组运算表达数学关系，更接近统计学和线性代数。

How：价格 -> 收益率 -> 风险指标

prices
  ↓
vectorized return
  ↓
mean / std / drawdown
  ↓
summary

参数拆解方法

np.where(condition, x, y)

Common Errors

今日强化题（带具体代码）

强化题 1：计算收益率

验收：生成 numpy_vector_stats.json。

强化题 2：添加阈值标签

任务：修改 risk_threshold。

参考代码：main.py

from pathlib import Path
import json
import numpy as np

DAY = 17
OUT = Path(__file__).resolve().parent / "outputs" / f"day{DAY:03d}"


def analyze_prices(prices, risk_threshold=0.03):
    arr = np.array(prices, dtype=float)
    returns = arr[1:] / arr[:-1] - 1
    labels = np.where(np.abs(returns) >= risk_threshold, "large_move", "normal")
    cumulative_max = np.maximum.accumulate(arr)
    drawdown = arr / cumulative_max - 1
    return {
        "prices": arr.round(4).tolist(),
        "returns": returns.round(6).tolist(),
        "labels": labels.tolist(),
        "mean_return": round(float(returns.mean()), 6),
        "volatility": round(float(returns.std(ddof=1)), 6),
        "max_drawdown": round(float(drawdown.min()), 6),
    }


def main():
    OUT.mkdir(parents=True, exist_ok=True)
    prices = [100, 102, 101, 107, 103, 110]
    payload = {"topic": "numpy vectorization and statistics", "summary": analyze_prices(prices)}
    (OUT / "numpy_vector_stats.json").write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
    print(json.dumps(payload, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

今日复盘模板

Day17：NumPy 向量化与统计

向量化解决什么问题：
布尔掩码是什么：
np.where 怎么理解：
收益率数组为什么比价格数组少一位：

Day18 - pandas DataFrame 基础

> 阶段三：数据分析三大库

学习定位

今天学习 pandas 的核心对象：DataFrame 是带行列标签的表格。

认知地图

What

pandas DataFrame 可以理解成“有字段名、有行索引的二维表”。

它比 list/dict 更适合做筛选、清洗、分组、聚合、导出。

Why

CSV/JSON 负责保存数据，pandas 负责分析表格数据。

数据分析第一步不是建模，而是体检：

1. 有多少行列？

2. 字段名是什么？

3. 每列类型是什么？

4. 有没有缺失值？

5. 前几行长什么样？

How：dict -> DataFrame -> 体检

records
  ↓
pd.DataFrame
  ↓
head / shape / dtypes / describe
  ↓
summary json

Common Errors

今日强化题（带具体代码）

强化题 1：创建 DataFrame 并体检

验收：生成 pandas_dataframe_profile.json。

参考代码：main.py

from pathlib import Path
import json
import pandas as pd

DAY = 18
OUT = Path(__file__).resolve().parent / "outputs" / f"day{DAY:03d}"


def profile_dataframe(df):
    numeric_df = df.select_dtypes(include="number")
    return {
        "shape": list(df.shape),
        "columns": list(df.columns),
        "dtypes": {column: str(dtype) for column, dtype in df.dtypes.items()},
        "missing": df.isna().sum().to_dict(),
        "numeric_summary": numeric_df.describe().round(4).to_dict(),
        "head": df.head(3).to_dict(orient="records"),
    }


def main():
    OUT.mkdir(parents=True, exist_ok=True)
    rows = [
        {"date": "2026-01-01", "group": "A", "value": 10.0, "flag": 1},
        {"date": "2026-01-02", "group": "A", "value": 12.5, "flag": 0},
        {"date": "2026-01-03", "group": "B", "value": None, "flag": 1},
        {"date": "2026-01-04", "group": "B", "value": 9.5, "flag": 0},
    ]
    df = pd.DataFrame(rows)
    payload = {"topic": "pandas dataframe basics", "profile": profile_dataframe(df)}
    (OUT / "pandas_dataframe_profile.json").write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
    print(json.dumps(payload, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

今日复盘模板

Day18：pandas DataFrame 基础

DataFrame 是什么：
shape 看什么：
dtypes 看什么：
isna().sum() 看什么：

Day19 - pandas 清洗与筛选

> 阶段三：数据分析三大库

学习定位

今天学习 pandas 的第二步：把脏表格变成可分析表格。

认知地图

What

清洗不是“让数据变漂亮”，而是让后续计算可信。

今天只做四件事：

1. 转日期。

2. 转数字。

3. 处理缺失值。

4. 按条件筛选。

Why

真实数据不会按你的想法出现。常见问题：

• 数字列里混入字符串。
• 日期列还是普通文本。
• 关键字段缺失。
• 异常值进入统计。

不清洗就直接分析，结果看起来能跑，实际不可信。

How：原始表 -> 清洗表

raw df
  ↓
copy
  ↓
to_datetime / to_numeric
  ↓
dropna / fillna
  ↓
boolean filter
  ↓
clean df

Common Errors

今日强化题（带具体代码）

强化题 1：清洗一张脏表

验收：生成 pandas_cleaning_report.json 和 cleaned.csv。

参考代码：main.py

from pathlib import Path
import json
import pandas as pd

DAY = 19
OUT = Path(__file__).resolve().parent / "outputs" / f"day{DAY:03d}"


def clean_dataframe(df):
    cleaned = df.copy()
    cleaned["date"] = pd.to_datetime(cleaned["date"], errors="coerce")
    cleaned["value"] = pd.to_numeric(cleaned["value"], errors="coerce")
    before = len(cleaned)
    cleaned = cleaned.dropna(subset=["date", "value"])
    cleaned["group"] = cleaned["group"].fillna("unknown")
    cleaned = cleaned[(cleaned["value"] >= 0) & (cleaned["value"] <= 100)]
    return cleaned, {"before_rows": before, "after_rows": len(cleaned)}


def main():
    OUT.mkdir(parents=True, exist_ok=True)
    raw = pd.DataFrame([
        {"date": "2026-01-01", "group": "A", "value": "10"},
        {"date": "bad-date", "group": "A", "value": "12"},
        {"date": "2026-01-03", "group": None, "value": "bad"},
        {"date": "2026-01-04", "group": "B", "value": "9.5"},
        {"date": "2026-01-05", "group": "B", "value": "999"},
    ])
    cleaned, stats = clean_dataframe(raw)
    cleaned.to_csv(OUT / "cleaned.csv", index=False)
    report = {
        "topic": "pandas cleaning and filtering",
        "stats": stats,
        "dtypes": {column: str(dtype) for column, dtype in cleaned.dtypes.items()},
        "records": cleaned.to_dict(orient="records"),
    }
    (OUT / "pandas_cleaning_report.json").write_text(json.dumps(report, ensure_ascii=False, indent=2, default=str), encoding="utf-8")
    print(json.dumps(report, ensure_ascii=False, indent=2, default=str))


if __name__ == "__main__":
    main()

今日复盘模板

Day19：pandas 清洗与筛选

to_numeric 做什么：
to_datetime 做什么：
dropna 和 fillna 的区别：
布尔筛选最容易错在哪里：

Day20 - pandas 分组聚合

> 阶段三：数据分析三大库

学习定位

今天学习 pandas 的核心分析动作：按类别分组，再计算指标。

认知地图

What

分组聚合就是回答：

每个组分别怎么样？

例如每个 group 的样本数、均值、最大值。

Why

数据分析不只看总体，还要比较分组。统计学里的分组均值、组间差异、样本量意识，在 pandas 里主要靠 groupby。

How：明细表 -> 指标表

clean df
  ↓
groupby("group")
  ↓
agg count mean max
  ↓
sort / save

Common Errors

今日强化题（带具体代码）

强化题 1：生成分组指标表

验收：生成 group_metrics.csv 和 group_metrics.json。

参考代码：main.py

from pathlib import Path
import json
import pandas as pd

DAY = 20
OUT = Path(__file__).resolve().parent / "outputs" / f"day{DAY:03d}"


def build_group_metrics(df):
    grouped = (
        df.groupby("group", dropna=False)
        .agg(
            n=("value", "count"),
            mean_value=("value", "mean"),
            max_value=("value", "max"),
            min_value=("value", "min"),
        )
        .reset_index()
        .sort_values("mean_value", ascending=False)
    )
    grouped["mean_value"] = grouped["mean_value"].round(4)
    return grouped


def main():
    OUT.mkdir(parents=True, exist_ok=True)
    df = pd.DataFrame([
        {"group": "A", "value": 10},
        {"group": "A", "value": 12},
        {"group": "A", "value": 15},
        {"group": "B", "value": 8},
        {"group": "B", "value": 11},
        {"group": "C", "value": 20},
    ])
    metrics = build_group_metrics(df)
    metrics.to_csv(OUT / "group_metrics.csv", index=False)
    payload = {
        "topic": "pandas groupby aggregation",
        "metrics": metrics.to_dict(orient="records"),
    }
    (OUT / "group_metrics.json").write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
    print(json.dumps(payload, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

今日复盘模板

Day20：pandas 分组聚合

groupby 解决什么问题：
agg 的输入输出是什么：
为什么要同时看 n 和 mean：
reset_index 为什么常用：

Day21 - Matplotlib 基础图表

> 阶段三：数据分析三大库

学习定位

今天学习 Matplotlib：把数据变成可复查的图表文件。

本机环境如果 Matplotlib 暂时不可用，参考代码会自动降级保存文本报告，保证学习不中断。

认知地图

What

Matplotlib 是 Python 最基础的绘图库。它关注三层：

figure 整张图
axis/ax 一个子图
plot/bar/scatter 图形元素

Why

数据分析不能只给表。图表能更快暴露趋势、异常、分组差异。

How：数据 -> 图表 -> 文件

x/y 数据
  ↓
fig, ax
  ↓
ax.plot / ax.bar
  ↓
title / labels
  ↓
savefig

Common Errors

今日强化题（带具体代码）

强化题 1：保存一张趋势图

验收：环境正常时生成 PNG；环境异常时生成 fallback 文本。

参考代码：main.py

from pathlib import Path
import json

DAY = 21
OUT = Path(__file__).resolve().parent / "outputs" / f"day{DAY:03d}"


def save_line_plot(x, y, path):
    try:
        import matplotlib
        matplotlib.use("Agg")
        import matplotlib.pyplot as plt
    except Exception as exc:
        fallback = path.with_suffix(".txt")
        fallback.write_text(f"matplotlib unavailable: {type(exc).__name__}: {exc}\\nx={x}\\ny={y}\\n", encoding="utf-8")
        return {"ok": False, "fallback": str(fallback), "error": str(exc)}

    fig, ax = plt.subplots(figsize=(6, 4))
    ax.plot(x, y, marker="o")
    ax.set_title("Value Trend")
    ax.set_xlabel("step")
    ax.set_ylabel("value")
    ax.grid(True, alpha=0.3)
    fig.tight_layout()
    fig.savefig(path, dpi=150)
    plt.close(fig)
    return {"ok": True, "image": str(path)}


def main():
    OUT.mkdir(parents=True, exist_ok=True)
    x = [1, 2, 3, 4, 5]
    y = [10, 12, 9, 15, 18]
    result = save_line_plot(x, y, OUT / "line_plot.png")
    payload = {"topic": "matplotlib basic line plot", "plot_result": result}
    (OUT / "plot_report.json").write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
    print(json.dumps(payload, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

今日复盘模板

Day21：Matplotlib 基础图表

figure 和 ax 是什么：
plot 的输入是什么：
为什么要保存图片：
我的环境是否能正常生成 PNG：

Day22 - Matplotlib 多图与保存

> 阶段三：数据分析三大库

学习定位

今天把 Matplotlib 从“一张图”升级到“多图布局”：同一份数据可以同时展示趋势和分布。

认知地图

What

多图不是为了花哨，而是为了同时回答多个问题：

• 趋势是什么？
• 分布是什么？
• 两个变量有没有关系？

Why

单张图容易片面。数据分析里常见组合：

• 折线图看时间趋势。
• 直方图看分布。
• 柱状图看组间对比。
• 散点图看两个变量关系。

How：一份数据，多张图

DataFrame
  ↓
取列
  ↓
subplots
  ↓
plot / hist / scatter
  ↓
savefig

Common Errors

今日强化题（带具体代码）

强化题 1：保存一张双图

验收：生成 dashboard.png 或 fallback 文本。

参考代码：main.py

from pathlib import Path
import json
import pandas as pd

DAY = 22
OUT = Path(__file__).resolve().parent / "outputs" / f"day{DAY:03d}"


def save_dashboard(df, path):
    try:
        import matplotlib
        matplotlib.use("Agg")
        import matplotlib.pyplot as plt
    except Exception as exc:
        fallback = path.with_suffix(".txt")
        fallback.write_text(
            "matplotlib unavailable\\n"
            f"error={type(exc).__name__}: {exc}\\n"
            f"data={df.to_dict(orient='records')}\\n",
            encoding="utf-8",
        )
        return {"ok": False, "fallback": str(fallback), "error": str(exc)}

    fig, axes = plt.subplots(1, 2, figsize=(9, 4))
    axes[0].plot(df["step"], df["value"], marker="o")
    axes[0].set_title("Trend")
    axes[0].set_xlabel("step")
    axes[0].set_ylabel("value")

    axes[1].hist(df["value"], bins=4)
    axes[1].set_title("Distribution")
    axes[1].set_xlabel("value")
    axes[1].set_ylabel("count")

    fig.tight_layout()
    fig.savefig(path, dpi=150)
    plt.close(fig)
    return {"ok": True, "image": str(path)}


def main():
    OUT.mkdir(parents=True, exist_ok=True)
    df = pd.DataFrame({
        "step": [1, 2, 3, 4, 5, 6],
        "value": [10, 13, 9, 16, 14, 18],
    })
    result = save_dashboard(df, OUT / "dashboard.png")
    payload = {
        "topic": "matplotlib multi plot and savefig",
        "rows": len(df),
        "plot_result": result,
    }
    (OUT / "dashboard_report.json").write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
    print(json.dumps(payload, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

今日复盘模板

Day22：Matplotlib 多图与保存

subplots 的输入输出：
hist 看什么：
plot 看什么：
tight_layout 的作用：

Day23 - NumPy / pandas / Matplotlib 综合

> 阶段三：数据分析三大库

学习定位

今天把三大库串起来：NumPy 做数值计算，pandas 做表格组织，Matplotlib 做图表输出。

认知地图

What

一个最小数据分析流程通常是：

原始 records
  ↓ pandas
清洗表格
  ↓ NumPy
计算指标
  ↓ pandas
形成指标表
  ↓ Matplotlib
保存图表

Why

三大库不是互相替代，而是分工：

• NumPy 更接近数学数组。
• pandas 更接近数据表。
• Matplotlib 更接近报告输出。

How：三库综合流水线

records -> DataFrame -> clean -> NumPy metrics -> report -> plot

Common Errors

今日强化题（带具体代码）

强化题 1：跑通三库综合

验收：生成 analysis_report.json、cleaned.csv、图表或 fallback。

参考代码：main.py

from pathlib import Path
import json
import numpy as np
import pandas as pd

DAY = 23
OUT = Path(__file__).resolve().parent / "outputs" / f"day{DAY:03d}"


def clean_data(records):
    df = pd.DataFrame(records)
    df["date"] = pd.to_datetime(df["date"], errors="coerce")
    df["value"] = pd.to_numeric(df["value"], errors="coerce")
    df = df.dropna(subset=["date", "value"]).copy()
    df = df[df["value"] >= 0]
    return df


def compute_metrics(df):
    values = df["value"].to_numpy(dtype=float)
    return {
        "n": int(values.size),
        "mean": round(float(np.mean(values)), 4),
        "std": round(float(np.std(values, ddof=1)), 4) if values.size > 1 else 0.0,
        "max": round(float(np.max(values)), 4),
        "min": round(float(np.min(values)), 4),
    }


def save_plot(df, path):
    try:
        import matplotlib
        matplotlib.use("Agg")
        import matplotlib.pyplot as plt
    except Exception as exc:
        fallback = path.with_suffix(".txt")
        fallback.write_text(f"matplotlib unavailable: {type(exc).__name__}: {exc}\\n", encoding="utf-8")
        return {"ok": False, "fallback": str(fallback), "error": str(exc)}

    fig, ax = plt.subplots(figsize=(7, 4))
    ax.plot(df["date"], df["value"], marker="o")
    ax.set_title("Cleaned Value Trend")
    ax.set_xlabel("date")
    ax.set_ylabel("value")
    fig.autofmt_xdate()
    fig.tight_layout()
    fig.savefig(path, dpi=150)
    plt.close(fig)
    return {"ok": True, "image": str(path)}


def main():
    OUT.mkdir(parents=True, exist_ok=True)
    raw_records = [
        {"date": "2026-01-01", "group": "A", "value": "10"},
        {"date": "2026-01-02", "group": "A", "value": "12"},
        {"date": "bad-date", "group": "B", "value": "11"},
        {"date": "2026-01-04", "group": "B", "value": "-5"},
        {"date": "2026-01-05", "group": "B", "value": "18"},
    ]
    df = clean_data(raw_records)
    metrics = compute_metrics(df)
    group_metrics = df.groupby("group").agg(n=("value", "count"), mean_value=("value", "mean")).reset_index()
    df.to_csv(OUT / "cleaned.csv", index=False)
    plot_result = save_plot(df, OUT / "trend.png")
    report = {
        "topic": "numpy pandas matplotlib integrated workflow",
        "metrics": metrics,
        "group_metrics": group_metrics.round(4).to_dict(orient="records"),
        "plot_result": plot_result,
    }
    (OUT / "analysis_report.json").write_text(json.dumps(report, ensure_ascii=False, indent=2), encoding="utf-8")
    print(json.dumps(report, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

今日复盘模板

Day23：三库综合

NumPy 在流程里负责什么：
pandas 在流程里负责什么：
Matplotlib 在流程里负责什么：
今天的输入、处理、输出分别是什么：

Day24 - 缺失值、类型转换与清洗

> 阶段三：数据分析与本地数据系统

学习定位

把脏表变成可计算表。

今天的目标不是背定义，而是产出：一个 clean DataFrame。

前置知识

• 推荐前置：Day23 pandas 读取
• 上一站：Day23
• 下一站：Day25

今日知识地图

• to_datetime
• to_numeric
• dropna
• 数据质量记录

真实任务入口

今天先不从定义开始，而是先看问题：如何用「缺失值、类型转换与清洗」完成 一个 clean DataFrame？

这个问题在工程里不是孤立练习。它属于 数据分析与本地数据系统 阶段，目标是：把原始数据变成可检查、可保存、可复盘的数据资产。

先按这条顺序学习：

真实任务
  ↓
拆解流程
  ↓
引出问题
  ↓
引出知识点
  ↓
解释设计原因
  ↓
代码实现
  ↓
未来使用

今天你真正要掌握的不是“会背哪个语法”，而是能回答：它解决什么问题、为什么需要它、怎么落到代码、以后在哪个主题会再次出现。

工程问题解决结构

1. 是什么（What）

缺失值、类型转换与清洗 是用 Python 解决工程任务时的一组小工具。最简定义：它帮助你把「to_datetime、to_numeric、dropna」放进可运行流程里。先把它当成解决问题的方法，不要先背术语。

2. 为什么存在（Why）

如果没有 缺失值、类型转换与清洗，代码通常会变成一次性脚本：逻辑散、结果难复查、报错难定位、以后练习里也难复用。它存在的意义是把真实任务拆成更清楚的步骤，让你知道哪里输入、哪里处理、哪里输出。

3. 真实工程场景（Real Scenario）

• 科研场景：读取实验数据，检查字段、缺失值和样本量，生成 Markdown 记录。
• 数据分析场景：清洗业务数据，计算指标，保存 CSV、SQLite 或报告。
• Quant 场景：读取行情样例，计算收益率、移动平均、分组指标或风险统计。
• LLM/Agent 场景：把数据检查步骤封装成 tool，让 Agent 调用后返回结构化结果。

4. 怎么做（How）

先看场景流程，再看代码：

原始数据
  ↓
字段检查
  ↓
清洗/计算
  ↓
边界检查
  ↓
保存结果
  ↓
写分析说明

from pathlib import Path

# Day24 - 缺失值、类型转换与清洗
raw_rows = [{"name": "sample", "value": 1}]

processed = []
for row in raw_rows:
    if "value" not in row:
        continue
    processed.append({"name": row["name"], "value": row["value"]})

Path("outputs").mkdir(exist_ok=True)
Path("outputs/day24_result.txt").write_text(str(processed), encoding="utf-8")
print(processed)

5. 工程设计思维（Design）

工程师会多写一层函数、配置、输出文件或 说明文档，是为了让代码不只今天能跑，也能被明天的自己、未来的自己和未来主题继续使用。

6. Future Usage（未来使用）

这个知识点以后会反复出现在：

• 数据分析报告
• SQLite 本地数据系统
• Quant 指标管道
• Agent 数据检查工具
• 数据处理脚本

7. 掌握检查

学完今天不要只问“代码跑了吗”，要能回答四个问题：

1. 它是什么？

2. 它为什么存在？

3. 它解决什么问题？

4. 它在未来 Quant / LLM / Agent 主题中怎么使用？

基础优化补充：问题、场景与代码

阶段定位：数据分析与本地数据系统。

解决什么问题（Problem）：缺失值、类型转换与清洗 的核心不是背概念，而是把原始数据变成可以检查、清洗、计算、保存和复盘的数据资产。

真实科研场景：整理实验数据、论文元数据和指标结果，让每一步处理都有输入、输出和检查记录。

数据分析场景：读取 CSV/Excel/SQLite 数据，完成字段检查、清洗、聚合、统计和报告输出。

Quant 场景：处理行情、收益率、指标和时间序列，形成后续回测或研究报告的基础数据层。

LLM/Agent 场景：为 LLM/RAG 提供干净、结构化、可引用的数据和本地知识材料。

def build_day024_note(input_name, output_name, risk):
    return {
        "day": "Day24",
        "topic": "缺失值、类型转换与清洗",
        "input": input_name,
        "output": output_name,
        "risk": risk,
        "next_check": "确认输入、处理步骤、输出和失败点是否清楚",
    }

工程工作流补充

如果你完全看不懂，先只抓这一句话

今天学的是：缺失值、类型转换与清洗。它不只是一个孤立知识点，而是服务于「数据分析与本地数据系统」阶段的一个小能力：把原始数据变成可以检查、保存、复盘的数据资产。

先按这条工程线理解：

读取数据 -> 检查字段 -> 清洗/计算 -> 保存结果 -> 写报告

你不需要一开始把所有细节背下来。先回答五个问题：

1. 今天的输入是什么？

2. 中间处理分几步？

3. 输出保存在哪里？

4. 失败时会在哪一步失败？

5. 这个能力以后能放进哪个主题？

真实工作流怎么想

把今天的主题放进一个真实主题里，它通常不是单独出现的。比如做一个 AI/data/quant 小工具时，你会经历：

执行过程追踪

读今天代码时，不要只看语法，要追踪数据怎么走：

输入
  ↓
核心处理
  ↓
中间结果
  ↓
边界检查
  ↓
最终输出

当前最应该检查：字段名、数据类型、空值、重复、样例输出。

最容易混的点

工业化知识百科补充：从会用到会迁移

这一节不是把前面没学完的语法硬塞回来，而是把 缺失值、类型转换与清洗 放进后续 IC 挑战里补厚。你现在已经进入 Day10 之后，学习重点要从“我知道这个语法”升级为“我知道它在工程里解决什么问题、会踩什么坑、怎么迁移到 IC”。

1. 阶段定位

当前阶段：数据分析与本地数据系统。

阶段目标：把原始数据变成结构清楚、指标可信、结果可复查的数据资产。

本阶段反复出现的能力：

• 数据体检
• 类型转换
• 缺失值处理
• 聚合统计
• 时间窗口
• SQL 与本地数据库

2. 这个主题必须补齐的知识面

• DataFrame
• 索引
• 字段类型
• 缺失值
• 聚合
• join
• 滚动窗口
• 向量化

学习时不要把这些点当成孤立词条。更好的读法是：每个概念都对应一种工程压力，例如输入变多、数据变脏、文件变大、结果要复现、输出要交给别人、模型回答需要校验。

3. 真实主题里怎么用

• 数据分析：先明确字段、类型、缺失值、样本范围，再写处理逻辑。不要直接对未知数据写复杂代码。
• Quant：任何计算都要关心时间顺序、样本区间、交易成本、未来函数和结果复现。
• LLM/Agent：所有输入输出都要有结构，模型结果要校验，高风险动作要有人类审查点。

4. 常见坑和边界

• 先体检数据再分析。
• 清洗步骤要能复盘。
• 图表必须说明数据来源、时间范围和口径。
• 不要把所有逻辑堆进一个文件或一个函数。先拆出最小核心函数，再决定是否需要 CLI、API、看板或测试。
• 不要用“能跑一次”代表掌握。真正掌握是换一份输入、换一个场景、换一个主题后仍然能迁移。

5. 最小迁移代码模块边界

def day024_engineering_note(input_data):
    """记录今天知识点在工程主题里的使用边界。"""
    return {
        "day": "Day24",
        "topic": "缺失值、类型转换与清洗",
        "input_shape": "明确输入来源、字段、类型和边界",
        "core_step": "把今天主题压缩成一个可测试的小函数",
        "output_shape": "明确输出给终端、文件、API、报告还是下游函数",
        "failure_modes": ["空输入", "类型不对", "缺字段", "路径或网络失败"],
        "reuse_target": "数据分析 / Quant / LLM-Agent / 能力清单主题",
    }

6. 百科式自查问题

1. 这个主题的输入是什么？输入可能为空、缺字段、类型错误吗？

2. 核心处理步骤能不能写成一个小函数？

3. 输出是给人看，还是给下游程序继续用？

4. 失败时怎么记录？是 print、logging、错误报告，还是测试失败？

5. 如果迁移到 Quant / LLM / Agent 主题，最大的风险是什么？

6. 这个能力是否需要 说明文档、样例数据或测试来长期保存？

7. 建议扩展练习

• 写一个最小正常样例。
• 写一个边界样例，例如空输入、缺字段、类型错误、路径不存在。
• 写一段 Debug 记录，说明错误现象、定位过程和修复方式。
• 把今天的代码改造成一个函数，并说明输入和输出。
• 思考它未来会放进哪个主题模块：data_io、transform、analysis、api、app、agent_tool、backtest 或 report。

2 小时学习节奏

• 15 分钟：读定位、前置和知识地图。
• 25 分钟：手打最小案例并运行。
• 35 分钟：完成 7 道简单路线题。
• 35 分钟：完成 5 道基础巩固题。
• 10 分钟：记录 Debug、结果和下一步。

简单路线 7 题

1. 读完“学习定位”，用一句话写下今天要解决的问题。

2. 手打最小案例并运行，确认得到 一个 clean DataFrame。

3. 把示例输入改成 2-3 条虚拟样例，观察输出是否仍然合理。

4. 故意制造一个小错误，记录报错、原因和修复方式。

5. 给输出加一个清晰字段名或标题，避免只看到裸数字。

6. 把今天代码保存到本地练习文件夹，并写下运行命令。

7. 用 3 行话说明它如何服务于 Quant 指标和报表的输入层。

今日强化题（带具体代码）

> 每天正文上限控制在 600 行以内。强化题不是口头描述，必须能落到 main.py 运行。

强化题 1：复现最小案例

任务：把下面参考代码复制到 main.py，先不要改，直接运行。

验收：终端能打印 JSON，且本地生成 outputs/day024/。

强化题 2：替换输入

任务：只改输入数据，至少新增 2 条样例。

验收：输出数量、均值、跳过记录或检索结果发生合理变化。

强化题 3：边界检查

任务：制造 1 个坏输入，例如空值、重复值、非法字段或极端价格。

验收：程序不会静默失败；你能在输出或 errors.md 里解释原因。

强化题 4：结果保存

任务：把运行结果保存到 JSON、CSV、Markdown 或 SQLite 中的一种。

验收：关闭终端后，仍能从文件复查今天结果。

强化题 5：迁移说明

任务：写 3 句话说明 缺失值、类型转换与清洗 会如何迁移到 Data、Quant、LLM 或 Agent。

验收：不是写“以后有用”，而是写清具体场景。

参考代码：main.py

from pathlib import Path
import json
from statistics import mean

TOPIC = '缺失值、类型转换与清洗'
DAY = 24
ROOT = Path(__file__).resolve().parent
OUT = ROOT / "outputs" / f"day{DAY:03d}"


def ensure_dirs():
    OUT.mkdir(parents=True, exist_ok=True)


def sample_rows():
    return [
        {"user": "u1", "group": "A", "value": 12},
        {"user": "u2", "group": "A", "value": 18},
        {"user": "u3", "group": "B", "value": 9},
        {"user": "u4", "group": "B", "value": None},
    ]


def clean_rows(rows):
    cleaned = []
    skipped = []
    for row in rows:
        if row["value"] is None:
            skipped.append({"row": row, "reason": "missing value"})
            continue
        cleaned.append(row)
    return cleaned, skipped


def summarize(cleaned, skipped):
    values = [row["value"] for row in cleaned]
    return {
        "topic": TOPIC,
        "valid_rows": len(cleaned),
        "skipped_rows": len(skipped),
        "mean_value": round(mean(values), 2) if values else 0,
        "groups": sorted({row["group"] for row in cleaned}),
    }


def main():
    ensure_dirs()
    cleaned, skipped = clean_rows(sample_rows())
    summary = summarize(cleaned, skipped)
    (OUT / "summary.json").write_text(json.dumps(summary, ensure_ascii=False, indent=2), encoding="utf-8")
    (OUT / "skipped.json").write_text(json.dumps(skipped, ensure_ascii=False, indent=2), encoding="utf-8")
    print(json.dumps(summary, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

运行命令

python main.py

Debug 记录要求

错误现象：
触发输入：
定位过程：
修复方式：
以后如何避免：

Debug 记录模板

错误现象：
触发输入：
定位过程：
修复方式：
以后如何避免：

复习检查

• [ ] 我能解释今天能力的输入、处理和输出。
• [ ] 我能从零手打最小案例。
• [ ] 我完成了今日强化题，并运行了 main.py 参考代码。
• [ ] 我把结果保存成可复查产物。

参考资料

• Python 官方文档

Day25 - 分组聚合与业务指标

> 阶段三：数据分析与本地数据系统

学习定位

按类别计算 count、mean、std。

今天的目标不是背定义，而是产出：一张 summary 表。

前置知识

• 推荐前置：Day24 清洗
• 上一站：Day24
• 下一站：Day26

今日知识地图

• groupby
• agg
• reset_index
• 排序

真实任务入口

今天先不从定义开始，而是先看问题：如何用「分组聚合与业务指标」完成 一张 summary 表？

这个问题在工程里不是孤立练习。它属于 数据分析与本地数据系统 阶段，目标是：把原始数据变成可检查、可保存、可复盘的数据资产。

先按这条顺序学习：

真实任务
  ↓
拆解流程
  ↓
引出问题
  ↓
引出知识点
  ↓
解释设计原因
  ↓
代码实现
  ↓
未来使用

今天你真正要掌握的不是“会背哪个语法”，而是能回答：它解决什么问题、为什么需要它、怎么落到代码、以后在哪个主题会再次出现。

工程问题解决结构

1. 是什么（What）

分组聚合与业务指标 是用 Python 解决工程任务时的一组小工具。最简定义：它帮助你把「groupby、agg、reset_index」放进可运行流程里。先把它当成解决问题的方法，不要先背术语。

2. 为什么存在（Why）

如果没有 分组聚合与业务指标，代码通常会变成一次性脚本：逻辑散、结果难复查、报错难定位、以后练习里也难复用。它存在的意义是把真实任务拆成更清楚的步骤，让你知道哪里输入、哪里处理、哪里输出。

3. 真实工程场景（Real Scenario）

• 科研场景：读取实验数据，检查字段、缺失值和样本量，生成 Markdown 记录。
• 数据分析场景：清洗业务数据，计算指标，保存 CSV、SQLite 或报告。
• Quant 场景：读取行情样例，计算收益率、移动平均、分组指标或风险统计。
• LLM/Agent 场景：把数据检查步骤封装成 tool，让 Agent 调用后返回结构化结果。

4. 怎么做（How）

先看场景流程，再看代码：

原始数据
  ↓
字段检查
  ↓
清洗/计算
  ↓
边界检查
  ↓
保存结果
  ↓
写分析说明

from pathlib import Path

# Day25 - 分组聚合与业务指标
raw_rows = [{"name": "sample", "value": 1}]

processed = []
for row in raw_rows:
    if "value" not in row:
        continue
    processed.append({"name": row["name"], "value": row["value"]})

Path("outputs").mkdir(exist_ok=True)
Path("outputs/day25_result.txt").write_text(str(processed), encoding="utf-8")
print(processed)

5. 工程设计思维（Design）

工程师会多写一层函数、配置、输出文件或 说明文档，是为了让代码不只今天能跑，也能被明天的自己、未来的自己和未来主题继续使用。

6. Future Usage（未来使用）

这个知识点以后会反复出现在：

• 数据分析报告
• SQLite 本地数据系统
• Quant 指标管道
• Agent 数据检查工具
• 数据处理脚本

7. 掌握检查

学完今天不要只问“代码跑了吗”，要能回答四个问题：

1. 它是什么？

2. 它为什么存在？

3. 它解决什么问题？

4. 它在未来 Quant / LLM / Agent 主题中怎么使用？

基础优化补充：问题、场景与代码

阶段定位：数据分析与本地数据系统。

解决什么问题（Problem）：分组聚合与业务指标 的核心不是背概念，而是把原始数据变成可以检查、清洗、计算、保存和复盘的数据资产。

真实科研场景：整理实验数据、论文元数据和指标结果，让每一步处理都有输入、输出和检查记录。

数据分析场景：读取 CSV/Excel/SQLite 数据，完成字段检查、清洗、聚合、统计和报告输出。

Quant 场景：处理行情、收益率、指标和时间序列，形成后续回测或研究报告的基础数据层。

LLM/Agent 场景：为 LLM/RAG 提供干净、结构化、可引用的数据和本地知识材料。

def build_day025_note(input_name, output_name, risk):
    return {
        "day": "Day25",
        "topic": "分组聚合与业务指标",
        "input": input_name,
        "output": output_name,
        "risk": risk,
        "next_check": "确认输入、处理步骤、输出和失败点是否清楚",
    }

工程工作流补充

如果你完全看不懂，先只抓这一句话

今天学的是：分组聚合与业务指标。它不只是一个孤立知识点，而是服务于「数据分析与本地数据系统」阶段的一个小能力：把原始数据变成可以检查、保存、复盘的数据资产。

先按这条工程线理解：

读取数据 -> 检查字段 -> 清洗/计算 -> 保存结果 -> 写报告

你不需要一开始把所有细节背下来。先回答五个问题：

1. 今天的输入是什么？

2. 中间处理分几步？

3. 输出保存在哪里？

4. 失败时会在哪一步失败？

5. 这个能力以后能放进哪个主题？

真实工作流怎么想

把今天的主题放进一个真实主题里，它通常不是单独出现的。比如做一个 AI/data/quant 小工具时，你会经历：

执行过程追踪

读今天代码时，不要只看语法，要追踪数据怎么走：

输入
  ↓
核心处理
  ↓
中间结果
  ↓
边界检查
  ↓
最终输出

当前最应该检查：字段名、数据类型、空值、重复、样例输出。

最容易混的点

工业化知识百科补充：从会用到会迁移

这一节不是把前面没学完的语法硬塞回来，而是把 分组聚合与业务指标 放进后续 IC 挑战里补厚。你现在已经进入 Day10 之后，学习重点要从“我知道这个语法”升级为“我知道它在工程里解决什么问题、会踩什么坑、怎么迁移到 IC”。

1. 阶段定位

当前阶段：数据分析与本地数据系统。

阶段目标：把原始数据变成结构清楚、指标可信、结果可复查的数据资产。

本阶段反复出现的能力：

• 数据体检
• 类型转换
• 缺失值处理
• 聚合统计
• 时间窗口
• SQL 与本地数据库

2. 这个主题必须补齐的知识面

• DataFrame
• 索引
• 字段类型
• 缺失值
• 聚合
• join
• 滚动窗口
• 向量化

学习时不要把这些点当成孤立词条。更好的读法是：每个概念都对应一种工程压力，例如输入变多、数据变脏、文件变大、结果要复现、输出要交给别人、模型回答需要校验。

3. 真实主题里怎么用

• 数据分析：先明确字段、类型、缺失值、样本范围，再写处理逻辑。不要直接对未知数据写复杂代码。
• Quant：任何计算都要关心时间顺序、样本区间、交易成本、未来函数和结果复现。
• LLM/Agent：所有输入输出都要有结构，模型结果要校验，高风险动作要有人类审查点。

4. 常见坑和边界

• 先体检数据再分析。
• 清洗步骤要能复盘。
• 图表必须说明数据来源、时间范围和口径。
• 不要把所有逻辑堆进一个文件或一个函数。先拆出最小核心函数，再决定是否需要 CLI、API、看板或测试。
• 不要用“能跑一次”代表掌握。真正掌握是换一份输入、换一个场景、换一个主题后仍然能迁移。

5. 最小迁移代码模块边界

def day025_engineering_note(input_data):
    """记录今天知识点在工程主题里的使用边界。"""
    return {
        "day": "Day25",
        "topic": "分组聚合与业务指标",
        "input_shape": "明确输入来源、字段、类型和边界",
        "core_step": "把今天主题压缩成一个可测试的小函数",
        "output_shape": "明确输出给终端、文件、API、报告还是下游函数",
        "failure_modes": ["空输入", "类型不对", "缺字段", "路径或网络失败"],
        "reuse_target": "数据分析 / Quant / LLM-Agent / 能力清单主题",
    }

6. 百科式自查问题

1. 这个主题的输入是什么？输入可能为空、缺字段、类型错误吗？

2. 核心处理步骤能不能写成一个小函数？

3. 输出是给人看，还是给下游程序继续用？

4. 失败时怎么记录？是 print、logging、错误报告，还是测试失败？

5. 如果迁移到 Quant / LLM / Agent 主题，最大的风险是什么？

6. 这个能力是否需要 说明文档、样例数据或测试来长期保存？

7. 建议扩展练习

• 写一个最小正常样例。
• 写一个边界样例，例如空输入、缺字段、类型错误、路径不存在。
• 写一段 Debug 记录，说明错误现象、定位过程和修复方式。
• 把今天的代码改造成一个函数，并说明输入和输出。
• 思考它未来会放进哪个主题模块：data_io、transform、analysis、api、app、agent_tool、backtest 或 report。

2 小时学习节奏

• 15 分钟：读定位、前置和知识地图。
• 25 分钟：手打最小案例并运行。
• 35 分钟：完成 7 道简单路线题。
• 35 分钟：完成 5 道基础巩固题。
• 10 分钟：记录 Debug、结果和下一步。

简单路线 7 题

1. 读完“学习定位”，用一句话写下今天要解决的问题。

2. 手打最小案例并运行，确认得到 一张 summary 表。

3. 把示例输入改成 2-3 条虚拟样例，观察输出是否仍然合理。

4. 故意制造一个小错误，记录报错、原因和修复方式。

5. 给输出加一个清晰字段名或标题，避免只看到裸数字。

6. 把今天代码保存到本地练习文件夹，并写下运行命令。

7. 用 3 行话说明它如何服务于 数据分析报表和 Quant 横截面统计。

今日强化题（带具体代码）

> 每天正文上限控制在 600 行以内。强化题不是口头描述，必须能落到 main.py 运行。

强化题 1：复现最小案例

任务：把下面参考代码复制到 main.py，先不要改，直接运行。

验收：终端能打印 JSON，且本地生成 outputs/day025/。

强化题 2：替换输入

任务：只改输入数据，至少新增 2 条样例。

验收：输出数量、均值、跳过记录或检索结果发生合理变化。

强化题 3：边界检查

任务：制造 1 个坏输入，例如空值、重复值、非法字段或极端价格。

验收：程序不会静默失败；你能在输出或 errors.md 里解释原因。

强化题 4：结果保存

任务：把运行结果保存到 JSON、CSV、Markdown 或 SQLite 中的一种。

验收：关闭终端后，仍能从文件复查今天结果。

强化题 5：迁移说明

任务：写 3 句话说明 分组聚合与业务指标 会如何迁移到 Data、Quant、LLM 或 Agent。

验收：不是写“以后有用”，而是写清具体场景。

参考代码：main.py

from pathlib import Path
import json
from statistics import mean

TOPIC = '分组聚合与业务指标'
DAY = 25
ROOT = Path(__file__).resolve().parent
OUT = ROOT / "outputs" / f"day{DAY:03d}"


def ensure_dirs():
    OUT.mkdir(parents=True, exist_ok=True)


def sample_rows():
    return [
        {"user": "u1", "group": "A", "value": 12},
        {"user": "u2", "group": "A", "value": 18},
        {"user": "u3", "group": "B", "value": 9},
        {"user": "u4", "group": "B", "value": None},
    ]


def clean_rows(rows):
    cleaned = []
    skipped = []
    for row in rows:
        if row["value"] is None:
            skipped.append({"row": row, "reason": "missing value"})
            continue
        cleaned.append(row)
    return cleaned, skipped


def summarize(cleaned, skipped):
    values = [row["value"] for row in cleaned]
    return {
        "topic": TOPIC,
        "valid_rows": len(cleaned),
        "skipped_rows": len(skipped),
        "mean_value": round(mean(values), 2) if values else 0,
        "groups": sorted({row["group"] for row in cleaned}),
    }


def main():
    ensure_dirs()
    cleaned, skipped = clean_rows(sample_rows())
    summary = summarize(cleaned, skipped)
    (OUT / "summary.json").write_text(json.dumps(summary, ensure_ascii=False, indent=2), encoding="utf-8")
    (OUT / "skipped.json").write_text(json.dumps(skipped, ensure_ascii=False, indent=2), encoding="utf-8")
    print(json.dumps(summary, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

运行命令

python main.py

Debug 记录要求

错误现象：
触发输入：
定位过程：
修复方式：
以后如何避免：

Debug 记录模板

错误现象：
触发输入：
定位过程：
修复方式：
以后如何避免：

复习检查

• [ ] 我能解释今天能力的输入、处理和输出。
• [ ] 我能从零手打最小案例。
• [ ] 我完成了今日强化题，并运行了 main.py 参考代码。
• [ ] 我把结果保存成可复查产物。

参考资料

• Python 官方文档

Day26 - 表连接、映射与维表

> 阶段三：数据分析与本地数据系统

学习定位

把事实表和维度表连接起来。

今天的目标不是背定义，而是产出：一张带行业/标签的分析表。

前置知识

• 推荐前置：Day25 聚合
• 上一站：Day25
• 下一站：Day27

今日知识地图

• merge
• left join
• 维表
• 字段一致性

真实任务入口

今天先不从定义开始，而是先看问题：如何用「表连接、映射与维表」完成 一张带行业/标签的分析表？

这个问题在工程里不是孤立练习。它属于 数据分析与本地数据系统 阶段，目标是：把原始数据变成可检查、可保存、可复盘的数据资产。

先按这条顺序学习：

真实任务
  ↓
拆解流程
  ↓
引出问题
  ↓
引出知识点
  ↓
解释设计原因
  ↓
代码实现
  ↓
未来使用

今天你真正要掌握的不是“会背哪个语法”，而是能回答：它解决什么问题、为什么需要它、怎么落到代码、以后在哪个主题会再次出现。

工程问题解决结构

1. 是什么（What）

表连接、映射与维表 是用 Python 解决工程任务时的一组小工具。最简定义：它帮助你把「merge、left join、维表」放进可运行流程里。先把它当成解决问题的方法，不要先背术语。

2. 为什么存在（Why）

如果没有 表连接、映射与维表，代码通常会变成一次性脚本：逻辑散、结果难复查、报错难定位、以后练习里也难复用。它存在的意义是把真实任务拆成更清楚的步骤，让你知道哪里输入、哪里处理、哪里输出。

3. 真实工程场景（Real Scenario）

• 科研场景：读取实验数据，检查字段、缺失值和样本量，生成 Markdown 记录。
• 数据分析场景：清洗业务数据，计算指标，保存 CSV、SQLite 或报告。
• Quant 场景：读取行情样例，计算收益率、移动平均、分组指标或风险统计。
• LLM/Agent 场景：把数据检查步骤封装成 tool，让 Agent 调用后返回结构化结果。

4. 怎么做（How）

先看场景流程，再看代码：

原始数据
  ↓
字段检查
  ↓
清洗/计算
  ↓
边界检查
  ↓
保存结果
  ↓
写分析说明

from pathlib import Path

# Day26 - 表连接、映射与维表
raw_rows = [{"name": "sample", "value": 1}]

processed = []
for row in raw_rows:
    if "value" not in row:
        continue
    processed.append({"name": row["name"], "value": row["value"]})

Path("outputs").mkdir(exist_ok=True)
Path("outputs/day26_result.txt").write_text(str(processed), encoding="utf-8")
print(processed)

5. 工程设计思维（Design）

工程师会多写一层函数、配置、输出文件或 说明文档，是为了让代码不只今天能跑，也能被明天的自己、未来的自己和未来主题继续使用。

6. Future Usage（未来使用）

这个知识点以后会反复出现在：

• 数据分析报告
• SQLite 本地数据系统
• Quant 指标管道
• Agent 数据检查工具
• 数据处理脚本

7. 掌握检查

学完今天不要只问“代码跑了吗”，要能回答四个问题：

1. 它是什么？

2. 它为什么存在？

3. 它解决什么问题？

4. 它在未来 Quant / LLM / Agent 主题中怎么使用？

基础优化补充：问题、场景与代码

阶段定位：数据分析与本地数据系统。

解决什么问题（Problem）：表连接、映射与维表 的核心不是背概念，而是把原始数据变成可以检查、清洗、计算、保存和复盘的数据资产。

真实科研场景：整理实验数据、论文元数据和指标结果，让每一步处理都有输入、输出和检查记录。

数据分析场景：读取 CSV/Excel/SQLite 数据，完成字段检查、清洗、聚合、统计和报告输出。

Quant 场景：处理行情、收益率、指标和时间序列，形成后续回测或研究报告的基础数据层。

LLM/Agent 场景：为 LLM/RAG 提供干净、结构化、可引用的数据和本地知识材料。

def build_day026_note(input_name, output_name, risk):
    return {
        "day": "Day26",
        "topic": "表连接、映射与维表",
        "input": input_name,
        "output": output_name,
        "risk": risk,
        "next_check": "确认输入、处理步骤、输出和失败点是否清楚",
    }

工程工作流补充

如果你完全看不懂，先只抓这一句话

今天学的是：表连接、映射与维表。它不只是一个孤立知识点，而是服务于「数据分析与本地数据系统」阶段的一个小能力：把原始数据变成可以检查、保存、复盘的数据资产。

先按这条工程线理解：

读取数据 -> 检查字段 -> 清洗/计算 -> 保存结果 -> 写报告

你不需要一开始把所有细节背下来。先回答五个问题：

1. 今天的输入是什么？

2. 中间处理分几步？

3. 输出保存在哪里？

4. 失败时会在哪一步失败？

5. 这个能力以后能放进哪个主题？

真实工作流怎么想

把今天的主题放进一个真实主题里，它通常不是单独出现的。比如做一个 AI/data/quant 小工具时，你会经历：

执行过程追踪

读今天代码时，不要只看语法，要追踪数据怎么走：

输入
  ↓
核心处理
  ↓
中间结果
  ↓
边界检查
  ↓
最终输出

当前最应该检查：字段名、数据类型、空值、重复、样例输出。

最容易混的点

工业化知识百科补充：从会用到会迁移

这一节不是把前面没学完的语法硬塞回来，而是把 表连接、映射与维表 放进后续 IC 挑战里补厚。你现在已经进入 Day10 之后，学习重点要从“我知道这个语法”升级为“我知道它在工程里解决什么问题、会踩什么坑、怎么迁移到 IC”。

1. 阶段定位

当前阶段：数据分析与本地数据系统。

阶段目标：把原始数据变成结构清楚、指标可信、结果可复查的数据资产。

本阶段反复出现的能力：

• 数据体检
• 类型转换
• 缺失值处理
• 聚合统计
• 时间窗口
• SQL 与本地数据库

2. 这个主题必须补齐的知识面

• DataFrame
• 索引
• 字段类型
• 缺失值
• 聚合
• join
• 滚动窗口
• 向量化

学习时不要把这些点当成孤立词条。更好的读法是：每个概念都对应一种工程压力，例如输入变多、数据变脏、文件变大、结果要复现、输出要交给别人、模型回答需要校验。

3. 真实主题里怎么用

• 数据分析：先明确字段、类型、缺失值、样本范围，再写处理逻辑。不要直接对未知数据写复杂代码。
• Quant：任何计算都要关心时间顺序、样本区间、交易成本、未来函数和结果复现。
• LLM/Agent：所有输入输出都要有结构，模型结果要校验，高风险动作要有人类审查点。

4. 常见坑和边界

• 先体检数据再分析。
• 清洗步骤要能复盘。
• 图表必须说明数据来源、时间范围和口径。
• 不要把所有逻辑堆进一个文件或一个函数。先拆出最小核心函数，再决定是否需要 CLI、API、看板或测试。
• 不要用“能跑一次”代表掌握。真正掌握是换一份输入、换一个场景、换一个主题后仍然能迁移。

5. 最小迁移代码模块边界

def day026_engineering_note(input_data):
    """记录今天知识点在工程主题里的使用边界。"""
    return {
        "day": "Day26",
        "topic": "表连接、映射与维表",
        "input_shape": "明确输入来源、字段、类型和边界",
        "core_step": "把今天主题压缩成一个可测试的小函数",
        "output_shape": "明确输出给终端、文件、API、报告还是下游函数",
        "failure_modes": ["空输入", "类型不对", "缺字段", "路径或网络失败"],
        "reuse_target": "数据分析 / Quant / LLM-Agent / 能力清单主题",
    }

6. 百科式自查问题

1. 这个主题的输入是什么？输入可能为空、缺字段、类型错误吗？

2. 核心处理步骤能不能写成一个小函数？

3. 输出是给人看，还是给下游程序继续用？

4. 失败时怎么记录？是 print、logging、错误报告，还是测试失败？

5. 如果迁移到 Quant / LLM / Agent 主题，最大的风险是什么？

6. 这个能力是否需要 说明文档、样例数据或测试来长期保存？

7. 建议扩展练习

• 写一个最小正常样例。
• 写一个边界样例，例如空输入、缺字段、类型错误、路径不存在。
• 写一段 Debug 记录，说明错误现象、定位过程和修复方式。
• 把今天的代码改造成一个函数，并说明输入和输出。
• 思考它未来会放进哪个主题模块：data_io、transform、analysis、api、app、agent_tool、backtest 或 report。

2 小时学习节奏

• 15 分钟：读定位、前置和知识地图。
• 25 分钟：手打最小案例并运行。
• 35 分钟：完成 7 道简单路线题。
• 35 分钟：完成 5 道基础巩固题。
• 10 分钟：记录 Debug、结果和下一步。

简单路线 7 题

1. 读完“学习定位”，用一句话写下今天要解决的问题。

2. 手打最小案例并运行，确认得到 一张带行业/标签的分析表。

3. 把示例输入改成 2-3 条虚拟样例，观察输出是否仍然合理。

4. 故意制造一个小错误，记录报错、原因和修复方式。

5. 给输出加一个清晰字段名或标题，避免只看到裸数字。

6. 把今天代码保存到本地练习文件夹，并写下运行命令。

7. 用 3 行话说明它如何服务于 金融行业分类、用户画像和业务维度。

今日强化题（带具体代码）

> 每天正文上限控制在 600 行以内。强化题不是口头描述，必须能落到 main.py 运行。

强化题 1：复现最小案例

任务：把下面参考代码复制到 main.py，先不要改，直接运行。

验收：终端能打印 JSON，且本地生成 outputs/day026/。

强化题 2：替换输入

任务：只改输入数据，至少新增 2 条样例。

验收：输出数量、均值、跳过记录或检索结果发生合理变化。

强化题 3：边界检查

任务：制造 1 个坏输入，例如空值、重复值、非法字段或极端价格。

验收：程序不会静默失败；你能在输出或 errors.md 里解释原因。

强化题 4：结果保存

任务：把运行结果保存到 JSON、CSV、Markdown 或 SQLite 中的一种。

验收：关闭终端后，仍能从文件复查今天结果。

强化题 5：迁移说明

任务：写 3 句话说明 表连接、映射与维表 会如何迁移到 Data、Quant、LLM 或 Agent。

验收：不是写“以后有用”，而是写清具体场景。

参考代码：main.py

from pathlib import Path
import json

DAY = 26
TOPIC = "表连接、映射与维表"
ROOT = Path(__file__).resolve().parent
OUT = ROOT / "outputs" / f"day{DAY:03d}"


def write_json(name, payload):
    OUT.mkdir(parents=True, exist_ok=True)
    path = OUT / name
    path.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
    return path


def join_orders_with_users(orders, users):
    user_map = {user["user_id"]: user for user in users}
    joined = []
    unmatched = []
    for order in orders:
        user = user_map.get(order["user_id"])
        if user is None:
            unmatched.append(order)
            continue
        joined.append({**order, "city": user["city"], "segment": user["segment"]})
    return joined, unmatched


def main():
    orders = [{"order_id": "o1", "user_id": "u1", "amount": 120}, {"order_id": "o2", "user_id": "u3", "amount": 80}]
    users = [{"user_id": "u1", "city": "Beijing", "segment": "new"}, {"user_id": "u2", "city": "Shanghai", "segment": "vip"}]
    joined, unmatched = join_orders_with_users(orders, users)
    report = {"topic": TOPIC, "joined": joined, "unmatched": unmatched}
    path = write_json("join_dimension_report.json", report)
    print(json.dumps({"saved_to": str(path), **report}, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

运行命令

python main.py

Debug 记录要求

错误现象：
触发输入：
定位过程：
修复方式：
以后如何避免：

Debug 记录模板

错误现象：
触发输入：
定位过程：
修复方式：
以后如何避免：

复习检查

• [ ] 我能解释今天能力的输入、处理和输出。
• [ ] 我能从零手打最小案例。
• [ ] 我完成了今日强化题，并运行了 main.py 参考代码。
• [ ] 我把结果保存成可复查产物。

参考资料

• Python 官方文档

Day27 - 时间序列、滚动窗口与移动平均

> 阶段三：数据分析与本地数据系统

学习定位

处理按时间排序的数据和 rolling 指标。

今天的目标不是背定义，而是产出：一张带移动平均的时间序列表。

前置知识

• 推荐前置：Day26 表连接
• 上一站：Day26
• 下一站：Day28

今日知识地图

• rolling
• 时间排序
• 移动平均
• 窗口边界

真实任务入口

今天先不从定义开始，而是先看问题：如何用「时间序列、滚动窗口与移动平均」完成 一张带移动平均的时间序列表？

这个问题在工程里不是孤立练习。它属于 数据分析与本地数据系统 阶段，目标是：把原始数据变成可检查、可保存、可复盘的数据资产。

先按这条顺序学习：

真实任务
  ↓
拆解流程
  ↓
引出问题
  ↓
引出知识点
  ↓
解释设计原因
  ↓
代码实现
  ↓
未来使用

今天你真正要掌握的不是“会背哪个语法”，而是能回答：它解决什么问题、为什么需要它、怎么落到代码、以后在哪个主题会再次出现。

工程问题解决结构

1. 是什么（What）

时间序列、滚动窗口与移动平均 是用 Python 解决工程任务时的一组小工具。最简定义：它帮助你把「rolling、时间排序、移动平均」放进可运行流程里。先把它当成解决问题的方法，不要先背术语。

2. 为什么存在（Why）

如果没有 时间序列、滚动窗口与移动平均，代码通常会变成一次性脚本：逻辑散、结果难复查、报错难定位、以后练习里也难复用。它存在的意义是把真实任务拆成更清楚的步骤，让你知道哪里输入、哪里处理、哪里输出。

3. 真实工程场景（Real Scenario）

• 科研场景：读取实验数据，检查字段、缺失值和样本量，生成 Markdown 记录。
• 数据分析场景：清洗业务数据，计算指标，保存 CSV、SQLite 或报告。
• Quant 场景：读取行情样例，计算收益率、移动平均、分组指标或风险统计。
• LLM/Agent 场景：把数据检查步骤封装成 tool，让 Agent 调用后返回结构化结果。

4. 怎么做（How）

先看场景流程，再看代码：

原始数据
  ↓
字段检查
  ↓
清洗/计算
  ↓
边界检查
  ↓
保存结果
  ↓
写分析说明

from pathlib import Path

# Day27 - 时间序列、滚动窗口与移动平均
raw_rows = [{"name": "sample", "value": 1}]

processed = []
for row in raw_rows:
    if "value" not in row:
        continue
    processed.append({"name": row["name"], "value": row["value"]})

Path("outputs").mkdir(exist_ok=True)
Path("outputs/day27_result.txt").write_text(str(processed), encoding="utf-8")
print(processed)

5. 工程设计思维（Design）

工程师会多写一层函数、配置、输出文件或 说明文档，是为了让代码不只今天能跑，也能被明天的自己、未来的自己和未来主题继续使用。

6. Future Usage（未来使用）

这个知识点以后会反复出现在：

• 数据分析报告
• SQLite 本地数据系统
• Quant 指标管道
• Agent 数据检查工具
• 数据处理脚本

7. 掌握检查

学完今天不要只问“代码跑了吗”，要能回答四个问题：

1. 它是什么？

2. 它为什么存在？

3. 它解决什么问题？

4. 它在未来 Quant / LLM / Agent 主题中怎么使用？

基础优化补充：问题、场景与代码

阶段定位：数据分析与本地数据系统。

解决什么问题（Problem）：时间序列、滚动窗口与移动平均 的核心不是背概念，而是把原始数据变成可以检查、清洗、计算、保存和复盘的数据资产。

真实科研场景：整理实验数据、论文元数据和指标结果，让每一步处理都有输入、输出和检查记录。

数据分析场景：读取 CSV/Excel/SQLite 数据，完成字段检查、清洗、聚合、统计和报告输出。

Quant 场景：处理行情、收益率、指标和时间序列，形成后续回测或研究报告的基础数据层。

LLM/Agent 场景：为 LLM/RAG 提供干净、结构化、可引用的数据和本地知识材料。

def build_day027_note(input_name, output_name, risk):
    return {
        "day": "Day27",
        "topic": "时间序列、滚动窗口与移动平均",
        "input": input_name,
        "output": output_name,
        "risk": risk,
        "next_check": "确认输入、处理步骤、输出和失败点是否清楚",
    }

工程工作流补充

如果你完全看不懂，先只抓这一句话

今天学的是：时间序列、滚动窗口与移动平均。它不只是一个孤立知识点，而是服务于「数据分析与本地数据系统」阶段的一个小能力：把原始数据变成可以检查、保存、复盘的数据资产。

先按这条工程线理解：

读取数据 -> 检查字段 -> 清洗/计算 -> 保存结果 -> 写报告

你不需要一开始把所有细节背下来。先回答五个问题：

1. 今天的输入是什么？

2. 中间处理分几步？

3. 输出保存在哪里？

4. 失败时会在哪一步失败？

5. 这个能力以后能放进哪个主题？

真实工作流怎么想

把今天的主题放进一个真实主题里，它通常不是单独出现的。比如做一个 AI/data/quant 小工具时，你会经历：

执行过程追踪

读今天代码时，不要只看语法，要追踪数据怎么走：

输入
  ↓
核心处理
  ↓
中间结果
  ↓
边界检查
  ↓
最终输出

当前最应该检查：字段名、数据类型、空值、重复、样例输出。

最容易混的点

工业化知识百科补充：从会用到会迁移

这一节不是把前面没学完的语法硬塞回来，而是把 时间序列、滚动窗口与移动平均 放进后续 IC 挑战里补厚。你现在已经进入 Day10 之后，学习重点要从“我知道这个语法”升级为“我知道它在工程里解决什么问题、会踩什么坑、怎么迁移到 IC”。

1. 阶段定位

当前阶段：数据分析与本地数据系统。

阶段目标：把原始数据变成结构清楚、指标可信、结果可复查的数据资产。

本阶段反复出现的能力：

• 数据体检
• 类型转换
• 缺失值处理
• 聚合统计
• 时间窗口
• SQL 与本地数据库

2. 这个主题必须补齐的知识面

• 日期解析
• 格式化
• 排序
• 时区
• 窗口
• 样本边界
• 未来数据泄漏

学习时不要把这些点当成孤立词条。更好的读法是：每个概念都对应一种工程压力，例如输入变多、数据变脏、文件变大、结果要复现、输出要交给别人、模型回答需要校验。

3. 真实主题里怎么用

• 数据分析：先明确字段、类型、缺失值、样本范围，再写处理逻辑。不要直接对未知数据写复杂代码。
• Quant：任何计算都要关心时间顺序、样本区间、交易成本、未来函数和结果复现。
• LLM/Agent：所有输入输出都要有结构，模型结果要校验，高风险动作要有人类审查点。

4. 常见坑和边界

• 日期字符串先解析再排序。
• 时间序列处理要明确样本区间。
• Quant 回测里不能用未来数据计算今天信号。
• 不要把所有逻辑堆进一个文件或一个函数。先拆出最小核心函数，再决定是否需要 CLI、API、看板或测试。
• 不要用“能跑一次”代表掌握。真正掌握是换一份输入、换一个场景、换一个主题后仍然能迁移。

5. 最小迁移代码模块边界

def day027_engineering_note(input_data):
    """记录今天知识点在工程主题里的使用边界。"""
    return {
        "day": "Day27",
        "topic": "时间序列、滚动窗口与移动平均",
        "input_shape": "明确输入来源、字段、类型和边界",
        "core_step": "把今天主题压缩成一个可测试的小函数",
        "output_shape": "明确输出给终端、文件、API、报告还是下游函数",
        "failure_modes": ["空输入", "类型不对", "缺字段", "路径或网络失败"],
        "reuse_target": "数据分析 / Quant / LLM-Agent / 能力清单主题",
    }

6. 百科式自查问题

1. 这个主题的输入是什么？输入可能为空、缺字段、类型错误吗？

2. 核心处理步骤能不能写成一个小函数？

3. 输出是给人看，还是给下游程序继续用？

4. 失败时怎么记录？是 print、logging、错误报告，还是测试失败？

5. 如果迁移到 Quant / LLM / Agent 主题，最大的风险是什么？

6. 这个能力是否需要 说明文档、样例数据或测试来长期保存？

7. 建议扩展练习

• 写一个最小正常样例。
• 写一个边界样例，例如空输入、缺字段、类型错误、路径不存在。
• 写一段 Debug 记录，说明错误现象、定位过程和修复方式。
• 把今天的代码改造成一个函数，并说明输入和输出。
• 思考它未来会放进哪个主题模块：data_io、transform、analysis、api、app、agent_tool、backtest 或 report。

2 小时学习节奏

• 15 分钟：读定位、前置和知识地图。
• 25 分钟：手打最小案例并运行。
• 35 分钟：完成 7 道简单路线题。
• 35 分钟：完成 5 道基础巩固题。
• 10 分钟：记录 Debug、结果和下一步。

简单路线 7 题

1. 读完“学习定位”，用一句话写下今天要解决的问题。

2. 手打最小案例并运行，确认得到 一张带移动平均的时间序列表。

3. 把示例输入改成 2-3 条虚拟样例，观察输出是否仍然合理。

4. 故意制造一个小错误，记录报错、原因和修复方式。

5. 给输出加一个清晰字段名或标题，避免只看到裸数字。

6. 把今天代码保存到本地练习文件夹，并写下运行命令。

7. 用 3 行话说明它如何服务于 行情分析和监控趋势。

今日强化题（带具体代码）

> 每天正文上限控制在 600 行以内。强化题不是口头描述，必须能落到 main.py 运行。

强化题 1：复现最小案例

任务：把下面参考代码复制到 main.py，先不要改，直接运行。

验收：终端能打印 JSON，且本地生成 outputs/day027/。

强化题 2：替换输入

任务：只改输入数据，至少新增 2 条样例。

验收：输出数量、均值、跳过记录或检索结果发生合理变化。

强化题 3：边界检查

任务：制造 1 个坏输入，例如空值、重复值、非法字段或极端价格。

验收：程序不会静默失败；你能在输出或 errors.md 里解释原因。

强化题 4：结果保存

任务：把运行结果保存到 JSON、CSV、Markdown 或 SQLite 中的一种。

验收：关闭终端后，仍能从文件复查今天结果。

强化题 5：迁移说明

任务：写 3 句话说明 时间序列、滚动窗口与移动平均 会如何迁移到 Data、Quant、LLM 或 Agent。

验收：不是写“以后有用”，而是写清具体场景。

参考代码：main.py

from pathlib import Path
import json

DAY = 27
TOPIC = "时间序列、滚动窗口与移动平均"
ROOT = Path(__file__).resolve().parent
OUT = ROOT / "outputs" / f"day{DAY:03d}"


def write_json(name, payload):
    OUT.mkdir(parents=True, exist_ok=True)
    path = OUT / name
    path.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
    return path


def moving_average(values, window):
    if window <= 0:
        raise ValueError("window must be positive")
    result = []
    for end in range(window, len(values) + 1):
        chunk = values[end - window:end]
        result.append(round(sum(chunk) / window, 2))
    return result


def main():
    prices = [100, 102, 101, 105, 108, 107]
    report = {"topic": TOPIC, "prices": prices, "ma3": moving_average(prices, 3)}
    path = write_json("rolling_window_report.json", report)
    print(json.dumps({"saved_to": str(path), **report}, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

运行命令

python main.py

Debug 记录要求

错误现象：
触发输入：
定位过程：
修复方式：
以后如何避免：

Debug 记录模板

错误现象：
触发输入：
定位过程：
修复方式：
以后如何避免：

复习检查

• [ ] 我能解释今天能力的输入、处理和输出。
• [ ] 我能从零手打最小案例。
• [ ] 我完成了今日强化题，并运行了 main.py 参考代码。
• [ ] 我把结果保存成可复查产物。

参考资料

• Python 官方文档

Day28 - NumPy 数组与向量化计算

> 阶段三：数据分析与本地数据系统

学习定位

用数组方式计算收益率和统计量。

今天的目标不是背定义，而是产出：一个向量化收益率计算。

前置知识

• 推荐前置：Day27 时间序列
• 上一站：Day27
• 下一站：Day29

今日知识地图

• np.array
• 切片
• 向量化
• mean/std

真实任务入口

今天先不从定义开始，而是先看问题：如何用「NumPy 数组与向量化计算」完成 一个向量化收益率计算？

这个问题在工程里不是孤立练习。它属于 数据分析与本地数据系统 阶段，目标是：把原始数据变成可检查、可保存、可复盘的数据资产。

先按这条顺序学习：

真实任务
  ↓
拆解流程
  ↓
引出问题
  ↓
引出知识点
  ↓
解释设计原因
  ↓
代码实现
  ↓
未来使用

今天你真正要掌握的不是“会背哪个语法”，而是能回答：它解决什么问题、为什么需要它、怎么落到代码、以后在哪个主题会再次出现。

工程问题解决结构

1. 是什么（What）

NumPy 数组与向量化计算 是用 Python 解决工程任务时的一组小工具。最简定义：它帮助你把「np.array、切片、向量化」放进可运行流程里。先把它当成解决问题的方法，不要先背术语。

2. 为什么存在（Why）

如果没有 NumPy 数组与向量化计算，代码通常会变成一次性脚本：逻辑散、结果难复查、报错难定位、以后练习里也难复用。它存在的意义是把真实任务拆成更清楚的步骤，让你知道哪里输入、哪里处理、哪里输出。

3. 真实工程场景（Real Scenario）

• 科研场景：读取实验数据，检查字段、缺失值和样本量，生成 Markdown 记录。
• 数据分析场景：清洗业务数据，计算指标，保存 CSV、SQLite 或报告。
• Quant 场景：读取行情样例，计算收益率、移动平均、分组指标或风险统计。
• LLM/Agent 场景：把数据检查步骤封装成 tool，让 Agent 调用后返回结构化结果。

4. 怎么做（How）

先看场景流程，再看代码：

原始数据
  ↓
字段检查
  ↓
清洗/计算
  ↓
边界检查
  ↓
保存结果
  ↓
写分析说明

from pathlib import Path

# Day28 - NumPy 数组与向量化计算
raw_rows = [{"name": "sample", "value": 1}]

processed = []
for row in raw_rows:
    if "value" not in row:
        continue
    processed.append({"name": row["name"], "value": row["value"]})

Path("outputs").mkdir(exist_ok=True)
Path("outputs/day28_result.txt").write_text(str(processed), encoding="utf-8")
print(processed)

5. 工程设计思维（Design）

工程师会多写一层函数、配置、输出文件或 说明文档，是为了让代码不只今天能跑，也能被明天的自己、未来的自己和未来主题继续使用。

6. Future Usage（未来使用）

这个知识点以后会反复出现在：

• 数据分析报告
• SQLite 本地数据系统
• Quant 指标管道
• Agent 数据检查工具
• 数据处理脚本

7. 掌握检查

学完今天不要只问“代码跑了吗”，要能回答四个问题：

1. 它是什么？

2. 它为什么存在？

3. 它解决什么问题？

4. 它在未来 Quant / LLM / Agent 主题中怎么使用？

基础优化补充：问题、场景与代码

阶段定位：数据分析与本地数据系统。

解决什么问题（Problem）：NumPy 数组与向量化计算 的核心不是背概念，而是把原始数据变成可以检查、清洗、计算、保存和复盘的数据资产。

真实科研场景：整理实验数据、论文元数据和指标结果，让每一步处理都有输入、输出和检查记录。

数据分析场景：读取 CSV/Excel/SQLite 数据，完成字段检查、清洗、聚合、统计和报告输出。

Quant 场景：处理行情、收益率、指标和时间序列，形成后续回测或研究报告的基础数据层。

LLM/Agent 场景：为 LLM/RAG 提供干净、结构化、可引用的数据和本地知识材料。

def build_day028_note(input_name, output_name, risk):
    return {
        "day": "Day28",
        "topic": "NumPy 数组与向量化计算",
        "input": input_name,
        "output": output_name,
        "risk": risk,
        "next_check": "确认输入、处理步骤、输出和失败点是否清楚",
    }

工程工作流补充

如果你完全看不懂，先只抓这一句话

今天学的是：NumPy 数组与向量化计算。它不只是一个孤立知识点，而是服务于「数据分析与本地数据系统」阶段的一个小能力：把原始数据变成可以检查、保存、复盘的数据资产。

先按这条工程线理解：

读取数据 -> 检查字段 -> 清洗/计算 -> 保存结果 -> 写报告

你不需要一开始把所有细节背下来。先回答五个问题：

1. 今天的输入是什么？

2. 中间处理分几步？

3. 输出保存在哪里？

4. 失败时会在哪一步失败？

5. 这个能力以后能放进哪个主题？

真实工作流怎么想

把今天的主题放进一个真实主题里，它通常不是单独出现的。比如做一个 AI/data/quant 小工具时，你会经历：

执行过程追踪

读今天代码时，不要只看语法，要追踪数据怎么走：

输入
  ↓
核心处理
  ↓
中间结果
  ↓
边界检查
  ↓
最终输出

当前最应该检查：字段名、数据类型、空值、重复、样例输出。

最容易混的点

工业化知识百科补充：从会用到会迁移

这一节不是把前面没学完的语法硬塞回来，而是把 NumPy 数组与向量化计算 放进后续 IC 挑战里补厚。你现在已经进入 Day10 之后，学习重点要从“我知道这个语法”升级为“我知道它在工程里解决什么问题、会踩什么坑、怎么迁移到 IC”。

1. 阶段定位

当前阶段：数据分析与本地数据系统。

阶段目标：把原始数据变成结构清楚、指标可信、结果可复查的数据资产。

本阶段反复出现的能力：

• 数据体检
• 类型转换
• 缺失值处理
• 聚合统计
• 时间窗口
• SQL 与本地数据库

2. 这个主题必须补齐的知识面

• DataFrame
• 索引
• 字段类型
• 缺失值
• 聚合
• join
• 滚动窗口
• 向量化

学习时不要把这些点当成孤立词条。更好的读法是：每个概念都对应一种工程压力，例如输入变多、数据变脏、文件变大、结果要复现、输出要交给别人、模型回答需要校验。

3. 真实主题里怎么用

• 数据分析：先明确字段、类型、缺失值、样本范围，再写处理逻辑。不要直接对未知数据写复杂代码。
• Quant：任何计算都要关心时间顺序、样本区间、交易成本、未来函数和结果复现。
• LLM/Agent：所有输入输出都要有结构，模型结果要校验，高风险动作要有人类审查点。

4. 常见坑和边界

• 先体检数据再分析。
• 清洗步骤要能复盘。
• 图表必须说明数据来源、时间范围和口径。
• 不要把所有逻辑堆进一个文件或一个函数。先拆出最小核心函数，再决定是否需要 CLI、API、看板或测试。
• 不要用“能跑一次”代表掌握。真正掌握是换一份输入、换一个场景、换一个主题后仍然能迁移。

5. 最小迁移代码模块边界

def day028_engineering_note(input_data):
    """记录今天知识点在工程主题里的使用边界。"""
    return {
        "day": "Day28",
        "topic": "NumPy 数组与向量化计算",
        "input_shape": "明确输入来源、字段、类型和边界",
        "core_step": "把今天主题压缩成一个可测试的小函数",
        "output_shape": "明确输出给终端、文件、API、报告还是下游函数",
        "failure_modes": ["空输入", "类型不对", "缺字段", "路径或网络失败"],
        "reuse_target": "数据分析 / Quant / LLM-Agent / 能力清单主题",
    }

6. 百科式自查问题

1. 这个主题的输入是什么？输入可能为空、缺字段、类型错误吗？

2. 核心处理步骤能不能写成一个小函数？

3. 输出是给人看，还是给下游程序继续用？

4. 失败时怎么记录？是 print、logging、错误报告，还是测试失败？

5. 如果迁移到 Quant / LLM / Agent 主题，最大的风险是什么？

6. 这个能力是否需要 说明文档、样例数据或测试来长期保存？

7. 建议扩展练习

• 写一个最小正常样例。
• 写一个边界样例，例如空输入、缺字段、类型错误、路径不存在。
• 写一段 Debug 记录，说明错误现象、定位过程和修复方式。
• 把今天的代码改造成一个函数，并说明输入和输出。
• 思考它未来会放进哪个主题模块：data_io、transform、analysis、api、app、agent_tool、backtest 或 report。

2 小时学习节奏

• 15 分钟：读定位、前置和知识地图。
• 25 分钟：手打最小案例并运行。
• 35 分钟：完成 7 道简单路线题。
• 35 分钟：完成 5 道基础巩固题。
• 10 分钟：记录 Debug、结果和下一步。

简单路线 7 题

1. 读完“学习定位”，用一句话写下今天要解决的问题。

2. 手打最小案例并运行，确认得到 一个向量化收益率计算。

3. 把示例输入改成 2-3 条虚拟样例，观察输出是否仍然合理。

4. 故意制造一个小错误，记录报错、原因和修复方式。

5. 给输出加一个清晰字段名或标题，避免只看到裸数字。

6. 把今天代码保存到本地练习文件夹，并写下运行命令。

7. 用 3 行话说明它如何服务于 高效数值计算和机器学习前置。

今日强化题（带具体代码）

> 每天正文上限控制在 600 行以内。强化题不是口头描述，必须能落到 main.py 运行。

强化题 1：复现最小案例

任务：把下面参考代码复制到 main.py，先不要改，直接运行。

验收：终端能打印 JSON，且本地生成 outputs/day028/。

强化题 2：替换输入

任务：只改输入数据，至少新增 2 条样例。

验收：输出数量、均值、跳过记录或检索结果发生合理变化。

强化题 3：边界检查

任务：制造 1 个坏输入，例如空值、重复值、非法字段或极端价格。

验收：程序不会静默失败；你能在输出或 errors.md 里解释原因。

强化题 4：结果保存

任务：把运行结果保存到 JSON、CSV、Markdown 或 SQLite 中的一种。

验收：关闭终端后，仍能从文件复查今天结果。

强化题 5：迁移说明

任务：写 3 句话说明 NumPy 数组与向量化计算 会如何迁移到 Data、Quant、LLM 或 Agent。

验收：不是写“以后有用”，而是写清具体场景。

参考代码：main.py

from pathlib import Path
import json
from statistics import mean

TOPIC = 'NumPy 数组与向量化计算'
DAY = 28
ROOT = Path(__file__).resolve().parent
OUT = ROOT / "outputs" / f"day{DAY:03d}"


def ensure_dirs():
    OUT.mkdir(parents=True, exist_ok=True)


def sample_rows():
    return [
        {"user": "u1", "group": "A", "value": 12},
        {"user": "u2", "group": "A", "value": 18},
        {"user": "u3", "group": "B", "value": 9},
        {"user": "u4", "group": "B", "value": None},
    ]


def clean_rows(rows):
    cleaned = []
    skipped = []
    for row in rows:
        if row["value"] is None:
            skipped.append({"row": row, "reason": "missing value"})
            continue
        cleaned.append(row)
    return cleaned, skipped


def summarize(cleaned, skipped):
    values = [row["value"] for row in cleaned]
    return {
        "topic": TOPIC,
        "valid_rows": len(cleaned),
        "skipped_rows": len(skipped),
        "mean_value": round(mean(values), 2) if values else 0,
        "groups": sorted({row["group"] for row in cleaned}),
    }


def main():
    ensure_dirs()
    cleaned, skipped = clean_rows(sample_rows())
    summary = summarize(cleaned, skipped)
    (OUT / "summary.json").write_text(json.dumps(summary, ensure_ascii=False, indent=2), encoding="utf-8")
    (OUT / "skipped.json").write_text(json.dumps(skipped, ensure_ascii=False, indent=2), encoding="utf-8")
    print(json.dumps(summary, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

运行命令

python main.py

Debug 记录要求

错误现象：
触发输入：
定位过程：
修复方式：
以后如何避免：

Debug 记录模板

错误现象：
触发输入：
定位过程：
修复方式：
以后如何避免：

复习检查

• [ ] 我能解释今天能力的输入、处理和输出。
• [ ] 我能从零手打最小案例。
• [ ] 我完成了今日强化题，并运行了 main.py 参考代码。
• [ ] 我把结果保存成可复查产物。

参考资料

• NumPy 文档

Day29 - 统计指标、样本量与置信思维

> 阶段三：数据分析与本地数据系统

学习定位

把均值、波动、标准误写成可解释函数。

今天的目标不是背定义，而是产出：一个统计 summary dict。

前置知识

• 推荐前置：Day28 NumPy
• 上一站：Day28
• 下一站：Day30

今日知识地图

• mean
• std
• standard error
• 样本量

真实任务入口

今天先不从定义开始，而是先看问题：如何用「统计指标、样本量与置信思维」完成 一个统计 summary dict？

这个问题在工程里不是孤立练习。它属于 数据分析与本地数据系统 阶段，目标是：把原始数据变成可检查、可保存、可复盘的数据资产。

先按这条顺序学习：

真实任务
  ↓
拆解流程
  ↓
引出问题
  ↓
引出知识点
  ↓
解释设计原因
  ↓
代码实现
  ↓
未来使用

今天你真正要掌握的不是“会背哪个语法”，而是能回答：它解决什么问题、为什么需要它、怎么落到代码、以后在哪个主题会再次出现。

工程问题解决结构

1. 是什么（What）

统计指标、样本量与置信思维 是用 Python 解决工程任务时的一组小工具。最简定义：它帮助你把「mean、std、standard error」放进可运行流程里。先把它当成解决问题的方法，不要先背术语。

2. 为什么存在（Why）

如果没有 统计指标、样本量与置信思维，代码通常会变成一次性脚本：逻辑散、结果难复查、报错难定位、以后练习里也难复用。它存在的意义是把真实任务拆成更清楚的步骤，让你知道哪里输入、哪里处理、哪里输出。

3. 真实工程场景（Real Scenario）

• 科研场景：读取实验数据，检查字段、缺失值和样本量，生成 Markdown 记录。
• 数据分析场景：清洗业务数据，计算指标，保存 CSV、SQLite 或报告。
• Quant 场景：读取行情样例，计算收益率、移动平均、分组指标或风险统计。
• LLM/Agent 场景：把数据检查步骤封装成 tool，让 Agent 调用后返回结构化结果。

4. 怎么做（How）

先看场景流程，再看代码：

原始数据
  ↓
字段检查
  ↓
清洗/计算
  ↓
边界检查
  ↓
保存结果
  ↓
写分析说明

from pathlib import Path

# Day29 - 统计指标、样本量与置信思维
raw_rows = [{"name": "sample", "value": 1}]

processed = []
for row in raw_rows:
    if "value" not in row:
        continue
    processed.append({"name": row["name"], "value": row["value"]})

Path("outputs").mkdir(exist_ok=True)
Path("outputs/day29_result.txt").write_text(str(processed), encoding="utf-8")
print(processed)

5. 工程设计思维（Design）

工程师会多写一层函数、配置、输出文件或 说明文档，是为了让代码不只今天能跑，也能被明天的自己、未来的自己和未来主题继续使用。

6. Future Usage（未来使用）

这个知识点以后会反复出现在：

• 数据分析报告
• SQLite 本地数据系统
• Quant 指标管道
• Agent 数据检查工具
• 数据处理脚本

7. 掌握检查

学完今天不要只问“代码跑了吗”，要能回答四个问题：

1. 它是什么？

2. 它为什么存在？

3. 它解决什么问题？

4. 它在未来 Quant / LLM / Agent 主题中怎么使用？

基础优化补充：问题、场景与代码

阶段定位：数据分析与本地数据系统。

解决什么问题（Problem）：统计指标、样本量与置信思维 的核心不是背概念，而是把原始数据变成可以检查、清洗、计算、保存和复盘的数据资产。

真实科研场景：整理实验数据、论文元数据和指标结果，让每一步处理都有输入、输出和检查记录。

数据分析场景：读取 CSV/Excel/SQLite 数据，完成字段检查、清洗、聚合、统计和报告输出。

Quant 场景：处理行情、收益率、指标和时间序列，形成后续回测或研究报告的基础数据层。

LLM/Agent 场景：为 LLM/RAG 提供干净、结构化、可引用的数据和本地知识材料。

def build_day029_note(input_name, output_name, risk):
    return {
        "day": "Day29",
        "topic": "统计指标、样本量与置信思维",
        "input": input_name,
        "output": output_name,
        "risk": risk,
        "next_check": "确认输入、处理步骤、输出和失败点是否清楚",
    }

工程工作流补充

如果你完全看不懂，先只抓这一句话

今天学的是：统计指标、样本量与置信思维。它不只是一个孤立知识点，而是服务于「数据分析与本地数据系统」阶段的一个小能力：把原始数据变成可以检查、保存、复盘的数据资产。

先按这条工程线理解：

读取数据 -> 检查字段 -> 清洗/计算 -> 保存结果 -> 写报告

你不需要一开始把所有细节背下来。先回答五个问题：

1. 今天的输入是什么？

2. 中间处理分几步？

3. 输出保存在哪里？

4. 失败时会在哪一步失败？

5. 这个能力以后能放进哪个主题？

真实工作流怎么想

把今天的主题放进一个真实主题里，它通常不是单独出现的。比如做一个 AI/data/quant 小工具时，你会经历：

执行过程追踪

读今天代码时，不要只看语法，要追踪数据怎么走：

输入
  ↓
核心处理
  ↓
中间结果
  ↓
边界检查
  ↓
最终输出

当前最应该检查：字段名、数据类型、空值、重复、样例输出。

最容易混的点

工业化知识百科补充：从会用到会迁移

这一节不是把前面没学完的语法硬塞回来，而是把 统计指标、样本量与置信思维 放进后续 IC 挑战里补厚。你现在已经进入 Day10 之后，学习重点要从“我知道这个语法”升级为“我知道它在工程里解决什么问题、会踩什么坑、怎么迁移到 IC”。

1. 阶段定位

当前阶段：数据分析与本地数据系统。

阶段目标：把原始数据变成结构清楚、指标可信、结果可复查的数据资产。

本阶段反复出现的能力：

• 数据体检
• 类型转换
• 缺失值处理
• 聚合统计
• 时间窗口
• SQL 与本地数据库

2. 这个主题必须补齐的知识面

• DataFrame
• 索引
• 字段类型
• 缺失值
• 聚合
• join
• 滚动窗口
• 向量化

学习时不要把这些点当成孤立词条。更好的读法是：每个概念都对应一种工程压力，例如输入变多、数据变脏、文件变大、结果要复现、输出要交给别人、模型回答需要校验。

3. 真实主题里怎么用

• 数据分析：先明确字段、类型、缺失值、样本范围，再写处理逻辑。不要直接对未知数据写复杂代码。
• Quant：任何计算都要关心时间顺序、样本区间、交易成本、未来函数和结果复现。
• LLM/Agent：所有输入输出都要有结构，模型结果要校验，高风险动作要有人类审查点。

4. 常见坑和边界

• 先体检数据再分析。
• 清洗步骤要能复盘。
• 图表必须说明数据来源、时间范围和口径。
• 不要把所有逻辑堆进一个文件或一个函数。先拆出最小核心函数，再决定是否需要 CLI、API、看板或测试。
• 不要用“能跑一次”代表掌握。真正掌握是换一份输入、换一个场景、换一个主题后仍然能迁移。

5. 最小迁移代码模块边界

def day029_engineering_note(input_data):
    """记录今天知识点在工程主题里的使用边界。"""
    return {
        "day": "Day29",
        "topic": "统计指标、样本量与置信思维",
        "input_shape": "明确输入来源、字段、类型和边界",
        "core_step": "把今天主题压缩成一个可测试的小函数",
        "output_shape": "明确输出给终端、文件、API、报告还是下游函数",
        "failure_modes": ["空输入", "类型不对", "缺字段", "路径或网络失败"],
        "reuse_target": "数据分析 / Quant / LLM-Agent / 能力清单主题",
    }

6. 百科式自查问题

1. 这个主题的输入是什么？输入可能为空、缺字段、类型错误吗？

2. 核心处理步骤能不能写成一个小函数？

3. 输出是给人看，还是给下游程序继续用？

4. 失败时怎么记录？是 print、logging、错误报告，还是测试失败？

5. 如果迁移到 Quant / LLM / Agent 主题，最大的风险是什么？

6. 这个能力是否需要 说明文档、样例数据或测试来长期保存？

7. 建议扩展练习

• 写一个最小正常样例。
• 写一个边界样例，例如空输入、缺字段、类型错误、路径不存在。
• 写一段 Debug 记录，说明错误现象、定位过程和修复方式。
• 把今天的代码改造成一个函数，并说明输入和输出。
• 思考它未来会放进哪个主题模块：data_io、transform、analysis、api、app、agent_tool、backtest 或 report。

2 小时学习节奏

• 15 分钟：读定位、前置和知识地图。
• 25 分钟：手打最小案例并运行。
• 35 分钟：完成 7 道简单路线题。
• 35 分钟：完成 5 道基础巩固题。
• 10 分钟：记录 Debug、结果和下一步。

简单路线 7 题

1. 读完“学习定位”，用一句话写下今天要解决的问题。

2. 手打最小案例并运行，确认得到 一个统计 summary dict。

3. 把示例输入改成 2-3 条虚拟样例，观察输出是否仍然合理。

4. 故意制造一个小错误，记录报错、原因和修复方式。

5. 给输出加一个清晰字段名或标题，避免只看到裸数字。

6. 把今天代码保存到本地练习文件夹，并写下运行命令。

7. 用 3 行话说明它如何服务于 A/B 测试、Quant 和模型评估。

今日强化题（带具体代码）

> 每天正文上限控制在 600 行以内。强化题不是口头描述，必须能落到 main.py 运行。

强化题 1：复现最小案例

任务：把下面参考代码复制到 main.py，先不要改，直接运行。

验收：终端能打印 JSON，且本地生成 outputs/day029/。

强化题 2：替换输入

任务：只改输入数据，至少新增 2 条样例。

验收：输出数量、均值、跳过记录或检索结果发生合理变化。

强化题 3：边界检查

任务：制造 1 个坏输入，例如空值、重复值、非法字段或极端价格。

验收：程序不会静默失败；你能在输出或 errors.md 里解释原因。

强化题 4：结果保存

任务：把运行结果保存到 JSON、CSV、Markdown 或 SQLite 中的一种。

验收：关闭终端后，仍能从文件复查今天结果。

强化题 5：迁移说明

任务：写 3 句话说明 统计指标、样本量与置信思维 会如何迁移到 Data、Quant、LLM 或 Agent。

验收：不是写“以后有用”，而是写清具体场景。

参考代码：main.py

from pathlib import Path
import json
from statistics import mean

TOPIC = '统计指标、样本量与置信思维'
DAY = 29
ROOT = Path(__file__).resolve().parent
OUT = ROOT / "outputs" / f"day{DAY:03d}"


def ensure_dirs():
    OUT.mkdir(parents=True, exist_ok=True)


def sample_rows():
    return [
        {"user": "u1", "group": "A", "value": 12},
        {"user": "u2", "group": "A", "value": 18},
        {"user": "u3", "group": "B", "value": 9},
        {"user": "u4", "group": "B", "value": None},
    ]


def clean_rows(rows):
    cleaned = []
    skipped = []
    for row in rows:
        if row["value"] is None:
            skipped.append({"row": row, "reason": "missing value"})
            continue
        cleaned.append(row)
    return cleaned, skipped


def summarize(cleaned, skipped):
    values = [row["value"] for row in cleaned]
    return {
        "topic": TOPIC,
        "valid_rows": len(cleaned),
        "skipped_rows": len(skipped),
        "mean_value": round(mean(values), 2) if values else 0,
        "groups": sorted({row["group"] for row in cleaned}),
    }


def main():
    ensure_dirs()
    cleaned, skipped = clean_rows(sample_rows())
    summary = summarize(cleaned, skipped)
    (OUT / "summary.json").write_text(json.dumps(summary, ensure_ascii=False, indent=2), encoding="utf-8")
    (OUT / "skipped.json").write_text(json.dumps(skipped, ensure_ascii=False, indent=2), encoding="utf-8")
    print(json.dumps(summary, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

运行命令

python main.py

Debug 记录要求

错误现象：
触发输入：
定位过程：
修复方式：
以后如何避免：

Debug 记录模板

错误现象：
触发输入：
定位过程：
修复方式：
以后如何避免：

复习检查

• [ ] 我能解释今天能力的输入、处理和输出。
• [ ] 我能从零手打最小案例。
• [ ] 我完成了今日强化题，并运行了 main.py 参考代码。
• [ ] 我把结果保存成可复查产物。

参考资料

• Python 官方文档

Day30 - 可视化与 Markdown 报告

> 阶段三：数据分析与本地数据系统

学习定位

保存图表和文字报告。

今天的目标不是背定义，而是产出：一张图和一份 report.md。

前置知识

• 推荐前置：Day29 统计指标
• 上一站：Day29
• 下一站：Day31

今日知识地图

• plot
• savefig
• Markdown
• 结论说明

真实任务入口

今天先不从定义开始，而是先看问题：如何用「可视化与 Markdown 报告」完成 一张图和一份 report.md？

这个问题在工程里不是孤立练习。它属于 数据分析与本地数据系统 阶段，目标是：把原始数据变成可检查、可保存、可复盘的数据资产。

先按这条顺序学习：

真实任务
  ↓
拆解流程
  ↓
引出问题
  ↓
引出知识点
  ↓
解释设计原因
  ↓
代码实现
  ↓
未来使用

今天你真正要掌握的不是“会背哪个语法”，而是能回答：它解决什么问题、为什么需要它、怎么落到代码、以后在哪个主题会再次出现。

工程问题解决结构

1. 是什么（What）

可视化与 Markdown 报告 是用 Python 解决工程任务时的一组小工具。最简定义：它帮助你把「plot、savefig、Markdown」放进可运行流程里。先把它当成解决问题的方法，不要先背术语。

2. 为什么存在（Why）

如果没有 可视化与 Markdown 报告，代码通常会变成一次性脚本：逻辑散、结果难复查、报错难定位、以后练习里也难复用。它存在的意义是把真实任务拆成更清楚的步骤，让你知道哪里输入、哪里处理、哪里输出。

3. 真实工程场景（Real Scenario）

• 科研场景：读取实验数据，检查字段、缺失值和样本量，生成 Markdown 记录。
• 数据分析场景：清洗业务数据，计算指标，保存 CSV、SQLite 或报告。
• Quant 场景：读取行情样例，计算收益率、移动平均、分组指标或风险统计。
• LLM/Agent 场景：把数据检查步骤封装成 tool，让 Agent 调用后返回结构化结果。

4. 怎么做（How）

先看场景流程，再看代码：

原始数据
  ↓
字段检查
  ↓
清洗/计算
  ↓
边界检查
  ↓
保存结果
  ↓
写分析说明

from pathlib import Path

# Day30 - 可视化与 Markdown 报告
raw_rows = [{"name": "sample", "value": 1}]

processed = []
for row in raw_rows:
    if "value" not in row:
        continue
    processed.append({"name": row["name"], "value": row["value"]})

Path("outputs").mkdir(exist_ok=True)
Path("outputs/day30_result.txt").write_text(str(processed), encoding="utf-8")
print(processed)

5. 工程设计思维（Design）

工程师会多写一层函数、配置、输出文件或 说明文档，是为了让代码不只今天能跑，也能被明天的自己、未来的自己和未来主题继续使用。

6. Future Usage（未来使用）

这个知识点以后会反复出现在：

• 数据分析报告
• SQLite 本地数据系统
• Quant 指标管道
• Agent 数据检查工具
• 数据处理脚本

7. 掌握检查

学完今天不要只问“代码跑了吗”，要能回答四个问题：

1. 它是什么？

2. 它为什么存在？

3. 它解决什么问题？

4. 它在未来 Quant / LLM / Agent 主题中怎么使用？

基础优化补充：问题、场景与代码

阶段定位：数据分析与本地数据系统。

解决什么问题（Problem）：可视化与 Markdown 报告 的核心不是背概念，而是把原始数据变成可以检查、清洗、计算、保存和复盘的数据资产。

真实科研场景：整理实验数据、论文元数据和指标结果，让每一步处理都有输入、输出和检查记录。

数据分析场景：读取 CSV/Excel/SQLite 数据，完成字段检查、清洗、聚合、统计和报告输出。

Quant 场景：处理行情、收益率、指标和时间序列，形成后续回测或研究报告的基础数据层。

LLM/Agent 场景：为 LLM/RAG 提供干净、结构化、可引用的数据和本地知识材料。

def build_day030_note(input_name, output_name, risk):
    return {
        "day": "Day30",
        "topic": "可视化与 Markdown 报告",
        "input": input_name,
        "output": output_name,
        "risk": risk,
        "next_check": "确认输入、处理步骤、输出和失败点是否清楚",
    }

工程工作流补充

如果你完全看不懂，先只抓这一句话

今天学的是：可视化与 Markdown 报告。它不只是一个孤立知识点，而是服务于「数据分析与本地数据系统」阶段的一个小能力：把原始数据变成可以检查、保存、复盘的数据资产。

先按这条工程线理解：

读取数据 -> 检查字段 -> 清洗/计算 -> 保存结果 -> 写报告

你不需要一开始把所有细节背下来。先回答五个问题：

1. 今天的输入是什么？

2. 中间处理分几步？

3. 输出保存在哪里？

4. 失败时会在哪一步失败？

5. 这个能力以后能放进哪个主题？

真实工作流怎么想

把今天的主题放进一个真实主题里，它通常不是单独出现的。比如做一个 AI/data/quant 小工具时，你会经历：

执行过程追踪

读今天代码时，不要只看语法，要追踪数据怎么走：

输入
  ↓
核心处理
  ↓
中间结果
  ↓
边界检查
  ↓
最终输出

当前最应该检查：字段名、数据类型、空值、重复、样例输出。

最容易混的点

工业化知识百科补充：从会用到会迁移

这一节不是把前面没学完的语法硬塞回来，而是把 可视化与 Markdown 报告 放进后续 IC 挑战里补厚。你现在已经进入 Day10 之后，学习重点要从“我知道这个语法”升级为“我知道它在工程里解决什么问题、会踩什么坑、怎么迁移到 IC”。

1. 阶段定位

当前阶段：数据分析与本地数据系统。

阶段目标：把原始数据变成结构清楚、指标可信、结果可复查的数据资产。

本阶段反复出现的能力：

• 数据体检
• 类型转换
• 缺失值处理
• 聚合统计
• 时间窗口
• SQL 与本地数据库

2. 这个主题必须补齐的知识面

• DataFrame
• 索引
• 字段类型
• 缺失值
• 聚合
• join
• 滚动窗口
• 向量化

学习时不要把这些点当成孤立词条。更好的读法是：每个概念都对应一种工程压力，例如输入变多、数据变脏、文件变大、结果要复现、输出要交给别人、模型回答需要校验。

3. 真实主题里怎么用

• 数据分析：先明确字段、类型、缺失值、样本范围，再写处理逻辑。不要直接对未知数据写复杂代码。
• Quant：任何计算都要关心时间顺序、样本区间、交易成本、未来函数和结果复现。
• LLM/Agent：所有输入输出都要有结构，模型结果要校验，高风险动作要有人类审查点。

4. 常见坑和边界

• 先体检数据再分析。
• 清洗步骤要能复盘。
• 图表必须说明数据来源、时间范围和口径。
• 不要把所有逻辑堆进一个文件或一个函数。先拆出最小核心函数，再决定是否需要 CLI、API、看板或测试。
• 不要用“能跑一次”代表掌握。真正掌握是换一份输入、换一个场景、换一个主题后仍然能迁移。

5. 最小迁移代码模块边界

def day030_engineering_note(input_data):
    """记录今天知识点在工程主题里的使用边界。"""
    return {
        "day": "Day30",
        "topic": "可视化与 Markdown 报告",
        "input_shape": "明确输入来源、字段、类型和边界",
        "core_step": "把今天主题压缩成一个可测试的小函数",
        "output_shape": "明确输出给终端、文件、API、报告还是下游函数",
        "failure_modes": ["空输入", "类型不对", "缺字段", "路径或网络失败"],
        "reuse_target": "数据分析 / Quant / LLM-Agent / 能力清单主题",
    }

6. 百科式自查问题

1. 这个主题的输入是什么？输入可能为空、缺字段、类型错误吗？

2. 核心处理步骤能不能写成一个小函数？

3. 输出是给人看，还是给下游程序继续用？

4. 失败时怎么记录？是 print、logging、错误报告，还是测试失败？

5. 如果迁移到 Quant / LLM / Agent 主题，最大的风险是什么？

6. 这个能力是否需要 说明文档、样例数据或测试来长期保存？

7. 建议扩展练习

• 写一个最小正常样例。
• 写一个边界样例，例如空输入、缺字段、类型错误、路径不存在。
• 写一段 Debug 记录，说明错误现象、定位过程和修复方式。
• 把今天的代码改造成一个函数，并说明输入和输出。
• 思考它未来会放进哪个主题模块：data_io、transform、analysis、api、app、agent_tool、backtest 或 report。

2 小时学习节奏

• 15 分钟：读定位、前置和知识地图。
• 25 分钟：手打最小案例并运行。
• 35 分钟：完成 7 道简单路线题。
• 35 分钟：完成 5 道基础巩固题。
• 10 分钟：记录 Debug、结果和下一步。

简单路线 7 题

1. 读完“学习定位”，用一句话写下今天要解决的问题。

2. 手打最小案例并运行，确认得到 一张图和一份 report.md。

3. 把示例输入改成 2-3 条虚拟样例，观察输出是否仍然合理。

4. 故意制造一个小错误，记录报错、原因和修复方式。

5. 给输出加一个清晰字段名或标题，避免只看到裸数字。

6. 把今天代码保存到本地练习文件夹，并写下运行命令。

7. 用 3 行话说明它如何服务于 数据报告、策略复盘和作品展示。

今日强化题（带具体代码）

> 每天正文上限控制在 600 行以内。强化题不是口头描述，必须能落到 main.py 运行。

强化题 1：复现最小案例

任务：把下面参考代码复制到 main.py，先不要改，直接运行。

验收：终端能打印 JSON，且本地生成 outputs/day030/。

强化题 2：替换输入

任务：只改输入数据，至少新增 2 条样例。

验收：输出数量、均值、跳过记录或检索结果发生合理变化。

强化题 3：边界检查

任务：制造 1 个坏输入，例如空值、重复值、非法字段或极端价格。

验收：程序不会静默失败；你能在输出或 errors.md 里解释原因。

强化题 4：结果保存

任务：把运行结果保存到 JSON、CSV、Markdown 或 SQLite 中的一种。

验收：关闭终端后，仍能从文件复查今天结果。

强化题 5：迁移说明

任务：写 3 句话说明 可视化与 Markdown 报告 会如何迁移到 Data、Quant、LLM 或 Agent。

验收：不是写“以后有用”，而是写清具体场景。

参考代码：main.py

from pathlib import Path
import json
from statistics import mean

TOPIC = '可视化与 Markdown 报告'
DAY = 30
ROOT = Path(__file__).resolve().parent
OUT = ROOT / "outputs" / f"day{DAY:03d}"


def ensure_dirs():
    OUT.mkdir(parents=True, exist_ok=True)


def sample_rows():
    return [
        {"user": "u1", "group": "A", "value": 12},
        {"user": "u2", "group": "A", "value": 18},
        {"user": "u3", "group": "B", "value": 9},
        {"user": "u4", "group": "B", "value": None},
    ]


def clean_rows(rows):
    cleaned = []
    skipped = []
    for row in rows:
        if row["value"] is None:
            skipped.append({"row": row, "reason": "missing value"})
            continue
        cleaned.append(row)
    return cleaned, skipped


def summarize(cleaned, skipped):
    values = [row["value"] for row in cleaned]
    return {
        "topic": TOPIC,
        "valid_rows": len(cleaned),
        "skipped_rows": len(skipped),
        "mean_value": round(mean(values), 2) if values else 0,
        "groups": sorted({row["group"] for row in cleaned}),
    }


def main():
    ensure_dirs()
    cleaned, skipped = clean_rows(sample_rows())
    summary = summarize(cleaned, skipped)
    (OUT / "summary.json").write_text(json.dumps(summary, ensure_ascii=False, indent=2), encoding="utf-8")
    (OUT / "skipped.json").write_text(json.dumps(skipped, ensure_ascii=False, indent=2), encoding="utf-8")
    print(json.dumps(summary, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

运行命令

python main.py

Debug 记录要求

错误现象：
触发输入：
定位过程：
修复方式：
以后如何避免：

Debug 记录模板

错误现象：
触发输入：
定位过程：
修复方式：
以后如何避免：

复习检查

• [ ] 我能解释今天能力的输入、处理和输出。
• [ ] 我能从零手打最小案例。
• [ ] 我完成了今日强化题，并运行了 main.py 参考代码。
• [ ] 我把结果保存成可复查产物。

参考资料

• Python 官方文档

Day31 - SQLite 本地数据库

> 阶段三：数据分析与本地数据系统

学习定位

把结构化结果保存到轻量数据库。

今天的目标不是背定义，而是产出：一个 research.db。

前置知识

• 推荐前置：Day30 报告
• 上一站：Day30
• 下一站：Day32

今日知识地图

• sqlite3
• CREATE TABLE
• INSERT
• SELECT

真实任务入口

今天先不从定义开始，而是先看问题：如何用「SQLite 本地数据库」完成 一个 research.db？

这个问题在工程里不是孤立练习。它属于 数据分析与本地数据系统 阶段，目标是：把原始数据变成可检查、可保存、可复盘的数据资产。

先按这条顺序学习：

真实任务
  ↓
拆解流程
  ↓
引出问题
  ↓
引出知识点
  ↓
解释设计原因
  ↓
代码实现
  ↓
未来使用

今天你真正要掌握的不是“会背哪个语法”，而是能回答：它解决什么问题、为什么需要它、怎么落到代码、以后在哪个主题会再次出现。

工程问题解决结构

1. 是什么（What）

SQLite 本地数据库 是用 Python 解决工程任务时的一组小工具。最简定义：它帮助你把「sqlite3、CREATE TABLE、INSERT」放进可运行流程里。先把它当成解决问题的方法，不要先背术语。

2. 为什么存在（Why）

如果没有 SQLite 本地数据库，代码通常会变成一次性脚本：逻辑散、结果难复查、报错难定位、以后练习里也难复用。它存在的意义是把真实任务拆成更清楚的步骤，让你知道哪里输入、哪里处理、哪里输出。

3. 真实工程场景（Real Scenario）

• 科研场景：读取实验数据，检查字段、缺失值和样本量，生成 Markdown 记录。
• 数据分析场景：清洗业务数据，计算指标，保存 CSV、SQLite 或报告。
• Quant 场景：读取行情样例，计算收益率、移动平均、分组指标或风险统计。
• LLM/Agent 场景：把数据检查步骤封装成 tool，让 Agent 调用后返回结构化结果。

4. 怎么做（How）

先看场景流程，再看代码：

原始数据
  ↓
字段检查
  ↓
清洗/计算
  ↓
边界检查
  ↓
保存结果
  ↓
写分析说明

from pathlib import Path

# Day31 - SQLite 本地数据库
raw_rows = [{"name": "sample", "value": 1}]

processed = []
for row in raw_rows:
    if "value" not in row:
        continue
    processed.append({"name": row["name"], "value": row["value"]})

Path("outputs").mkdir(exist_ok=True)
Path("outputs/day31_result.txt").write_text(str(processed), encoding="utf-8")
print(processed)

5. 工程设计思维（Design）

工程师会多写一层函数、配置、输出文件或 说明文档，是为了让代码不只今天能跑，也能被明天的自己、未来的自己和未来主题继续使用。

6. Future Usage（未来使用）

这个知识点以后会反复出现在：

• 数据分析报告
• SQLite 本地数据系统
• Quant 指标管道
• Agent 数据检查工具
• 数据处理脚本

7. 掌握检查

学完今天不要只问“代码跑了吗”，要能回答四个问题：

1. 它是什么？

2. 它为什么存在？

3. 它解决什么问题？

4. 它在未来 Quant / LLM / Agent 主题中怎么使用？

基础优化补充：问题、场景与代码

阶段定位：数据分析与本地数据系统。

解决什么问题（Problem）：SQLite 本地数据库 的核心不是背概念，而是把原始数据变成可以检查、清洗、计算、保存和复盘的数据资产。

真实科研场景：整理实验数据、论文元数据和指标结果，让每一步处理都有输入、输出和检查记录。

数据分析场景：读取 CSV/Excel/SQLite 数据，完成字段检查、清洗、聚合、统计和报告输出。

Quant 场景：处理行情、收益率、指标和时间序列，形成后续回测或研究报告的基础数据层。

LLM/Agent 场景：为 LLM/RAG 提供干净、结构化、可引用的数据和本地知识材料。

def build_day031_note(input_name, output_name, risk):
    return {
        "day": "Day31",
        "topic": "SQLite 本地数据库",
        "input": input_name,
        "output": output_name,
        "risk": risk,
        "next_check": "确认输入、处理步骤、输出和失败点是否清楚",
    }

工程工作流补充

如果你完全看不懂，先只抓这一句话

今天学的是：SQLite 本地数据库。它不只是一个孤立知识点，而是服务于「数据分析与本地数据系统」阶段的一个小能力：把原始数据变成可以检查、保存、复盘的数据资产。

先按这条工程线理解：

读取数据 -> 检查字段 -> 清洗/计算 -> 保存结果 -> 写报告

你不需要一开始把所有细节背下来。先回答五个问题：

1. 今天的输入是什么？

2. 中间处理分几步？

3. 输出保存在哪里？

4. 失败时会在哪一步失败？

5. 这个能力以后能放进哪个主题？

真实工作流怎么想

把今天的主题放进一个真实主题里，它通常不是单独出现的。比如做一个 AI/data/quant 小工具时，你会经历：

执行过程追踪

读今天代码时，不要只看语法，要追踪数据怎么走：

输入
  ↓
核心处理
  ↓
中间结果
  ↓
边界检查
  ↓
最终输出

当前最应该检查：字段名、数据类型、空值、重复、样例输出。

最容易混的点

工业化知识百科补充：从会用到会迁移

这一节不是把前面没学完的语法硬塞回来，而是把 SQLite 本地数据库 放进后续 IC 挑战里补厚。你现在已经进入 Day10 之后，学习重点要从“我知道这个语法”升级为“我知道它在工程里解决什么问题、会踩什么坑、怎么迁移到 IC”。

1. 阶段定位

当前阶段：数据分析与本地数据系统。

阶段目标：把原始数据变成结构清楚、指标可信、结果可复查的数据资产。

本阶段反复出现的能力：

• 数据体检
• 类型转换
• 缺失值处理
• 聚合统计
• 时间窗口
• SQL 与本地数据库

2. 这个主题必须补齐的知识面

• 表结构
• 主键
• 索引
• join
• 窗口函数
• 事务
• 查询复用

学习时不要把这些点当成孤立词条。更好的读法是：每个概念都对应一种工程压力，例如输入变多、数据变脏、文件变大、结果要复现、输出要交给别人、模型回答需要校验。

3. 真实主题里怎么用

• 数据分析：先明确字段、类型、缺失值、样本范围，再写处理逻辑。不要直接对未知数据写复杂代码。
• Quant：任何计算都要关心时间顺序、样本区间、交易成本、未来函数和结果复现。
• LLM/Agent：所有输入输出都要有结构，模型结果要校验，高风险动作要有人类审查点。

4. 常见坑和边界

• 本地 SQLite 适合保存实验结果。
• 表名和字段名要稳定。
• 复杂查询先拆成可读步骤。
• 不要把所有逻辑堆进一个文件或一个函数。先拆出最小核心函数，再决定是否需要 CLI、API、看板或测试。
• 不要用“能跑一次”代表掌握。真正掌握是换一份输入、换一个场景、换一个主题后仍然能迁移。

5. 最小迁移代码模块边界

def day031_engineering_note(input_data):
    """记录今天知识点在工程主题里的使用边界。"""
    return {
        "day": "Day31",
        "topic": "SQLite 本地数据库",
        "input_shape": "明确输入来源、字段、类型和边界",
        "core_step": "把今天主题压缩成一个可测试的小函数",
        "output_shape": "明确输出给终端、文件、API、报告还是下游函数",
        "failure_modes": ["空输入", "类型不对", "缺字段", "路径或网络失败"],
        "reuse_target": "数据分析 / Quant / LLM-Agent / 能力清单主题",
    }

6. 百科式自查问题

1. 这个主题的输入是什么？输入可能为空、缺字段、类型错误吗？

2. 核心处理步骤能不能写成一个小函数？

3. 输出是给人看，还是给下游程序继续用？

4. 失败时怎么记录？是 print、logging、错误报告，还是测试失败？

5. 如果迁移到 Quant / LLM / Agent 主题，最大的风险是什么？

6. 这个能力是否需要 说明文档、样例数据或测试来长期保存？

7. 建议扩展练习

• 写一个最小正常样例。
• 写一个边界样例，例如空输入、缺字段、类型错误、路径不存在。
• 写一段 Debug 记录，说明错误现象、定位过程和修复方式。
• 把今天的代码改造成一个函数，并说明输入和输出。
• 思考它未来会放进哪个主题模块：data_io、transform、analysis、api、app、agent_tool、backtest 或 report。

2 小时学习节奏

• 15 分钟：读定位、前置和知识地图。
• 25 分钟：手打最小案例并运行。
• 35 分钟：完成 7 道简单路线题。
• 35 分钟：完成 5 道基础巩固题。
• 10 分钟：记录 Debug、结果和下一步。

简单路线 7 题

1. 读完“学习定位”，用一句话写下今天要解决的问题。

2. 手打最小案例并运行，确认得到 一个 research.db。

3. 把示例输入改成 2-3 条虚拟样例，观察输出是否仍然合理。

4. 故意制造一个小错误，记录报错、原因和修复方式。

5. 给输出加一个清晰字段名或标题，避免只看到裸数字。

6. 把今天代码保存到本地练习文件夹，并写下运行命令。

7. 用 3 行话说明它如何服务于 可查询结果仓库和 Agent 数据源。

今日强化题（带具体代码）

> 每天正文上限控制在 600 行以内。强化题不是口头描述，必须能落到 main.py 运行。

强化题 1：复现最小案例

任务：把下面参考代码复制到 main.py，先不要改，直接运行。

验收：终端能打印 JSON，且本地生成 outputs/day031/。

强化题 2：替换输入

任务：只改输入数据，至少新增 2 条样例。

验收：输出数量、均值、跳过记录或检索结果发生合理变化。

强化题 3：边界检查

任务：制造 1 个坏输入，例如空值、重复值、非法字段或极端价格。

验收：程序不会静默失败；你能在输出或 errors.md 里解释原因。

强化题 4：结果保存

任务：把运行结果保存到 JSON、CSV、Markdown 或 SQLite 中的一种。

验收：关闭终端后，仍能从文件复查今天结果。

强化题 5：迁移说明

任务：写 3 句话说明 SQLite 本地数据库 会如何迁移到 Data、Quant、LLM 或 Agent。

验收：不是写“以后有用”，而是写清具体场景。

参考代码：main.py

from pathlib import Path
import sqlite3
import json

TOPIC = 'SQLite 本地数据库'
DAY = 31
ROOT = Path(__file__).resolve().parent
OUT = ROOT / "outputs" / f"day{DAY:03d}"
DB = OUT / "learning.db"


def ensure_dirs():
    OUT.mkdir(parents=True, exist_ok=True)


def setup_db():
    conn = sqlite3.connect(DB)
    conn.execute("drop table if exists study_log")
    conn.execute("create table study_log(day int, topic text, minutes int)")
    conn.executemany(
        "insert into study_log values (?, ?, ?)",
        [(31, "sqlite", 40), (32, "sql join", 50), (33, "config", 20)],
    )
    conn.commit()
    return conn


def query_summary(conn):
    rows = conn.execute(
        "select count(*) as n, sum(minutes) as total_minutes from study_log"
    ).fetchone()
    top = conn.execute(
        "select topic, minutes from study_log order by minutes desc limit 1"
    ).fetchone()
    return {"topic": TOPIC, "rows": rows[0], "total_minutes": rows[1], "top_topic": top[0]}


def main():
    ensure_dirs()
    conn = setup_db()
    summary = query_summary(conn)
    conn.close()
    (OUT / "summary.json").write_text(json.dumps(summary, ensure_ascii=False, indent=2), encoding="utf-8")
    print(json.dumps(summary, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

运行命令

python main.py

Debug 记录要求

错误现象：
触发输入：
定位过程：
修复方式：
以后如何避免：

Debug 记录模板

错误现象：
触发输入：
定位过程：
修复方式：
以后如何避免：

复习检查

• [ ] 我能解释今天能力的输入、处理和输出。
• [ ] 我能从零手打最小案例。
• [ ] 我完成了今日强化题，并运行了 main.py 参考代码。
• [ ] 我把结果保存成可复查产物。

参考资料

• sqlite3 文档

Day32 - SQL 查询、Join 与窗口意识

> 阶段三：数据分析与本地数据系统

学习定位

用 SQL 回答分析问题。

今天的目标不是背定义，而是产出：一个聚合查询和一个 join 查询。

前置知识

• 推荐前置：Day31 SQLite
• 上一站：Day31
• 下一站：Day33

今日知识地图

• SELECT
• WHERE
• GROUP BY
• ORDER BY
• JOIN

真实任务入口

今天先不从定义开始，而是先看问题：如何用「SQL 查询、Join 与窗口意识」完成 一个聚合查询和一个 join 查询？

这个问题在工程里不是孤立练习。它属于 数据分析与本地数据系统 阶段，目标是：把原始数据变成可检查、可保存、可复盘的数据资产。

先按这条顺序学习：

真实任务
  ↓
拆解流程
  ↓
引出问题
  ↓
引出知识点
  ↓
解释设计原因
  ↓
代码实现
  ↓
未来使用

今天你真正要掌握的不是“会背哪个语法”，而是能回答：它解决什么问题、为什么需要它、怎么落到代码、以后在哪个主题会再次出现。

工程问题解决结构

1. 是什么（What）

SQL 查询、Join 与窗口意识 是用 Python 解决工程任务时的一组小工具。最简定义：它帮助你把「SELECT、WHERE、GROUP BY」放进可运行流程里。先把它当成解决问题的方法，不要先背术语。

2. 为什么存在（Why）

如果没有 SQL 查询、Join 与窗口意识，代码通常会变成一次性脚本：逻辑散、结果难复查、报错难定位、以后练习里也难复用。它存在的意义是把真实任务拆成更清楚的步骤，让你知道哪里输入、哪里处理、哪里输出。

3. 真实工程场景（Real Scenario）

• 科研场景：读取实验数据，检查字段、缺失值和样本量，生成 Markdown 记录。
• 数据分析场景：清洗业务数据，计算指标，保存 CSV、SQLite 或报告。
• Quant 场景：读取行情样例，计算收益率、移动平均、分组指标或风险统计。
• LLM/Agent 场景：把数据检查步骤封装成 tool，让 Agent 调用后返回结构化结果。

4. 怎么做（How）

先看场景流程，再看代码：

原始数据
  ↓
字段检查
  ↓
清洗/计算
  ↓
边界检查
  ↓
保存结果
  ↓
写分析说明

from pathlib import Path

# Day32 - SQL 查询、Join 与窗口意识
raw_rows = [{"name": "sample", "value": 1}]

processed = []
for row in raw_rows:
    if "value" not in row:
        continue
    processed.append({"name": row["name"], "value": row["value"]})

Path("outputs").mkdir(exist_ok=True)
Path("outputs/day32_result.txt").write_text(str(processed), encoding="utf-8")
print(processed)

5. 工程设计思维（Design）

工程师会多写一层函数、配置、输出文件或 说明文档，是为了让代码不只今天能跑，也能被明天的自己、未来的自己和未来主题继续使用。

6. Future Usage（未来使用）

这个知识点以后会反复出现在：

• 数据分析报告
• SQLite 本地数据系统
• Quant 指标管道
• Agent 数据检查工具
• 数据处理脚本

7. 掌握检查

学完今天不要只问“代码跑了吗”，要能回答四个问题：

1. 它是什么？

2. 它为什么存在？

3. 它解决什么问题？

4. 它在未来 Quant / LLM / Agent 主题中怎么使用？

基础优化补充：问题、场景与代码

阶段定位：数据分析与本地数据系统。

解决什么问题（Problem）：SQL 查询、Join 与窗口意识 的核心不是背概念，而是把原始数据变成可以检查、清洗、计算、保存和复盘的数据资产。

真实科研场景：整理实验数据、论文元数据和指标结果，让每一步处理都有输入、输出和检查记录。

数据分析场景：读取 CSV/Excel/SQLite 数据，完成字段检查、清洗、聚合、统计和报告输出。

Quant 场景：处理行情、收益率、指标和时间序列，形成后续回测或研究报告的基础数据层。

LLM/Agent 场景：为 LLM/RAG 提供干净、结构化、可引用的数据和本地知识材料。

def build_day032_note(input_name, output_name, risk):
    return {
        "day": "Day32",
        "topic": "SQL 查询、Join 与窗口意识",
        "input": input_name,
        "output": output_name,
        "risk": risk,
        "next_check": "确认输入、处理步骤、输出和失败点是否清楚",
    }

工程工作流补充

如果你完全看不懂，先只抓这一句话

今天学的是：SQL 查询、Join 与窗口意识。它不只是一个孤立知识点，而是服务于「数据分析与本地数据系统」阶段的一个小能力：把原始数据变成可以检查、保存、复盘的数据资产。

先按这条工程线理解：

读取数据 -> 检查字段 -> 清洗/计算 -> 保存结果 -> 写报告

你不需要一开始把所有细节背下来。先回答五个问题：

1. 今天的输入是什么？

2. 中间处理分几步？

3. 输出保存在哪里？

4. 失败时会在哪一步失败？

5. 这个能力以后能放进哪个主题？

真实工作流怎么想

把今天的主题放进一个真实主题里，它通常不是单独出现的。比如做一个 AI/data/quant 小工具时，你会经历：

执行过程追踪

读今天代码时，不要只看语法，要追踪数据怎么走：

输入
  ↓
核心处理
  ↓
中间结果
  ↓
边界检查
  ↓
最终输出

当前最应该检查：字段名、数据类型、空值、重复、样例输出。

最容易混的点

工业化知识百科补充：从会用到会迁移

这一节不是把前面没学完的语法硬塞回来，而是把 SQL 查询、Join 与窗口意识 放进后续 IC 挑战里补厚。你现在已经进入 Day10 之后，学习重点要从“我知道这个语法”升级为“我知道它在工程里解决什么问题、会踩什么坑、怎么迁移到 IC”。

1. 阶段定位

当前阶段：数据分析与本地数据系统。

阶段目标：把原始数据变成结构清楚、指标可信、结果可复查的数据资产。

本阶段反复出现的能力：

• 数据体检
• 类型转换
• 缺失值处理
• 聚合统计
• 时间窗口
• SQL 与本地数据库

2. 这个主题必须补齐的知识面

• 表结构
• 主键
• 索引
• join
• 窗口函数
• 事务
• 查询复用

学习时不要把这些点当成孤立词条。更好的读法是：每个概念都对应一种工程压力，例如输入变多、数据变脏、文件变大、结果要复现、输出要交给别人、模型回答需要校验。

3. 真实主题里怎么用

• 数据分析：先明确字段、类型、缺失值、样本范围，再写处理逻辑。不要直接对未知数据写复杂代码。
• Quant：任何计算都要关心时间顺序、样本区间、交易成本、未来函数和结果复现。
• LLM/Agent：所有输入输出都要有结构，模型结果要校验，高风险动作要有人类审查点。

4. 常见坑和边界

• 本地 SQLite 适合保存实验结果。
• 表名和字段名要稳定。
• 复杂查询先拆成可读步骤。
• 不要把所有逻辑堆进一个文件或一个函数。先拆出最小核心函数，再决定是否需要 CLI、API、看板或测试。
• 不要用“能跑一次”代表掌握。真正掌握是换一份输入、换一个场景、换一个主题后仍然能迁移。

5. 最小迁移代码模块边界

def day032_engineering_note(input_data):
    """记录今天知识点在工程主题里的使用边界。"""
    return {
        "day": "Day32",
        "topic": "SQL 查询、Join 与窗口意识",
        "input_shape": "明确输入来源、字段、类型和边界",
        "core_step": "把今天主题压缩成一个可测试的小函数",
        "output_shape": "明确输出给终端、文件、API、报告还是下游函数",
        "failure_modes": ["空输入", "类型不对", "缺字段", "路径或网络失败"],
        "reuse_target": "数据分析 / Quant / LLM-Agent / 能力清单主题",
    }

6. 百科式自查问题

1. 这个主题的输入是什么？输入可能为空、缺字段、类型错误吗？

2. 核心处理步骤能不能写成一个小函数？

3. 输出是给人看，还是给下游程序继续用？

4. 失败时怎么记录？是 print、logging、错误报告，还是测试失败？

5. 如果迁移到 Quant / LLM / Agent 主题，最大的风险是什么？

6. 这个能力是否需要 说明文档、样例数据或测试来长期保存？

7. 建议扩展练习

• 写一个最小正常样例。
• 写一个边界样例，例如空输入、缺字段、类型错误、路径不存在。
• 写一段 Debug 记录，说明错误现象、定位过程和修复方式。
• 把今天的代码改造成一个函数，并说明输入和输出。
• 思考它未来会放进哪个主题模块：data_io、transform、analysis、api、app、agent_tool、backtest 或 report。

2 小时学习节奏

• 15 分钟：读定位、前置和知识地图。
• 25 分钟：手打最小案例并运行。
• 35 分钟：完成 7 道简单路线题。
• 35 分钟：完成 5 道基础巩固题。
• 10 分钟：记录 Debug、结果和下一步。

简单路线 7 题

1. 读完“学习定位”，用一句话写下今天要解决的问题。

2. 手打最小案例并运行，确认得到 一个聚合查询和一个 join 查询。

3. 把示例输入改成 2-3 条虚拟样例，观察输出是否仍然合理。

4. 故意制造一个小错误，记录报错、原因和修复方式。

5. 给输出加一个清晰字段名或标题，避免只看到裸数字。

6. 把今天代码保存到本地练习文件夹，并写下运行命令。

7. 用 3 行话说明它如何服务于 数据分析岗位和本地分析系统。

今日强化题（带具体代码）

> 每天正文上限控制在 600 行以内。强化题不是口头描述，必须能落到 main.py 运行。

强化题 1：复现最小案例

任务：把下面参考代码复制到 main.py，先不要改，直接运行。

验收：终端能打印 JSON，且本地生成 outputs/day032/。

强化题 2：替换输入

任务：只改输入数据，至少新增 2 条样例。

验收：输出数量、均值、跳过记录或检索结果发生合理变化。

强化题 3：边界检查

任务：制造 1 个坏输入，例如空值、重复值、非法字段或极端价格。

验收：程序不会静默失败；你能在输出或 errors.md 里解释原因。

强化题 4：结果保存

任务：把运行结果保存到 JSON、CSV、Markdown 或 SQLite 中的一种。

验收：关闭终端后，仍能从文件复查今天结果。

强化题 5：迁移说明

任务：写 3 句话说明 SQL 查询、Join 与窗口意识 会如何迁移到 Data、Quant、LLM 或 Agent。

验收：不是写“以后有用”，而是写清具体场景。

参考代码：main.py

from pathlib import Path
import sqlite3
import json

TOPIC = 'SQL 查询、Join 与窗口意识'
DAY = 32
ROOT = Path(__file__).resolve().parent
OUT = ROOT / "outputs" / f"day{DAY:03d}"
DB = OUT / "learning.db"


def ensure_dirs():
    OUT.mkdir(parents=True, exist_ok=True)


def setup_db():
    conn = sqlite3.connect(DB)
    conn.execute("drop table if exists study_log")
    conn.execute("create table study_log(day int, topic text, minutes int)")
    conn.executemany(
        "insert into study_log values (?, ?, ?)",
        [(31, "sqlite", 40), (32, "sql join", 50), (33, "config", 20)],
    )
    conn.commit()
    return conn


def query_summary(conn):
    rows = conn.execute(
        "select count(*) as n, sum(minutes) as total_minutes from study_log"
    ).fetchone()
    top = conn.execute(
        "select topic, minutes from study_log order by minutes desc limit 1"
    ).fetchone()
    return {"topic": TOPIC, "rows": rows[0], "total_minutes": rows[1], "top_topic": top[0]}


def main():
    ensure_dirs()
    conn = setup_db()
    summary = query_summary(conn)
    conn.close()
    (OUT / "summary.json").write_text(json.dumps(summary, ensure_ascii=False, indent=2), encoding="utf-8")
    print(json.dumps(summary, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

运行命令

python main.py

Debug 记录要求

错误现象：
触发输入：
定位过程：
修复方式：
以后如何避免：

Debug 记录模板

错误现象：
触发输入：
定位过程：
修复方式：
以后如何避免：

复习检查

• [ ] 我能解释今天能力的输入、处理和输出。
• [ ] 我能从零手打最小案例。
• [ ] 我完成了今日强化题，并运行了 main.py 参考代码。
• [ ] 我把结果保存成可复查产物。

参考资料

• Python 官方文档

Day33 - 配置文件与环境变量

> 阶段三：数据分析与本地数据系统

学习定位

把路径、参数和模式从代码里拿出来。

今天的目标不是背定义，而是产出：一个 config.json 和环境变量读取。

前置知识

• 推荐前置：Day32 SQL
• 上一站：Day32
• 下一站：Day34

今日知识地图

• json config
• os.environ
• 默认值
• 配置隔离

真实任务入口

今天先不从定义开始，而是先看问题：如何用「配置文件与环境变量」完成 一个 config.json 和环境变量读取？

这个问题在工程里不是孤立练习。它属于 数据分析与本地数据系统 阶段，目标是：把原始数据变成可检查、可保存、可复盘的数据资产。

先按这条顺序学习：

真实任务
  ↓
拆解流程
  ↓
引出问题
  ↓
引出知识点
  ↓
解释设计原因
  ↓
代码实现
  ↓
未来使用

今天你真正要掌握的不是“会背哪个语法”，而是能回答：它解决什么问题、为什么需要它、怎么落到代码、以后在哪个主题会再次出现。

工程问题解决结构

1. 是什么（What）

配置文件与环境变量 是用 Python 解决工程任务时的一组小工具。最简定义：它帮助你把「json config、os.environ、默认值」放进可运行流程里。先把它当成解决问题的方法，不要先背术语。

2. 为什么存在（Why）

如果没有 配置文件与环境变量，代码通常会变成一次性脚本：逻辑散、结果难复查、报错难定位、以后练习里也难复用。它存在的意义是把真实任务拆成更清楚的步骤，让你知道哪里输入、哪里处理、哪里输出。

3. 真实工程场景（Real Scenario）

• 科研场景：读取实验数据，检查字段、缺失值和样本量，生成 Markdown 记录。
• 数据分析场景：清洗业务数据，计算指标，保存 CSV、SQLite 或报告。
• Quant 场景：读取行情样例，计算收益率、移动平均、分组指标或风险统计。
• LLM/Agent 场景：把数据检查步骤封装成 tool，让 Agent 调用后返回结构化结果。

4. 怎么做（How）

先看场景流程，再看代码：

原始数据
  ↓
字段检查
  ↓
清洗/计算
  ↓
边界检查
  ↓
保存结果
  ↓
写分析说明

from pathlib import Path

# Day33 - 配置文件与环境变量
raw_rows = [{"name": "sample", "value": 1}]

processed = []
for row in raw_rows:
    if "value" not in row:
        continue
    processed.append({"name": row["name"], "value": row["value"]})

Path("outputs").mkdir(exist_ok=True)
Path("outputs/day33_result.txt").write_text(str(processed), encoding="utf-8")
print(processed)

5. 工程设计思维（Design）

工程师喜欢用 Path 和明确的输入输出路径，是为了减少字符串拼接错误，并让脚本从 Mac 终端、主题根目录、定时任务里运行时更稳定。

6. Future Usage（未来使用）

这个知识点以后会反复出现在：

• 数据分析报告
• SQLite 本地数据系统
• Quant 指标管道
• Agent 数据检查工具
• 数据处理脚本

7. 掌握检查

学完今天不要只问“代码跑了吗”，要能回答四个问题：

1. 它是什么？

2. 它为什么存在？

3. 它解决什么问题？

4. 它在未来 Quant / LLM / Agent 主题中怎么使用？

基础优化补充：问题、场景与代码

阶段定位：数据分析与本地数据系统。

解决什么问题（Problem）：配置文件与环境变量 的核心不是背概念，而是把原始数据变成可以检查、清洗、计算、保存和复盘的数据资产。

真实科研场景：整理实验数据、论文元数据和指标结果，让每一步处理都有输入、输出和检查记录。

数据分析场景：读取 CSV/Excel/SQLite 数据，完成字段检查、清洗、聚合、统计和报告输出。

Quant 场景：处理行情、收益率、指标和时间序列，形成后续回测或研究报告的基础数据层。

LLM/Agent 场景：为 LLM/RAG 提供干净、结构化、可引用的数据和本地知识材料。

def build_day033_note(input_name, output_name, risk):
    return {
        "day": "Day33",
        "topic": "配置文件与环境变量",
        "input": input_name,
        "output": output_name,
        "risk": risk,
        "next_check": "确认输入、处理步骤、输出和失败点是否清楚",
    }

工程工作流补充

如果你完全看不懂，先只抓这一句话

今天学的是：配置文件与环境变量。它不只是一个孤立知识点，而是服务于「数据分析与本地数据系统」阶段的一个小能力：把原始数据变成可以检查、保存、复盘的数据资产。

先按这条工程线理解：

读取数据 -> 检查字段 -> 清洗/计算 -> 保存结果 -> 写报告

你不需要一开始把所有细节背下来。先回答五个问题：

1. 今天的输入是什么？

2. 中间处理分几步？

3. 输出保存在哪里？

4. 失败时会在哪一步失败？

5. 这个能力以后能放进哪个主题？

真实工作流怎么想

把今天的主题放进一个真实主题里，它通常不是单独出现的。比如做一个 AI/data/quant 小工具时，你会经历：

执行过程追踪

读今天代码时，不要只看语法，要追踪数据怎么走：

输入
  ↓
核心处理
  ↓
中间结果
  ↓
边界检查
  ↓
最终输出

当前最应该检查：字段名、数据类型、空值、重复、样例输出。

最容易混的点

工业化知识百科补充：从会用到会迁移

这一节不是把前面没学完的语法硬塞回来，而是把 配置文件与环境变量 放进后续 IC 挑战里补厚。你现在已经进入 Day10 之后，学习重点要从“我知道这个语法”升级为“我知道它在工程里解决什么问题、会踩什么坑、怎么迁移到 IC”。

1. 阶段定位

当前阶段：数据分析与本地数据系统。

阶段目标：把原始数据变成结构清楚、指标可信、结果可复查的数据资产。

本阶段反复出现的能力：

• 数据体检
• 类型转换
• 缺失值处理
• 聚合统计
• 时间窗口
• SQL 与本地数据库

2. 这个主题必须补齐的知识面

• 类型提示
• 运行时校验
• 配置默认值
• 环境变量
• 路径配置
• 输入边界

学习时不要把这些点当成孤立词条。更好的读法是：每个概念都对应一种工程压力，例如输入变多、数据变脏、文件变大、结果要复现、输出要交给别人、模型回答需要校验。

3. 真实主题里怎么用