你有没有想过，给自己的电脑装一个「像素小人」陪你聊天？

前一阵子我一直在捣鼓一个叫 ChenXiaoxue 的项目——一个像素复古风 + AI 情感互动的桌面/Web 助手。做它的初衷其实很朴素：一个是想要一个能记住上下文、带点情绪反馈的 AI 陪伴，另一个就是想做个足够「有意思」的个人项目，把自己学过的前端、后端、桌面三块东西串起来练练手。

今天想跟你聊聊它从「单机像素小玩具」长成「三层全栈现代架构」的过程，中间踩了不少坑，也攒了不少经验。文章尽量写得实在，希望对你有点启发。

一、第一代：PyQt5 单机像素应用

故事的开头是 chenxiaoxue-orgin——一个 Python 3.7+ / PyQt5 的单机桌面应用。那时候的想法很简单：一个窗口，一个像素角色，一个输入框，连上 DeepSeek 的 API 就能对话。

它虽然「轻」，但五脏俱全：

• 像素主题：深蓝 #1a1a2e + 橙 #ff9d00 的配色，搭配 Press Start 2P / Zpix 像素字体，一眼就是复古游戏的味道。
• EnhancedResponseSystem 完整链路：分词 → 意图 → 情感 → API → 响应 → 上下文，一条链路走下来，还带缓存和 3 次重试。
• 情感驱动的表情与音效：聊到高兴时，小人的表情和音效会跟着变。
• 角色眨眼动画、打字机输出、心电图状态栏：这些小细节让「陪伴感」一下子就出来了。
• 梦境符号解析：飞翔、坠落、水、火、蛇、追逐、考试、牙齿……它会帮你解析梦境里的意象。
• 插件系统：基于 PluginBase + plugins.json，可插拔。
• 消息导出：支持 JSON / TXT / CSV，方便把对话存档。
• 中英日 i18n、「灵动 / 迟缓」两种输出模式。

第一代用的技术栈：PyQt5 / requests / jieba / snownlp / lxml，SQLite 存对话历史。说实话，单模型（DeepSeek）对话 + 本地情感分析，已经能跑出一个很完整的「像素陪伴」体验了。

仓库就在：https://gitee.com/yohotens/chenxiaoxue-orgin

二、第二代：全面重写，重写不丢初心

单机版玩熟了之后，我开始不满足于「只能在自己电脑上跑」这个限制。2025.08 我启动了迁移，把它重写成了 chenxiaoxue-reborn-reborn——一套前后端分离 + 桌面壳的现代架构：

• 后端：FastAPI 0.115 + Uvicorn + SQLAlchemy 2.0 + aiosqlite + JWT(bcrypt) + slowapi 限流 + loguru + alembic
• 前端：React 18 + TypeScript + Vite 4 + Three.js
• 桌面壳：Tauri 2（Rust）

三层技术栈（Python / TypeScript / Rust），一套代码同时覆盖 Web 和桌面。整体代码量大概 ~11000 行：后端 Python ~5000+、前端 TS/React ~3000+、Rust ~500+、测试 ~500+、文档 ~2000+，26+ 个 API 端点，12+ 个功能模块。

关键是——重写不丢初心。像素主题一脉相承：GIF 背景、打字机输出、ASCII 艺术、CRT 扫描线、毛玻璃效果，全都保留并且升级了。并且注册购买了域名：chenxiaoxue.space，未来会运载在服务器中并挂载在此网址。

仓库在这里：https://gitee.com/yohoten_space/chenxiaoxue-reborn

三、核心功能亮点

重写版功能一下子丰富了很多，挑几个我觉得最有意思的展开说说：

1. 多模型智能路由

ai_router.py 是后端最核心的模块之一。它集成了 DeepSeek / OpenAI / 通义 / 豆包 / Kimi / Claude 等多家供应商，会根据「任务类型 + 复杂度 + 成本」自动选型，支持流式 SSE，还有故障转移——某个供应商挂了，自动切到下一个可用的。

成本控制靠的是 model_pricing.json 这份计价表，比如 deepseek-chat 约 $0.008/1k tokens，gpt-4o 约 $2.5/1k tokens。路由时把价格拉进来算一笔账，简单的日常聊天就不会动不动砸到贵模型上。

2. 模型协作 collaborative_chat

单模型不够，那就多模型协作：任务分解 → 多模型并行 → 结果聚合。一个复杂问题拆成几块，分别交给不同的模型处理，最后汇总成一份答案。这也是现代 Agent 玩法里很经典的一种思路。

3. MCP 协议

重写版接入了 MCP（Model Context Protocol），暴露了 chat_completion、analyze_emotion、translate、get_models、collaborative_chat 等一批工具，并且支持接入外部 MCP 服务器。这意味着chenxiaoxue的能力可以像插头一样往外扩展，生态一下就打开了。

4. 情感分析：SnowNLP + AI 双模式

emotion_service 实现了混合情感分析，有 auto / rule / ai 三种模式：少于 20 个字走规则，否则交给 AI；AI 失败时自动降级回规则。底层还用 SnowNLP 做了阈值分段：

• > 0.8 → ecstatic（狂喜）
• > 0.6 → happy（开心）
• > 0.5 → content（满足）
• ≥ 0.4 → neutral（平静）
• ≥ 0.2 → sad（低落）
• 否则 → sad

一共 9 种情感，每种都有对应的 Emoji 映射（比如 ecstatic 对应 😊✨🎉，angry 对应 😠）。情感分析结果直接驱动小人表情、音效和 ECG 心电图，让「陪伴」不是冷冰冰的文字。

5. 像素主题 UI

这是我最舍不得的部分。GIF 动态背景、打字机逐字输出、ASCII 艺术、CRT 扫描线、毛玻璃卡片——一套下来，整个界面就像一台复古掌机。前端是 React 18 + TS + Vite 4 搭的，主题完全围绕「像素 + 复古」这一个核心设计语言展开。

6. Humanizer AI 检测器

一个很有意思的小工具：内置 24 种 AI 写作模式，能对一段文字打分（0-100%），判断它「像不像 AI 写的」。写东西多了之后，真的很需要这样一面镜子来提醒自己「这段是不是又 AI 味太重了」。

7. ECG 情感心电图

Canvas 画出来的心电图，P/QRS/T 波齐全，颜色和心率会跟着情感状态变化。开心的时候心电图「扑通扑通」跳得欢快，低落的时候慢慢悠悠——把这个做成状态栏，我觉得是整台机器最有灵性的地方。

8. 三级自我进化记忆

self_improving 模块做了一套分层的长期记忆：

• HOT：memory.md，≤100 行，记最近的对话状态；
• WARM：projects / domains，≤200 行，记项目相关的长期信息；
• COLD：归档，存更久远的内容。

它会识别「纠正」和「偏好」信号，自动沉淀成 CONTEXT / REFLECTION / LESSON 三种记忆条目。用着用着，它真的会越来越「懂你」。

顺带一提，还有 梦境解析 + Three.js 星图、JWT 多用户（Access 7 天 / Refresh 30 天）、插件系统 等一票功能，限于篇幅就不一一展开了。

四、技术与工程细节

作为工程人，再补几个「幕后」的细节：

• launcher.bat v2.2：setup / dev / backend / frontend / tauri / test / prod 七种模式一个脚本全搞定。自己一个人开发前后端 + 桌面，启动器好不好用直接决定幸福指数。
• JWT 双 Token：Access 7 天 + Refresh 30 天，登录态既安全又省心。
• 限流 + 日志：slowapi 做接口限流，loguru 管日志，alembic 管数据库迁移——该有的基建一个没落下。
• 多语言前端：重写版继续保留了多语言支持，国际化一直是这个项目的保留节目。

五、踩过的坑与感悟

写代码嘛，哪有不踩坑的。几个真实教训分享给你：

1. API Key 明文暴露过。 第一代项目的 config.ini 和 README 里，曾直接把 DeepSeek API Key 明文写了出来。虽然是个人项目，但这也是非常不安全的坏习惯。重写版全部改成了 .env 环境变量，密钥绝不进仓库。血的教训：密钥永远不要硬编码进代码或文档。
2. 单文件过大。 第一代 chat_window.py 有 2539 行，重写版的 ai_router.py 也有 1240 行。功能堆着堆着文件就失控了。现在回头看，早期就应该更早拆模块、抽服务。
3. 命名不一致。 项目名一会儿「陈筱雪」一会儿「Chen筱雪」一会儿「ChenXiaoxue」，甚至仓库名 chenxiaoxue-orgin 里的 orgin 还是个拼写笔误（应该是 origin）。正式项目开工前，先定好统一的命名规范，包括仓库名，不然后面到处都是坑。
4. 重写要有理由，也要有底线。 全面重写容易上头，但一定要想清楚「保留什么、抛弃什么」。我这次坚持把「像素主题」这条灵魂主线一路带下来，重写才没有变成「重做」。

对了，我的本机开发路径是 d:/pixel_ai_assistant-250907/Chen Xiaoxue/，项目一路从像素小玩具长到现在，也算有点感情了（笑）。

六、结尾

chenxiaoxue这个项目，是我把前端、后端、桌面三块能力真正「合体」的一次尝试。第一代让我理解了「一个完整的 AI 应用」长什么样，第二代让我学会了「如何把一套个人玩具做成正经的多层架构」。如果你也喜欢像素风，或者对「AI 情感陪伴」「全栈 + Tauri 桌面」感兴趣，欢迎来仓库逛逛、提提 issue。

项目仓库：

• 第一代：https://github.com/yohoten/chenxiaoxue-orgin / https://gitee.com/yohotens/chenxiaoxue-orgin
• 第二代：https://github.com/yohoten/chenxiaoxue-reborn / https://gitee.com/yohoten_space/chenxiaoxue-reborn

相关阅读：

• 知乎问答：https://www.zhihu.com/question/15175936725/answer/1944403822710596747
• 知乎专栏：https://zhuanlan.zhihu.com/p/1961952610673226156

未来我还想给它加更多的东西：更聪明的记忆策略、更丰富的像素场景、更顺滑的桌面体验……不过这些都慢慢来。如果你也有类似的「像素 + AI」想法，欢迎来找我交流～

路还长，我们继续写下去。

MNIST 数据集包含 70000 张手写数字的灰度图像，分为以下两部分：

• 训练集：60,000 张图像
• 测试集：10,000 张图像

其中，每张图像是 28×28 像素，表示一个手写的数字（0 到 9），即每张图像有 784（28×28）个像素点，每个像素的值是一个从 0 到 255 的灰度值。

MNIST 数据集有四个文件（下载时是 .gz 压缩包格式，约 11M，会自动解压缩）：

• train-images-idx3-ubyte（训练集图像）
• train-labels-idx1-ubyte（训练集标签）
• t10k-images-idx3-ubyte（测试集图像）
• t10k-labels-idx1-ubyte（测试集标签）

二、下载数据集与查看图片

下载 MNIST 数据集和查看图片的 Python 代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

"""
This code is supported by the website: https://www.guanjihuan.com
The newest version of this code is on the web page: https://www.guanjihuan.com/archives/43720
"""

from torchvision import datasets, transforms

transform = transforms.Compose([transforms.ToTensor()]) # 定义数据预处理步骤（转换为Tensor）
train_dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transform) # 加载 MNIST 数据集，训练集
print(type(train_dataset))
size_of_train_dataset = len(train_dataset)
print(size_of_train_dataset)
test_dataset = datasets.MNIST(root='./data', train=False, download=True, transform=transform) # 加载 MNIST 数据集，测试集
print(type(test_dataset))
size_of_test_dataset = len(test_dataset)
print(size_of_test_dataset)

import random
rand_number = random.randint(0, size_of_train_dataset-1)
image, label = train_dataset[rand_number] # 获取一张图像和标签
print(type(image))
print(image.shape)
image = image.squeeze(0)  # 去掉单通道的维度 (1, 28, 28) -> (28, 28)
print(type(image))
print(image.shape)

import matplotlib.pyplot as plt
# import os
# os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE" # 解决可能的多个 OpenMP 库版本冲突的问题。如果有 OMP 报错，可以试着使用这个解决。
plt.imshow(image, cmap='gray') # 显示图像
plt.title(f"Label: {label}")  # 标签值（理论值）
plt.axis('off')  # 不显示坐标轴
plt.show()

某次的运行结果为：

三、用神经网络训练

以下是使用神经网络进行训练的 Python 代码。这里对模型进行了包装，需要用到软件包 https://py.guanjihuan.com（pip install --upgrade guan）。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

"""
This code is supported by the website: https://www.guanjihuan.com
The newest version of this code is on the web page: https://www.guanjihuan.com/archives/43720
"""

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset
from torchvision import datasets, transforms

transform = transforms.Compose([transforms.ToTensor(),transforms.Normalize((0.5,), (0.5,))])  # 数据转换（将图片转换为 Tensor 并进行归一化处理，均值和标准差为 0.5）
train_dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transform) # 下载训练数据集
test_dataset = datasets.MNIST(root='./data', train=False, download=True, transform=transform) # 下载测试数据集

# 训练函数
def train(model, train_loader, criterion, optimizer, num_epochs=5):
    for epoch in range(num_epochs):
        model.train()
        running_loss = 0.0
        correct = 0
        total = 0
        for images, labels in train_loader:
            # print(images.shape)
            optimizer.zero_grad()  # 清除以前的梯度
            outputs = model(images) # 前向传播
            loss = criterion(outputs, labels)
            loss.backward() # 反向传播和优化
            optimizer.step()
            running_loss += loss.item()
            _, predicted = torch.max(outputs, 1) # 计算准确率
            total += labels.size(0)
            correct += (predicted == labels).sum().item()
        avg_loss = running_loss / len(train_loader)
        accuracy = 100 * correct / total
        print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {avg_loss:.4f}, Accuracy: {accuracy:.2f}%')

# 测试函数
def test(model, test_loader):
    model.eval()  # 设置为评估模式
    correct = 0
    total = 0
    with torch.no_grad():  # 禁用梯度计算
        for images, labels in test_loader:
            outputs = model(images)
            _, predicted = torch.max(outputs, 1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()
    accuracy = 100 * correct / total
    print(f'Test Accuracy: {accuracy:.2f}%')

# 训练和测试
def train_and_test(model, train_loader, test_loader):
    criterion = nn.CrossEntropyLoss()  # 交叉熵损失
    optimizer = optim.Adam(model.parameters(), lr=0.001)
    train(model, train_loader, criterion, optimizer, num_epochs=10)
    test(model, test_loader)

# 扁平化数据，并重建 DataLoader（用于全连接神经网络输入端的数据处理）
def flatten_data(data_loader):
    images_array = []
    labels_array = []
    for images, labels in data_loader:
        images = torch.flatten(images, start_dim=1) # 除去batch维度后，其他维度展平
        images_array.append(images)
        labels_array.append(labels)
    images_array = torch.cat(images_array, dim=0)
    labels_array = torch.cat(labels_array, dim=0)
    dataset_new = TensorDataset(images_array, labels_array)
    loader_new = DataLoader(dataset_new, batch_size=64, shuffle=True)
    return loader_new

# 数据加载器
train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False)

# 扁平化数据
train_loader_new = flatten_data(train_loader)
test_loader_new = flatten_data(test_loader)

# 安装软件包：pip install --upgrade guan
import guan

hidden_size = 64

print('---全连接神经网络模型（包含一个隐藏层）---')
model = guan.fully_connected_neural_network_with_one_hidden_layer(input_size=28*28, hidden_size=hidden_size, output_size=10, activation='relu')
train_and_test(model, train_loader_new, test_loader_new)

print('---全连接神经网络模型（包含两个隐藏层）---')
model = guan.fully_connected_neural_network_with_two_hidden_layers(input_size=28*28, hidden_size_1=hidden_size, hidden_size_2=hidden_size, output_size=10, activation_1='relu', activation_2='relu')
train_and_test(model, train_loader_new, test_loader_new)

print('---全连接神经网络模型（包含三个隐藏层）---')
model = guan.fully_connected_neural_network_with_three_hidden_layers(input_size=28*28, hidden_size_1=hidden_size, hidden_size_2=hidden_size, hidden_size_3=hidden_size, output_size=10, activation_1='relu', activation_2='relu', activation_3='relu')
train_and_test(model, train_loader_new, test_loader_new)

print('---卷积神经网络模型（包含两个卷积层和两个全连接层）---')
model = guan.convolutional_neural_network_with_two_convolutional_layers_and_two_fully_connected_layers(in_channels=1, out_channels_1=32, out_channels_2=64, kernel_size_1=3, kernel_size_2=3, stride_1=1, stride_2=1, padding_1=1, padding_2=1, pooling=1, pooling_kernel_size=2, pooling_stride=2, input_size=7*7*64, hidden_size_1=hidden_size, hidden_size_2=hidden_size, output_size=10)
train_and_test(model, train_loader, test_loader)

运行结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

---全连接神经网络模型（包含一个隐藏层）---
Epoch [1/10], Loss: 0.4376, Accuracy: 87.51%
Epoch [2/10], Loss: 0.2560, Accuracy: 92.49%
Epoch [3/10], Loss: 0.1936, Accuracy: 94.25%
Epoch [4/10], Loss: 0.1555, Accuracy: 95.38%
Epoch [5/10], Loss: 0.1328, Accuracy: 95.98%
Epoch [6/10], Loss: 0.1193, Accuracy: 96.41%
Epoch [7/10], Loss: 0.1087, Accuracy: 96.68%
Epoch [8/10], Loss: 0.0996, Accuracy: 96.97%
Epoch [9/10], Loss: 0.0945, Accuracy: 97.03%
Epoch [10/10], Loss: 0.0872, Accuracy: 97.30%
Test Accuracy: 96.75%
---全连接神经网络模型（包含两个隐藏层）---
Epoch [1/10], Loss: 0.4167, Accuracy: 87.95%
Epoch [2/10], Loss: 0.2170, Accuracy: 93.50%
Epoch [3/10], Loss: 0.1611, Accuracy: 95.21%
Epoch [4/10], Loss: 0.1338, Accuracy: 95.92%
Epoch [5/10], Loss: 0.1114, Accuracy: 96.56%
Epoch [6/10], Loss: 0.1002, Accuracy: 96.88%
Epoch [7/10], Loss: 0.0903, Accuracy: 97.16%
Epoch [8/10], Loss: 0.0802, Accuracy: 97.48%
Epoch [9/10], Loss: 0.0759, Accuracy: 97.59%
Epoch [10/10], Loss: 0.0699, Accuracy: 97.80%
Test Accuracy: 96.71%
---全连接神经网络模型（包含三个隐藏层）---
Epoch [1/10], Loss: 0.4567, Accuracy: 86.16%
Epoch [2/10], Loss: 0.2217, Accuracy: 93.27%
Epoch [3/10], Loss: 0.1686, Accuracy: 94.78%
Epoch [4/10], Loss: 0.1442, Accuracy: 95.54%
Epoch [5/10], Loss: 0.1276, Accuracy: 96.07%
Epoch [6/10], Loss: 0.1132, Accuracy: 96.55%
Epoch [7/10], Loss: 0.1007, Accuracy: 96.86%
Epoch [8/10], Loss: 0.0944, Accuracy: 96.96%
Epoch [9/10], Loss: 0.0863, Accuracy: 97.27%
Epoch [10/10], Loss: 0.0816, Accuracy: 97.39%
Test Accuracy: 96.74%
---卷积神经网络模型（包含两个卷积层和两个全连接层）---
Epoch [1/10], Loss: 0.1923, Accuracy: 93.92%
Epoch [2/10], Loss: 0.0522, Accuracy: 98.41%
Epoch [3/10], Loss: 0.0349, Accuracy: 98.92%
Epoch [4/10], Loss: 0.0278, Accuracy: 99.11%
Epoch [5/10], Loss: 0.0228, Accuracy: 99.28%
Epoch [6/10], Loss: 0.0177, Accuracy: 99.41%
Epoch [7/10], Loss: 0.0148, Accuracy: 99.51%
Epoch [8/10], Loss: 0.0127, Accuracy: 99.58%
Epoch [9/10], Loss: 0.0118, Accuracy: 99.64%
Epoch [10/10], Loss: 0.0080, Accuracy: 99.75%
Test Accuracy: 99.14%

四、附：手写数字识别动图

参考资料：https://www.guanjihuan.com/archives/43720

目录

1. 引入
2. SQLite 的安装
3. 创建一个表
   • 查看表
   • 退出/打开数据库
4. 基本操作
   • 查询 / DISTINCT / COUNT / AS / WHERE / AND 和 OR
5. 条件与分组
   • GROUP BY / ORDER BY / LIMIT / LIKE
6. 插入、更新与删除
   • INSERT / UPDATE / DELETE
7. 主键与外键
   • 准备 / 主键和外键 / JOIN
8. 建立索引
9. 事务
   • “事务”的介绍 / 四大特性
10. 在 Python 中使用 SQL
11. 附：关系型数据库和非关系型数据库

1. 引入

现代的程序，无论是网站、手机app等等，往往都要处理大量的数据，这些数据需要通过 数据库（Database） 来管理。为了便于程序与数据库之间的交互，我们引入一门语言，SQL（Structured Query Language，结构化查询语言）。使用SQL可以方便地对 关系型数据库（Relational Database） 进行增、查、改、删等操作。（关于什么是关系型数据库可以见文末）

2. SQLite的安装

为了学习SQL，我们先来安装一个轻量级的关系型数据库 SQLite ，请与SQL区分，SQL是一种查询语言，SQLiete是一种数据库。

因为我们只是用来学习SQL语言，所以比起Oracle这样的庞然大物，使用轻量级的SQLite是更好的选择。当然，你学会了SQL之后，可以自由选择符合你需求的数据库，关系型数据库都使用统一的SQL语言，无需再次学习。

安装SQLite非常简单，访问SQLite官网的下载页面，下载你的系统对应的带有“Precompiled”前缀的压缩包。以windows x64系统为例，下载这两个文件，并把他们解压到相同的文件夹下面，例如“C:\sqlite”。

此时双击sqlite3.exe，看到以下界面就成功了，连安装都不需要，只要解压，够轻量级吧。

但是当你在命令行输入sqlite3命令时会发现，系统找不到这个命令，这是因为没有在系统的环境变量path里加上sqlite3.exe所在的路径（例如C:\sqlite）。假如你不知道环境变量path是什么，可以看看我的这篇文章。

添加了环境变量后，在cmd/powershell/bash或者你喜欢的任何shell里输入sqlite3，你应该能看到和上面双击exe一样的输出。

在命令行里键入以下命令：

1

sqlite3

如果你配置好了环境，应该可以看到以下输出。

1
2
3

# SQLite version 3.43.1 2023-09-11 12:01:27
# Enter ".help" for usage hints.
# sqlite>

看到输入提示符变成“sqlite>”，我们就进入了sqlite的命令行。

3. 创建一个表

使用以下命令来创建一个表，注意所有的SQL语句末尾都要有分号。

1

CREATE TABLE 表名 ('列名' 数据类型, ...);

不同的数据库可能对相同的类型有不同的名称、不同的长度、数据范围 以sqlite为例，常用的数据类型有以下几种：

另外，SQLite还提供了两个修饰符：NOT NULL和UNIQUE，分别表示这个字段不能为空，以及这个字段必须唯一。

根据我们的需求，创建一个这样的表：

1

CREATE TABLE books ('title' TEXT NOT NULL, 'price' REAL, 'sales' INTEGER, 'category' TEXT);

我们先把一些数据拷贝到books.csv中（csv是Comma-Separated Values，逗号分隔的值的缩写）

数据是ChatGPT生成的，所以不要在意一些不合理的小细节

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

The Great Gatsby,50.99,4,Fiction
To Kill a Mockingbird,25.99,3,Fiction
Pride and Prejudice,40.99,2,Fiction
1984,35.99,1,Science Fiction
The Catcher in the Rye,60.99,5,Fiction
Animal Farm,30.5,2,Fiction
The Hobbit,45,4,Fantasy
The Lord of the Rings,55.99,3,Fantasy
Harry Potter and the Sorcerer's Stone,20,1,Fantasy
The Chronicles of Narnia,15.98,5,Fantasy
Moby Dick,45.99,3,Fiction
The Odyssey,30.99,2,Classic
To the Lighthouse,40,4,Classic
The Adventures of Tom Sawyer,25.1,2,Classic
War and Peace,50.99,4,Classic
Crime and Punishment,35.99,1,Classic
The Alchemist,55.99,2,Fiction
Fahrenheit 451,20.99,4,Science Fiction
The Picture of Dorian Gray,15.98,5,Classic
Brave New World,60.3,3,Science Fiction

将sqlite切换为csv模式并导入这个.csv文件。

1
2

.mode csv
.import books.csv books

所有以逗号开头的命令都不属于SQL，而是SQLite的语法

查看表

这样可以查看有哪些表，每个表有哪些字段：

1

.schema

这样查看表的内容：

1

SELECT 列名,... FROM 表名;

切换到box模式，这样的输出比较好看，然后我们用SELECT命令查看一下导入的数据。

1
2

.mode box
SELECT * FROM books;

“*”表示通配符，即选择所有的列，在这里相当于SELECT name, price, sales FROM books;

可以看到输出了刚刚导入的表格

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

┌───────────────────────────────────────┬───────┬───────┬─────────────────┐
│                 title                 │ price │ sales │    category     │
├───────────────────────────────────────┼───────┼───────┼─────────────────┤
│ The Great Gatsby                      │ 50.99 │ 4     │ Fiction         │
│ To Kill a Mockingbird                 │ 25.99 │ 3     │ Fiction         │
│ Pride and Prejudice                   │ 40.99 │ 2     │ Fiction         │
│ 1984                                  │ 35.99 │ 1     │ Science Fiction │
│ The Catcher in the Rye                │ 60.99 │ 5     │ Fiction         │
│ Animal Farm                           │ 30.5  │ 2     │ Fiction         │
│ The Hobbit                            │ 45.0  │ 4     │ Fantasy         │
│ The Lord of the Rings                 │ 55.99 │ 3     │ Fantasy         │
│ Harry Potter and the Sorcerer's Stone │ 20.0  │ 1     │ Fantasy         │
│ The Chronicles of Narnia              │ 15.98 │ 5     │ Fantasy         │
│ Moby Dick                             │ 45.99 │ 3     │ Fiction         │
│ The Odyssey                           │ 30.99 │ 2     │ Classic         │
│ To the Lighthouse                     │ 40.0  │ 4     │ Classic         │
│ The Adventures of Tom Sawyer          │ 25.1  │ 2     │ Classic         │
│ War and Peace                         │ 50.99 │ 4     │ Classic         │
│ Crime and Punishment                  │ 35.99 │ 1     │ Classic         │
│ The Alchemist                         │ 55.99 │ 2     │ Fiction         │
│ Fahrenheit 451                        │ 20.99 │ 4     │ Science Fiction │
│ The Picture of Dorian Gray            │ 15.98 │ 5     │ Classic         │
│ Brave New World                       │ 60.3  │ 3     │ Science Fiction │
└───────────────────────────────────────┴───────┴───────┴─────────────────┘

当然，不一定要选择所有的列，如果输入SELECT name FROM books;就只会显示所有的书名。试一试吧！

退出/打开数据库

输入.quit退出SQLite。

你会发现，SQLite为你在目录下自动创建了一个名为“books.db”的文件。

下一次打开数据库只需要输入sqlite3 books.db即可恢复原来的数据。

4. 基本操作

数据库有四个基本操作CRUD，即Create增、Read查、Update改、Delete删，在SQL中分别对应以下语句。

• 增：CREATE, INSERT
• 查：SELECT
• 改：UPDATE
• 删：DELETE, DROP

查询

我们已经学会了使用SELECT来查询数据，现在我们来学习一些常用的函数。

SQL中自带了很多函数，常用的有这几种：

DISTINCT

假如我们想要查看所有的分类，可以这样子写:

1

SELECT DISTINCT(category) FROM books;

输出:

1
2
3
4
5
6
7
8

┌─────────────────┐
│    category     │
├─────────────────┤
│ Fiction         │
│ Science Fiction │
│ Fantasy         │
│ Classic         │
└─────────────────┘

COUNT

查看有多少种分类：

1

SELECT COUNT(DISTINCT(category)) FROM books; 

输出是这样的

1
2
3
4
5

┌───────────────────────────┐
│ COUNT(DISTINCT(category)) │
├───────────────────────────┤
│ 4                         │
└───────────────────────────┘

AS

这个“COUNT(DISTINCT(category))”有点太长了，我们可以给它起个别名，比如说叫“n”。

SQL中有一个关键字AS可以实现这个功能。

1

SELECT COUNT(DISTINCT(category)) AS n FROM books; 

输出：

1
2
3
4
5

┌───┐
│ n │
├───┤
│ 4 │
└───┘

WHERE

WHERE可以用来指定选择的条件，如

1

SELECT COUNT(*) FROM books WHERE category = 'Fiction';

结果显示一共有7本小说

1
2
3
4
5

┌──────────┐
│ COUNT(*) │
├──────────┤
│ 7        │
└──────────┘

AND 和 OR

也可以使用AND或者OR来连接多个条件，比如我想知道有哪些经典小说的价格在30或以上。

1

SELECT * FROM books WHERE category = 'Classic' AND price >= 30;

非常简单对吧？

1
2
3
4
5
6
7
8

┌──────────────────────┬───────┬───────┬──────────┐
│        title         │ price │ sales │ category │
├──────────────────────┼───────┼───────┼──────────┤
│ The Odyssey          │ 30.99 │ 2     │ Classic  │
│ To the Lighthouse    │ 40.0  │ 4     │ Classic  │
│ War and Peace        │ 50.99 │ 4     │ Classic  │
│ Crime and Punishment │ 35.99 │ 1     │ Classic  │
└──────────────────────┴───────┴───────┴──────────┘

也可以自己试试把AND换成OR。

容易注意到，上面写的SQL语句的关键字都是使用全大写的，其实小写的命令也能被识别，大写的风格是一种传统的风格。

5. 条件与分组

上一节里我们使用了WHERE关键字进行了条件的筛选，实际上这样的关键字还有很多，以下是常用的一些。

GROUP BY

将数据按某个字段分组

1

SELECT category, COUNT(*) FROM books GROUP BY category;

输出：

1
2
3
4
5
6
7
8

┌─────────────────┬──────────┐
│    category     │ COUNT(*) │
├─────────────────┼──────────┤
│ Classic         │ 6        │
│ Fantasy         │ 4        │
│ Fiction         │ 7        │
│ Science Fiction │ 3        │
└─────────────────┴──────────┘

ORDER BY

按某个字段排序，例如按每种分类的个数排序。

1

SELECT category, COUNT(*) FROM books GROUP BY category ORDER BY COUNT(*);

输出：

1
2
3
4
5
6
7
8

┌─────────────────┬──────────┐
│    category     │ COUNT(*) │
├─────────────────┼──────────┤
│ Science Fiction │ 3        │
│ Fantasy         │ 4        │
│ Classic         │ 6        │
│ Fiction         │ 7        │
└─────────────────┴──────────┘

默认是升序排列的，如果我们想要降序排列，需要在后面加上DESC（Descending，降序）。默认情况和后面加上ASC是一样的（Ascending，升序）

1

SELECT category, COUNT(*) FROM books GROUP BY category ORDER BY COUNT(*) DESC;

输出

1
2
3
4
5
6
7
8

┌─────────────────┬──────────┐
│    category     │ COUNT(*) │
├─────────────────┼──────────┤
│ Fiction         │ 7        │
│ Classic         │ 6        │
│ Fantasy         │ 4        │
│ Science Fiction │ 3        │
└─────────────────┴──────────┘

LIMIT

LIMIT可以限制最多显示的数据条数，让我们看看最贵的5本书：

1

SELECT title, price FROM books ORDER BY price DESC LIMIT 5;

输出：

1
2
3
4
5
6
7
8
9

┌────────────────────────┬───────┐
│         title          │ price │
├────────────────────────┼───────┤
│ The Catcher in the Rye │ 60.99 │
│ Brave New World        │ 60.3  │
│ The Lord of the Rings  │ 55.99 │
│ The Alchemist          │ 55.99 │
│ The Great Gatsby       │ 50.99 │
└────────────────────────┴───────┘

LIKE

LIKE字句允许你使用通配符进行模糊匹配。

1. “%” 表示0或任意个字符（包括数字）
2. “_” 表示1个字符（包括数字）

我想找出所有以“The”开头的书，可以这样：

1

SELECT title FROM books WHERE title LIKE 'The%'; 

输出：

1
2
3
4
5
6
7
8
9
10
11
12
13

┌──────────────────────────────┐
│            title             │
├──────────────────────────────┤
│ The Great Gatsby             │
│ The Catcher in the Rye       │
│ The Hobbit                   │
│ The Lord of the Rings        │
│ The Chronicles of Narnia     │
│ The Odyssey                  │
│ The Adventures of Tom Sawyer │
│ The Alchemist                │
│ The Picture of Dorian Gray   │
└──────────────────────────────┘

6. 插入、更新与删除

INSERT

1

INSERT INTO 表名 (列名, ...) VALUES (值, ...);

这样可以插入新的数据，例如插入一本新书“A Wrinkle in Time”。

1

INSERT INTO books (title, price, sales, category) VALUES ('A Wrinkle in Time',23.99,1,'Fantasy');

键入SELECT * FROM books;可以看到已经成功地插入了新的书。

UPDATE

用UPDATE将所有“Science Fiction”分类改名为“Sci-fi”可以这样写：

1

UPDATE books SET category = 'Sci-fi' WHERE category = 'Science Fiction';

这是我们接触到的第一个“破坏性”的命令，所以键入命令时请double check一下，确认这就是你想要的，避免造成严重的后果 。实际的项目中一般有权限控制、备份、生产环境隔离等方法来避免这种悲剧的发生，但是养成这个好习惯也很重要。

DELETE

这个命令比UPDATE更加危险，因此请确保你所写下的命令，就是你想要的，不要漏掉任何条件语句如WHERE。

下面的命令可以删除所有销量不高于2的书：

1

DELETE FROM books WHERE sales <= 2;

现在的数据是这样的：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

┌────────────────────────────┬───────┬───────┬──────────┐
│           title            │ price │ sales │ category │
├────────────────────────────┼───────┼───────┼──────────┤
│ The Great Gatsby           │ 50.99 │ 4     │ Fiction  │
│ To Kill a Mockingbird      │ 25.99 │ 3     │ Fiction  │
│ The Catcher in the Rye     │ 60.99 │ 5     │ Fiction  │
│ The Hobbit                 │ 45.0  │ 4     │ Fantasy  │
│ The Lord of the Rings      │ 55.99 │ 3     │ Fantasy  │
│ The Chronicles of Narnia   │ 15.98 │ 5     │ Fantasy  │
│ Moby Dick                  │ 45.99 │ 3     │ Fiction  │
│ To the Lighthouse          │ 40.0  │ 4     │ Classic  │
│ War and Peace              │ 50.99 │ 4     │ Classic  │
│ Fahrenheit 451             │ 20.99 │ 4     │ Sci-fi   │
│ The Picture of Dorian Gray │ 15.98 │ 5     │ Classic  │
│ Brave New World            │ 60.3  │ 3     │ Sci-fi   │
└────────────────────────────┴───────┴───────┴──────────┘

7. 主键与外键

准备

为了介绍 主键（Primary Keys） 与外键 （Foreign Keys） ，我们再新建一个数据库。

1
2
3
4

sqlite3 movies.db
# SQLite version 3.43.1 2023-09-11 12:01:27
# Enter ".help" for usage hints.
# sqlite>

假如movies.db不存在，SQLite会自动创建它。

我用ChatGPT又生成了一些数据（不确定有没有错误）。

movies.csv:（两列分别代表id和title）

1
2
3
4
5
6
7

1,The Dark Knight
2,Inception
3,The Shawshank Redemption
4,The Godfather
5,The Godfather: Part II

......

stars.csv:（两列分别代表id和name）

1
2
3
4
5
6
7

1,Christian Bale
2,Heath Ledger
3,Aaron Eckhart
4,Michael Caine
5,Gary Oldman

......

movies_stars.csv:（两列分别代表movie_id和star_id）

1
2
3
4
5
6
7

1,1
1,2
1,3
1,4
1,5

......

下载这三个文件

创建三个相应的表格，并载入数据：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

CREATE TABLE movies (
  'id' INTEGER PRIMARY KEY,
  'title' TEXT
);
CREATE TABLE stars (
  'id' INTEGER PRIMARY KEY,
  'name' TEXT
);
CREATE TABLE movies_stars (
  'movie_id' INTEGER,
  'star_id' INTEGER,
  FOREIGN KEY('movie_id') REFERENCES movies('id'),
  FOREIGN KEY('star_id') REFERENCES stars('id')
);
.mode csv
.import movies.csv movies
.import stars.csv stars
.import movies_stars.csv movies_stars
.mode box

主键和外键

我们这次的数据里，每个电影都对应了多名主演，而每个演员也可能出演多部电影，所以我们使用一张movies_stars表格来记录电影和主演之间的关系，而不是直接放在同一个表格的另一列中。

主键是一种约束，一个表只能有一列主键，每个主键唯一，且不可以为空。'id' INTEGER PRIMARY KEY会将id设置为主键。

外键可以连接其他的表的主键，设置外键的约束可以防止插入外部表中不存在的主键。按以下格式：

1
2
3
4

CREATE TABLE movies_stars (
  ......,
  FOREIGN KEY(外键) REFERENCES 外部表(外部表的主键)
);

JOIN

查看movies_stars，发现它实际上只有两列数字id，如果我们想看看这些数字id代表那哪电影或哪名演员，就要使用JOIN合并两张表。

1

SELECT 列名, ... FROM 表1 JOIN 表2 ON 条件;

按照上面的格式，有：

1

SELECT * FROM movies_stars JOIN stars ON movies_stars.star_id = stars.id LIMIT 5;

输出如下结果：

1
2
3
4
5
6
7
8
9

┌──────────┬─────────┬────┬────────────────┐
│ movie_id │ star_id │ id │      name      │
├──────────┼─────────┼────┼────────────────┤
│ 1        │ 1       │ 1  │ Christian Bale │
│ 1        │ 2       │ 2  │ Heath Ledger   │
│ 1        │ 3       │ 3  │ Aaron Eckhart  │
│ 1        │ 4       │ 4  │ Michael Caine  │
│ 1        │ 5       │ 5  │ Gary Oldman    │
└──────────┴─────────┴────┴────────────────┘

比如我们想知道Morgan Freeman和Tom Hardy主演了哪些电影，我们可以使用两次JOIN:

1
2
3
4
5
6

SELECT title, name FROM movies_stars
JOIN stars ON movies_stars.star_id = stars.id
JOIN movies ON movies_stars.movie_id = movies.id
WHERE name = 'Morgan Freeman'
OR name = 'Tom Hardy'
ORDER BY name;

得到以下结果：

1
2
3
4
5
6
7
8
9

┌──────────────────────────┬────────────────┐
│          title           │      name      │
├──────────────────────────┼────────────────┤
│ The Shawshank Redemption │ Morgan Freeman │
│ Se7en                    │ Morgan Freeman │
│ The Dark Knight Rises    │ Morgan Freeman │
│ Inception                │ Tom Hardy      │
│ The Dark Knight Rises    │ Tom Hardy      │
└──────────────────────────┴────────────────┘

还有一种写法，效果是一样的：

1
2
3
4
5

SELECT title, name FROM movies_stars, stars, movies
WHERE movies_stars.star_id = stars.id
AND movies_stars.movie_id = movies.id
AND name IN ('Morgan Freeman', 'Tom Hardy')
ORDER BY name;

请注意FROM后面写出了多个表格。

8. 建立索引

当数据量小的时候，查找操作几乎是瞬间完成的，但是当数据库的规模很大的时候，对数据库的搜索操作会变得很慢，因为默认情况下数据库是使用低效的线性查找，这时候就需要我们建立 索引 。

1
2

CREATE INDEX 索引名 ON 表名 (列名, ...);
CREATE INDEX title_index ON movies (title);

当执行这个语句之后，数据库会为这几列创建一种名为 B树（B-Tree） 的数据结构，将搜索加速到 O(log⁡n)O(logn) ，但同时使用的储存空间也会更多，所以推荐只在需要经常查找的字段上建立索引。

另外，.timer on可以打开计时器比较执行速度，但是在我使用的这么小的数据里是看不出效果的。

9. 事务

“事务”的介绍

事务（Transaction） 可以将一系列数据库操作绑定在一起执行，要么一起成功，要么都不执行。

设想假如我去银行取钱，我的账户余额扣除了1000元，但是这个时候ATM机坏了，什么都没有吐出来，此时我的钱就凭空消失了。如果把“从账户里扣除1000元”和“ATM吐出1000元”绑定成一个 事务 ，就可以避免这种情况的发生，如果ATM吐钱失败了，我的账户也不会扣钱。

还有一种情况，是David教授在CS50的课上举的例子，假如宿舍里有一个小冰箱，一天我打开冰箱发现牛奶喝完了，于是我去买牛奶，这时我的室友回来了，他也看到冰箱里没牛奶了，于是也去买。结果两个人都买了牛奶，冰箱放不下了。

买牛奶这个问题的关键在于，我的室友并不知道冰箱有没有牛奶的状态正在从“没有”更新到“有”，他只能看到冰箱里“没有”牛奶，而不知道我已经去买牛奶了。具体到数据库上，我们需要一种方法，把数据库“锁住”，让其他读取操作等待，直到数据更新完毕后再执行。

“取钱”和“买牛奶”这两个问题都可以通过SQL中的“事务”来解决，你只需要把一系列的命令用BEGIN TRANSACTION和COMMIT包裹起来就可以了。

1
2
3

BEGIN TRANSACTION
......
COMMIT

四大特性

事务具有ACID四大特性：

1. 原子性（Atomicity）：事务中的操作不可再分，要么全部成功，要么全部取消。
2. 一致性（Consistency）：事务开始前与结束后的数据都是合法的，例如甲给乙转账，转账前后他们俩的钱加起来应该不变。
3. 隔离性（Isolation）：事务的运行互不干扰。
4. 持久性（Durability）：事务完成后，它对数据库的修改就永久提交了，不再回滚。

10. 在Python中使用SQL

SQL很少被单独使用，通常SQL会与其他的一些语言结合使用，比如Python、Java、 C#等等。这篇文章里，我们关注如何在Python中使用SQL操作数据库。

Python中内置了SQLite3，你只需要执行

1

import sqlite3

就可以开始使用了，不需要安装任何第三方库。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

db = sqlite3.connect("database.db") 
# 连接到一个现有的数据库，如果没有这个文件就创建它

cur = db.cursor() 
# 创建一个cursor，才能执行SQL语句

# cur.execute(你想执行的SQL语句)
cur.execute("CREATE TABLE books ('title' TEXT NOT NULL, 'price' REAL, 'sales' INTEGER, 'category' TEXT);")  
# 创建一个表

res = cur.execute("SELECT name FROM sqlite_master")
# SQLite内置了一个名叫“sqlite_master”的表，储存了所有已创建的表

print(res.fetchone())
# 输出('books',)

cur.execute("""
    INSERT INTO books VALUES
        ('The Great Gatsby', 50.99, 4, 'Fiction'),
        ('The Lord of the Rings', 55.99, 3, 'Fantasy')
""")
db.commit()
# 插入两名学生
# 会自动地创建事务，无需手动加上“BEGIN TRANSACTION”
# 需要手动db.commit()


category = input("category:")
res = cur.execute("SELECT title FROM books WHERE category = ?", (category, ))
# 注意传入的第二个参数是一个元组，不能直接传category
# 请使用“?”占位符，不要使用 f"SELECT title FROM books WHERE category = {category}"或者其他任何方式
# 否则可能会受到SQL注入攻击（SQL injection attacks）
# “?”占位符会自动处理传入的字符串，防止SQL注入


# cur.executemany可以批量执行SQL语句，推荐使用executemany而不是for循环嵌套execute
cur.executemany("INSERT INTO books VALUES(?, ?, ?, ?);", data)
db.commit()

res = cur.execute('SELECT title, price FROM books')
for row in res:
    print(row)
'''
输出
('The Great Gatsby', 50.99)
('The Lord of the Rings', 55.99)
('To Kill a Mockingbird', 25.99)
('Pride and Prejudice', 40.99)
('To Kill a Mockingbird', 25.99)
('Pride and Prejudice', 40.99)
('1984', 35.99)
('The Catcher in the Rye', 60.99)
('Animal Farm', 30.5)
('The Hobbit', 45.0)
'''

db.close()
# 关闭数据库连接，现在可以连接别的数据库

附：关系型数据库和非关系型数据库

我们上面讨论的 SQL 语言主要适用于关系型数据库，那么什么是关系型数据库和非关系性数据库呢？

关系型数据库（Relational Database）与非关系型数据库（NoSQL Database）有什么区别呢？请看下面的表格。

ACID: 原子性（Atomicity）、一致性（Consistency）、隔离性（Isolation）、持久性（Durability）

简单来说，关系型数据库就像Excel表格，非关系型数据库就像.json文件（当使用键值对数据结构时）。

关系型数据库更成熟稳定，非关系型数据库更灵活易扩展。

1. 线性空间到底是什么？
2. 群、环、域、模
   • 群
     • 比群更简单的结构
   • 环
     • 除环
     • 域
3. 模
4. 线性空间的定义
5. 为什么线性空间要定义在域上？
6. 证明线性空间一定有基
   • Hamel 基
     • 存在性证明
7. 模不一定有基
8. 基在线性空间中的作用
9. 参考链接

线性空间到底是什么？

我们在学习线性代数的时候，通常见到的线性空间是由以下八个条件共同定义的：

设 $K$ 是一个数域，$V$ 是一个非空集合，同时还定义了：

• 向量加法：$+:V\times V\to V$
• 标量乘法：$\cdot:K\times V\to V$（$\cdot$ 也可省略）

且两种运算满足以下八条，则称 $V$ 是定义在 $K$ 上的线性空间，又称向量空间。

1. 向量加法单位元存在：存在 $\theta\in V$ 使得 $\alpha+\theta=\alpha,\ \alpha\in V$，称 $\theta$ 为 $V$ 的零元素，即向量加法的单位元。
2. 向量加法逆元存在：$\forall\alpha\in V,\ \exists\beta\in V$ 使得 $\alpha+\beta=\theta$，称 $\beta$ 为 $V$ 的负元素，即向量加法的逆元。
3. 向量加法结合律：$(\alpha+\beta)+\gamma=\alpha+(\beta+\gamma),\ \alpha,\beta,\gamma\in V$
4. 向量加法交换律：$\alpha+\beta=\beta+\alpha,\ \alpha,\beta\in V$
5. 标量乘法单位元存在：存在 $1\in K$ 使得 $1\cdot\alpha=\alpha,\ \alpha\in V$，称 $1$ 为 $K$ 的单位元，即标量乘法的单位元。
6. 标量乘法对向量加法的分配律：$c\cdot(\alpha+\beta)=c\cdot\alpha+c\cdot\beta,\ c\in K,\ \alpha,\beta\in V$
7. 标量乘法对域加法的分配律：$(c_1+c_2)\cdot\alpha=c_1\cdot\alpha+c_2\cdot\alpha,\ c_1,c_2\in K,\ \alpha\in V$
8. 标量乘法与域乘法的结合律：$(c_1c_2)\cdot\alpha=c_1(c_2\cdot\alpha),\ c_1,c_2\in K,\ \alpha\in V$

整整八条，实在劝退，有没有更简单的方式来表达这些呢？

维基百科上对线性空间的概括定义是：

$(K,+,\times)$ 是一个域，且 $V$ 是一个 $K-$ 模。

本文将从八个条件出发，根据抽象代数中域和模的定义，来解释这一句话。前半部分亦可作为抽象代数中基本概念的速览。

群、环、域、模

群

群是指一个集合 $G$，和一个运算 $\circ:G\times G\to G$（封闭性），满足以下条件：

1. 结合律：$\forall a,b,c\in G,\ (a\circ b)\circ c=a\circ(b\circ c)$
2. 单位元：存在 $e\in G$，使得 $\forall a\in G,\ e\circ a=a$，称 $e$ 为群的单位元（Identity），又称幺元。
3. 逆元：对任意 $a\in G$，存在 $a^{-1}\in G$，使得 $a^{-1}\circ a=e$，称 $a^{-1}$ 为 $a$ 的逆元（Inverse）。

就称 $(G,\circ)$ 为一个群（Group）。需要注意的是，群不一定满足交换律；在群的定义的基础上，若还满足交换律 $a\circ b=b\circ a$，则称该群为交换群，又叫 Abel 群。

群的例子：

1. $(\mathbb{Z},+)$：整数关于加法满足结合律、单位元 $0$ 存在、逆元 $-a$ 存在，构成一个群，不仅如此，这还是一个交换群。
2. $(\mathbb{R}\setminus{0},\times)$：去掉零的实数关于乘法满足结合律、单位元 $1$ 存在、逆元 $a^{-1}$ 存在，构成一个群，也是一个交换群。
3. 非交换群的一个例子：六阶二面体群

我们可以看出，线性空间定义的前 4 条，现在可以用一句话概括：

$(V,+)$ 是一个交换群。

比群更简单的结构

上面群的定义可以概括成封闭性、结合律、单位元、逆元四个条件，可以进一步分解为：

• 满足封闭性就可以称为原群（Magma）
• 满足封闭性、结合律就可以称为半群（Semigroup）
• 满足封闭性、结合律、单位元就可以称为幺半群（Monoid）

环

不同地方对环的定义存在分歧，最常见的定义是以下这种：

若 $(R,+,\times)$ 满足：

1. $(R,+)$ 是一个交换群
2. $(R,\times)$ 是一个幺半群
3. 左分配律：$a(b+c)=ab+ac$
4. 右分配律：$(b+c)a=ba+ca$

则称 $(R,+,\times)$ 为一个环（Ring）。

环不一定满足乘法交换律，满足乘法交换律的环叫做交换环。

环的例子：

1. $(\mathbb{Z},+,\times)$，是环。
2. 实系数矩阵 $M_n(\mathbb{R})$ 是环。
3. 有理系数多项式 $\mathbb{Q}[x]$ 是环。

除环

如果环中的任何非零元都存在乘法逆元，即：

$$\forall a\in R\setminus{0},\ \exists a^{-1}\in R\setminus{0},\ \text{使得 } a^{-1}\cdot a=1$$

则称 $(R,+,\times)$ 为一个除环。

域

交换的除环就是域（Field）。

$\mathbb{Q}$、$\mathbb{R}$、$\mathbb{C}$ 都是域。但是 $\mathbb{Z}$ 不是域，因为 $\mathbb{Z}$ 中只有 $1,-1$ 两个元素存在乘法逆元。

模

若 $R$ 是一个环，$1_R$ 是环的幺元，$(M,+)$ 构成一个交换群，且有一个运算 $\cdot:R\times M\to M$，称为标量乘法。

若这个标量乘法对所有 $r,s\in R$，$x,y\in M$，满足：

1. $(r\cdot s)\cdot x=r\cdot(s\cdot x)$
2. $r\cdot(x+y)=r\cdot x+r\cdot y$
3. $(r+s)\cdot x=r\cdot x+s\cdot x$
4. $1_R\cdot x=x$

则称 $M$ 是一个左 $R-$ 模。

若基于上面的定义，但交换标量乘法的运算顺序，则称 $M$ 是一个右 $R-$ 模。

线性空间的定义

到模这一步就已经很抽象了，恭喜你坚持到了这里，现在我们终于可以定义线性空间了：

$(K,+,\times)$ 是一个域，且 $V$ 是一个 $K-$ 模。

线性空间的八条定义里，前四条实际上规定了 $(V,+)$ 是一个交换群，而后四条正好就是模的定义中的四条。因此说 $V$ 是一个 $K-$ 模，这就是定义的后半句话。

那么，这个定义中的前半句话可不可以去掉呢？模的定义里已经要求 $K$ 是一个环了，但是线性空间这里，把环的这个条件加强到了域，这有必要吗？

为什么线性空间要定义在域上？

我们这里不去讨论这样定义的历史原因，而是去讨论其合理性。

这非常有必要，因为这个条件保证了线性空间存在基。熟悉线性代数的朋友都应该非常清楚，基是线性代数中非常重要的概念，没有了基，线性代数中很多定理都无法成立，线性空间优良的性质也不存在了。

要理解这个定义，我们首先要证明这个定义下，线性空间一定有基，而且这个证明需要用到 $K$ 是一个域的这个条件。

证明线性空间一定有基

我们学习线性代数的时候，通常讨论的是有限维线性空间，证明有限维线性空间存在基比较简单，并且不需要用到 Zorn 引理；此处为了证明的泛用性，我们的证明将涵盖无穷维线性空间。

Hamel 基

基有多种不同的定义，此处指的是最常用的 Hamel 基。Hamel 基的定义如下：

设 $V$ 为一向量空间，Hamel 基是指一组向量组 $H\subset V$，满足：

1. $H$ 线性无关，即：任取 $H$ 中有限个向量 $\alpha_1,\alpha_2,\cdots,\alpha_n\in H$，则 $\displaystyle\sum_{i=1}^{n}c_i\alpha_i=0$ 当且仅当 $c_1=c_2=\cdots=c_n=0$。（注意此处加粗的”有限个”很重要）
2. $H$ 可以张成整个 $V$，即 $\text{span }H=V$：

$$V=\left{\sum c_i\alpha_i : c_i\in K,\ \alpha_i\in H\right}$$

存在性证明

定理：任何线性空间都有 Hamel 基。

或者更进一步的，任何线性无关向量组都可以扩展出一组基：

定理：设 $S$ 是线性空间 $V$ 中的线性无关向量组，则存在 Hamel 基 $H\supset S$。

证明需要用到 Zorn 引理：

Zorn 引理：设 $\mathcal{S}$ 为一非空偏序集，若 $\mathcal{S}$ 中任意全序集都在 $\mathcal{S}$ 中存在上界，则 $\mathcal{S}$ 中必有极大元。

设 $\mathcal{S}$ 为 $V$ 中所有包含 $S$ 的线性无关向量组的集合，$(\mathcal{S},\subset)$ 构成一偏序集，显然 $\mathcal{S}$ 非空。设 $S_0\in\mathcal{S}$ 为一全序子集，则令 $X=\bigcup_{S_i\in S_0}S_i$，有：

1. $X$ 是 $S_0$ 的上界：显然。
2. $X\in\mathcal{S}$，只需证明 $X$ 线性无关。

下证 $X$ 线性无关：

由 $S_i$ 构成全序集，知可以令 $S_1\subset S_2\subset S_3\subset\cdots$。

任取有限个向量 $\alpha_1,\alpha_2,\cdots,\alpha_n\in X$，则由于 $X=\bigcup_{S_i\in S_0}S_i$，对任意 $\alpha_i$，存在 $j_i$，$\alpha_i\in S_{j_i}$。令 $j=\max{j_1,j_2,\cdots,j_n}$，则 $\forall i,\ \alpha_i\in S_j$。又因为 $S_j\in\mathcal{S}$，所以 $\alpha_i$ 构成的向量组线性无关。$\alpha_i$ 可以任取，由线性无关定义，$X$ 线性无关，且 $X\in\mathcal{S}$。

由 $X$ 是 $S_0$ 的上界且 $X\in\mathcal{S}$，应用 Zorn 引理，$\mathcal{S}$ 中必有极大元，设 $H$ 为一极大元，则 $H\supset S$ 且 $H$ 线性无关。

考察 Hamel 基的定义，线性无关已满足，还需证明 $H$ 可以张成 $V$。任取 $x\in V$，则 $H\cup{x}$ 一定线性相关。因为若线性无关，设 $H’=H\cup{x}$，则 $H’\supset H$ 且 $H’\in\mathcal{S}$，这与 $H$ 是极大元矛盾。

由 $H$ 线性无关、$H’$ 线性相关，知存在不全为零的 $c_1,c_2,\cdots,c_n$ 和 $c_{n+1}\neq 0$，使得

$$c_1\alpha_1+c_2\alpha_2+\cdots+c_n\alpha_n+c_{n+1}x=0$$

则

$$x=c_{n+1}^{-1}(c_1\alpha_1+c_2\alpha_2+\cdots+c_n\alpha_n)$$

即任意 $x\in V$ 均可被 $H$ 线性表示，$\text{span }H=V$。

综上得证。

模不一定有基

回到我们原来的问题来，为什么线性空间一定要定义在域上？这是因为一般的模不一定存在基，存在基的模叫做自由模（Free Module），我们有：

除环上的模必为自由模。

考察我们上面的证明，最后一步中用到了 $c_{n+1}^{-1}$，这一步就要求了 $K$ 中存在乘法逆元，而模并不能保证这一点。

为了方便理解，下面举一个不存在基的模的例子。这个模就是 $\mathbb{Z}-$ 模 $\mathbb{Q}$。

证明 $\mathbb{Z}-$ 模 $\mathbb{Q}$ 不存在基：

设这个模为 $M$。首先，我们有任意两个非零元素都线性相关：$\forall p,q\in\mathbb{Q}\setminus{0}$，存在 $x,y\in\mathbb{Z}$，使得 $xp+yq=0$，这是显然的。

因此如果 $M$ 有基 $B$，一定有 $|B|=1$，设一个基为 $B={f}$，$f\in\mathbb{Q}\setminus{0}$，则 $\text{span }B={0,\pm f,\pm 2f,\cdots}$。显然 $f/2\in M$，$f/2\notin\text{span }B$。故这个基不能张成 $M$，矛盾。

基在线性空间中的作用

想到哪写到哪，早就偏题了，思绪比较混乱，望谅解。

为什么基这么重要？因为对于任何一个数学结构，只要能够证明它是一个线性空间，那么就可以取一组基，然后你就获得了整个线性代数，可以使用线性代数中熟悉的概念。而在群/环/模论中，不同的群/环/模可能有截然不同的性质，没办法这样通用地去研究。

例如在 Hilbert 空间里，傅里叶变换就是将函数变换到一组特殊的正交基上。

定义内积：

$$\langle\alpha,\beta\rangle=\lim_{T\to\infty}\frac{1}{T}\int_{-T/2}^{+T/2}\alpha(t)\overline{\beta(t)},dt$$

选取正交基 $e^{i2\pi ft}$。

不难发现这组基是正交的：

$$\langle e^{i2\pi f_1 t},e^{i2\pi f_2 t}\rangle=\begin{cases}1 & f_1=f_2\ 0 & f_1\neq f_2\end{cases}$$

在此基础上我们就可以推出傅里叶变换：

把信号 $x(t)$ 用正交基 $e^{i2\pi f_n t}$ 表示为：

$$x(t)=\lim_{T\to\infty}\sum_{n=-\infty}^{\infty}\langle x,e^{i2\pi f_n t}\rangle e^{i2\pi f_n t}=\lim_{T\to\infty}\sum_{n=-\infty}^{\infty}\frac{1}{T}\int_{-T/2}^{+T/2}x(t)e^{-i2\pi f_n t},dt\cdot e^{i2\pi f_n t}$$

其中 $f_n=\dfrac{n}{T}$。$\Delta f=\dfrac{1}{T}$，所以上式可以写成：

$$x(t)=\lim_{T\to\infty}\sum_{n=-\infty}^{\infty}\Delta f\int_{-T/2}^{+T/2}x(t)e^{-i2\pi f_n t},dt\cdot e^{i2\pi f_n t}=\int_{-\infty}^{\infty}\int_{-\infty}^{\infty}x(t)e^{-i2\pi ft},dt\cdot e^{i2\pi ft},df$$

由积分的定义可以将求和化为积分。

这个二重积分有着美妙的对称性，而且这里面就蕴含了傅里叶变换：

$$F(x)(f)=\hat{x}(f)=\int_{-\infty}^{\infty}x(t)e^{-i2\pi ft},dt$$

及其逆变换：

$$F^{-1}(\hat{x})(t)=x(t)=\int_{-\infty}^{\infty}\hat{x}(f)e^{i2\pi ft},df$$

这种定义的傅里叶变换 $F$ 可以看作一个线性变换，$F$ 和 $F^{-1}$ 互为逆变换，$F^{-1}\circ F=\mathrm{id}$。

而我们熟悉的 Parseval 定理，其实也只是勾股定理的推广，这里说的是在不同的正交基下，向量的模长都等于坐标的平方和：

$$\int_{-\infty}^{\infty}|x(t)|^2,dt=\int_{-\infty}^{\infty}|\hat{x}(f)|^2,df$$

参考链接

• 维基百科：群
• 维基百科：环（代数）
• 维基百科：模
• 香蕉空间讲义：线性代数（infi）/ 任意环和域上的线性代数 / 环、域、模、向量空间和代数
• 知乎专栏：P/331823781
• brezezee.github.io：Fourier transform
• 维基百科：傅里叶变换