学习笔记 on JasperSao的博客

梯度下降实践：从手写实现到 Scikit-Learn

Mon, 27 Jul 2026 00:00:00 +0800

1. 学习目标

这组实验主要解决以下问题：

从零实现线性回归的代价函数和梯度；
使用批量梯度下降训练模型；
判断梯度下降是否正在收敛；
选择合适的学习率；
使用 Z-score 标准化加快收敛；
通过特征工程实现多项式回归；
使用 Scikit-Learn 完成标准化、训练与预测。

2. 梯度下降的核心流程

线性回归模型：

$$f_{\mathbf{w},b}(\mathbf{x}) = \mathbf{w}\cdot\mathbf{x}+b$$

整个训练过程可以概括为：

输入训练数据 X、y
 ↓
使用当前 w、b 计算预测
 ↓
预测值减去真实值得到误差
 ↓
根据全部误差计算梯度
 ↓
沿梯度反方向更新 w、b
 ↓
重复，直到代价不再明显下降

参数更新规则：

$$w_j \leftarrow w_j-\alpha\frac{\partial J}{\partial w_j}$$$$b \leftarrow b-\alpha\frac{\partial J}{\partial b}$$

其中：

$\alpha$：学习率，决定每一步走多远；
梯度：代价函数上升最快的方向；
减去梯度：向代价下降的方向移动。

3. 实践一：从零实现一元线性回归

实验使用城市人口预测餐厅利润：

x_train：城市人口，单位为 10,000 人；
y_train：餐厅月利润，单位为 10,000 美元；
数据集共有 97 个样本。

一元线性回归模型：

$$f_{w,b}(x^{(i)})=wx^{(i)}+b$$

3.1 实现代价函数

平方误差代价函数：

$$J(w,b) = \frac{1}{2m} \sum_{i=0}^{m-1} \left( f_{w,b}(x^{(i)})-y^{(i)} \right)^2$$

代码：

def compute_cost(x, y, w, b):
 m = x.shape[0]
 total_cost = 0.0

 for i in range(m):
 prediction = w * x[i] + b
 error = prediction - y[i]
 total_cost += error ** 2

 return total_cost / (2 * m)

这里除以 $2m$：

除以 $m$：计算所有样本的平均损失；
除以 2：求导后平方项产生的 2 可以抵消，使梯度公式更简洁。

3.2 实现梯度

梯度公式：

$$\frac{\partial J}{\partial w} = \frac{1}{m} \sum_{i=0}^{m-1} \left( f_{w,b}(x^{(i)})-y^{(i)} \right)x^{(i)}$$$$\frac{\partial J}{\partial b} = \frac{1}{m} \sum_{i=0}^{m-1} \left( f_{w,b}(x^{(i)})-y^{(i)} \right)$$

代码：

def compute_gradient(x, y, w, b):
 m = x.shape[0]
 dj_dw = 0.0
 dj_db = 0.0

 for i in range(m):
 prediction = w * x[i] + b
 error = prediction - y[i]

 dj_dw += error * x[i]
 dj_db += error

 dj_dw /= m
 dj_db /= m

 return dj_dw, dj_db

dj_dw 多乘了一个 x[i]，因为 $w$ 是和输入 $x$ 相乘的参数；而 $b$ 只是直接相加，因此 dj_db 不需要乘 x[i]。

3.3 批量梯度下降

import copy
import math

def gradient_descent(
 x, y,
 w_in, b_in,
 cost_function,
 gradient_function,
 alpha,
 num_iters
):
 w = copy.deepcopy(w_in)
 b = b_in
 J_history = []

 for i in range(num_iters):
 dj_dw, dj_db = gradient_function(x, y, w, b)

 # 必须使用同一次迭代计算出的梯度同步更新
 w = w - alpha * dj_dw
 b = b - alpha * dj_db

 if i < 100_000:
 J_history.append(cost_function(x, y, w, b))

 if i % math.ceil(num_iters / 10) == 0:
 print(
 f"Iteration {i:4d}: "
 f"Cost {J_history[-1]:8.2f}"
 )

 return w, b, J_history

实验参数：

initial_w = 0.0
initial_b = 0.0
iterations = 1500
alpha = 0.01

w, b, J_history = gradient_descent(
 x_train,
 y_train,
 initial_w,
 initial_b,
 compute_cost,
 compute_gradient,
 alpha,
 iterations
)

实验结果大约为：

w = 1.1664
b = -3.6303

预测利润：

profit_35k = (3.5 * w + b) * 10_000
profit_70k = (7.0 * w + b) * 10_000

print(profit_35k) # 约 4519.77 美元
print(profit_70k) # 约 45342.45 美元

这里的"批量"表示：

每轮使用全部 $m$ 个训练样本计算平均梯度，然后更新一次参数。

4. 多变量梯度下降

假设训练数据形状为：

X：(m, n)
y：(m,)
w：(n,)
b：标量

其中：

$m$：训练样本数量；
$n$：每个样本的特征数量。

预测：

y_hat = X @ w + b

误差：

errors = y_hat - y

向量化代价：

def compute_cost(X, y, w, b):
 errors = X @ w + b - y
 return np.sum(errors ** 2) / (2 * X.shape[0])

向量化梯度：

def compute_gradient(X, y, w, b):
 m = X.shape[0]
 errors = X @ w + b - y

 dj_dw = X.T @ errors / m
 dj_db = np.sum(errors) / m

 return dj_dw, dj_db

形状变化：

X.T ：(n, m)
errors ：(m,)
X.T @ errors ：(n,)
dj_dw ：(n,)
dj_db ：标量

最终得到的 dj_dw 恰好包含 $n$ 个梯度，对应 $w$ 中的 $n$ 个参数。

5. 学习率实验

在未缩放的房价数据中，不同学习率会产生不同表现。

$\alpha=9.9\times10^{-7}$

学习率过大：

参数更新越过最低点；
代价不断增加；
模型发散。

$\alpha=9\times10^{-7}$

学习率稍小：

代价持续下降；
参数仍会在最低点两侧震荡；
最终能够收敛。

$\alpha=1\times10^{-7}$

学习率更小：

参数较平稳地靠近最低点；
基本没有明显震荡；
但收敛速度更慢。

因此：

学习率太大 → 震荡或发散
学习率太小 → 稳定但很慢
学习率合适 → 快速且稳定下降

6. 为什么需要特征缩放？

房价数据包含以下特征：

面积：几百到几千
卧室：0 到 5
楼层：1 到 3
房龄：数十年

假设：

$$f(\mathbf{x})=w_1x_1+w_2x_2+b$$

如果 $x_1$ 是房屋面积，最大接近 2000；$x_2$ 是卧室数量，最大只有 5。

对于面积 2000、5 间卧室的房屋，一组合适的参数可能是：

$$w_1=0.1,\quad w_2=50,\quad b=50$$

预测为：

$$0.1\times2000+50\times5+50=500$$

单位是千美元，即 50 万美元。

可以看到：

数值范围大的特征，参数通常较小；
数值范围小的特征，参数通常较大。

这会让代价函数的等高线变得非常狭长：

未缩放：
梯度下降在狭长峡谷两侧反复震荡

缩放后：
等高线更接近圆形
梯度下降更直接地靠近最低点

特征缩放通常不会改变模型能够达到的最优结果，主要作用是让训练更快、更稳定。

7. 三种特征缩放方法

7.1 除以最大值

$$x_j' = \frac{x_j}{\max(x_j)}$$

例如：

面积范围：300～2000
缩放后：0.15～1

卧室范围：0～5
缩放后：0～1

7.2 均值归一化

$$x_j' = \frac{x_j-\mu_j} {\max(x_j)-\min(x_j)}$$

减去均值后，数据会以 0 为中心。

7.3 Z-score 标准化

$$x_j' = \frac{x_j-\mu_j}{\sigma_j}$$

其中：

$$\mu_j = \frac{1}{m} \sum_{i=0}^{m-1}x_j^{(i)}$$$$\sigma_j = \sqrt{ \frac{1}{m} \sum_{i=0}^{m-1} \left(x_j^{(i)}-\mu_j\right)^2 }$$

处理后，每个特征通常具有：

均值接近 0；
标准差接近 1；
各特征具有相似的数值范围。

NumPy 实现：

def zscore_normalize_features(X):
 mu = np.mean(X, axis=0)
 sigma = np.std(X, axis=0)
 X_norm = (X - mu) / sigma

 return X_norm, mu, sigma

使用：

X_norm, X_mu, X_sigma = zscore_normalize_features(X_train)

实验中，未缩放数据只能使用约 1e-7 的学习率；经过 Z-score 标准化后，可以从 0.1 左右开始尝试，收敛速度明显加快。

8. 预测新数据时的关键规则

标准化训练数据后，必须保存训练集的均值和标准差。

预测面积 1200 平方英尺、3 间卧室、1 层、房龄 40 年的房屋：

x_house = np.array([1200, 3, 1, 40])

x_house_norm = (
 x_house - X_mu
) / X_sigma

price = x_house_norm @ w_norm + b_norm

不能对新样本重新计算均值和标准差。

错误：

# 不要这样做
new_mu = np.mean(x_house)
new_sigma = np.std(x_house)

正确原则：

训练集：计算并保存 mu、sigma
验证集：使用训练集的 mu、sigma
测试集：使用训练集的 mu、sigma
新数据：使用训练集的 mu、sigma

否则训练和预测使用的不是同一个坐标系。

9. 如何判断梯度下降是否收敛？

记录每次更新后的代价：

J_history.append(
 compute_cost(X, y, w, b)
)

绘制学习曲线：

plt.plot(J_history)
plt.xlabel("Iteration")
plt.ylabel("Cost J")
plt.show()

正常曲线：

J
│\
│ \
│ \____
│ ───
└──────────── 迭代次数

如果代价持续下降并逐渐变平，说明梯度下降正在收敛。

也可以使用自动收敛条件：

$$\left| J^{(t)}-J^{(t-1)} \right|<\epsilon$$

例如：

if abs(J_history[-1] - J_history[-2]) < 1e-3:
 break

但实际学习中，直接观察学习曲线通常更直观。

10. 梯度下降调试方法

10.1 代价不断增加

可能原因：

学习率太大；
参数更新误写成了加号；
梯度公式实现错误。

错误：

w = w + alpha * dj_dw

正确：

w = w - alpha * dj_dw
b = b - alpha * dj_db

10.2 使用很小的学习率进行测试

把 alpha 设置得非常小。

如果代码正确，代价函数理论上应该缓慢下降。如果很小的学习率下代价仍然增加，通常说明代码存在错误。

需要注意：

很小的学习率适合调试，但不一定适合正式训练，因为它可能导致收敛非常慢。

10.3 尝试一系列学习率

可以按大约 3 倍的间隔尝试：

选择能够让代价快速、持续下降的较大学习率。

11. 特征工程

特征工程是利用业务知识，从已有特征构造更有意义的新特征。

例如：

$x_1$：土地宽度；
$x_2$：土地深度。

可以构造土地面积：

$$x_3=x_1x_2$$

代码：

area = width * depth

模型变为：

$$f(\mathbf{x}) = w_1x_1+w_2x_2+w_3x_3+b$$

相比只使用宽度和深度，面积可能与房价具有更直接的关系。

12. 多项式回归

假设真实数据为：

$$y=1+x^2$$

如果只使用原始特征 $x$，线性回归只能拟合直线：

$$f(x)=wx+b$$

可以构造平方特征：

x = np.arange(0, 20, 1)
y = 1 + x ** 2

X = (x ** 2).reshape(-1, 1)

模型变为：

$$f(x)=w_1x^2+b$$

虽然它对原始变量 $x$ 是非线性的，但对参数 $w_1,b$ 仍然是线性的，所以仍可以使用线性回归的训练方法。

不知道应该使用几次项时，可以构造多个候选特征：

X = np.c_[
 x,
 x ** 2,
 x ** 3
]

对应模型：

$$f(x) = w_1x+w_2x^2+w_3x^3+b$$

多项式特征必须注意尺度

如果：

x：1～1000

那么：

x²：1～1,000,000
x³：1～1,000,000,000

尺度差异会非常大，因此应进行标准化：

X = np.c_[x, x ** 2, x ** 3]
X_norm, mu, sigma = zscore_normalize_features(X)

特征缩放后，可以使用更大的学习率，训练速度会明显提高。

13. 使用 Scikit-Learn

Scikit-Learn 可以直接完成标准化和梯度下降回归。

import numpy as np

from sklearn.linear_model import SGDRegressor
from sklearn.preprocessing import StandardScaler

13.1 标准化训练数据

scaler = StandardScaler()
X_norm = scaler.fit_transform(X_train)

fit_transform() 包含两步：

fit → 从训练集计算均值和标准差
transform → 使用这些统计量转换数据

13.2 创建并训练模型

sgdr = SGDRegressor(
 max_iter=1000,
 random_state=0
)

sgdr.fit(X_norm, y_train)

查看训练信息：

print(sgdr.n_iter_) # 实际迭代轮数
print(sgdr.t_) # 权重更新次数

查看参数：

w_norm = sgdr.coef_
b_norm = sgdr.intercept_

print(w_norm)
print(b_norm)

这些参数对应的是标准化后的输入数据，不能直接按原始面积、卧室数量的单位解释。

13.3 进行预测

y_pred_sgd = sgdr.predict(X_norm)

也可以手动计算：

y_pred_manual = X_norm @ w_norm + b_norm

检查两种结果：

np.allclose(
 y_pred_sgd,
 y_pred_manual
)

不要使用：

(y_pred_sgd == y_pred_manual).all()

浮点数运算可能存在很小的舍入误差，应使用 np.allclose()。

13.4 预测新房屋

x_house = np.array([
 [1200, 3, 1, 40]
])

x_house_norm = scaler.transform(x_house)
price = sgdr.predict(x_house_norm)

print(price)

对新数据只能调用：

scaler.transform()

不能再次调用：

scaler.fit_transform()

因为重新 fit 会改变标准化使用的均值和标准差。

13.5 SGD 与批量梯度下降的区别

手写实验使用的是批量梯度下降：

使用全部训练样本
→ 计算一次平均梯度
→ 更新一次参数

SGDRegressor 使用随机梯度下降：

依次使用单个样本或小批次
→ 更频繁地更新参数

两者都在尝试降低代价函数，但参数更新方式不同。

14. Notebook 中的 NameError

实验中出现：

NameError: name 'plt' is not defined
NameError: name 'load_house_data' is not defined
NameError: name 'run_gradient_descent' is not defined

这通常不是模型或公式的问题，而是依赖单元格没有运行。

Notebook 中的变量只存在于当前内核的内存里。重启内核、断线或者跳过前面的单元格，都会导致变量不存在。

正确运行顺序：

1. 运行 import 单元格
2. 运行辅助函数单元格
3. 加载训练数据
4. 标准化数据
5. 训练模型
6. 计算预测
7. 绘制图像

如果 Notebook 状态混乱，可以使用：

Restart Kernel and Run All

15. 高频易错点

w 和 b 必须同步更新 同一轮参数更新必须使用更新前计算出的同一组梯度。
更新公式使用减号 梯度指向代价上升方向，因此需要减去梯度。
特征尺度差异会拖慢收敛 面积、卧室数量、楼层、房龄应进行缩放。
预测新数据必须复用训练集统计量 不能为新样本重新计算均值和标准差。
多项式特征更需要缩放 $x,x^2,x^3$ 的数值范围可能相差多个数量级。
浮点数不要直接使用 == 比较 使用 np.isclose() 或 np.allclose()。
权重较大不一定代表特征更重要 权重大小受到特征尺度影响，也不代表因果关系。
SGDRegressor 不是批量梯度下降 它使用随机梯度下降，只是优化目标与线性回归相似。

16. 一页实践模板

import numpy as np
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import SGDRegressor

# 1. 准备数据
X_train, y_train = load_house_data()

# 2. 标准化
scaler = StandardScaler()
X_norm = scaler.fit_transform(X_train)

# 3. 训练
model = SGDRegressor(
 max_iter=1000,
 random_state=0
)
model.fit(X_norm, y_train)

# 4. 训练集预测
y_pred = model.predict(X_norm)

# 5. 新数据预测
x_new = np.array([
 [1200, 3, 1, 40]
])
x_new_norm = scaler.transform(x_new)
prediction = model.predict(x_new_norm)

# 6. 检查手动计算
manual_prediction = (
 X_norm @ model.coef_
 + model.intercept_
)

print(np.allclose(
 y_pred,
 manual_prediction
))

整组实验最重要的主线是：

准备训练数据
→ 检查特征尺度
→ 使用训练集统计量标准化
→ 选择学习率
→ 运行梯度下降
→ 观察代价是否持续下降
→ 保存参数和标准化器
→ 用相同的转换处理新数据
→ 进行预测

一句话总结：

梯度下降负责寻找参数，特征缩放负责让寻找过程更快、更稳定，学习曲线负责判断训练是否正常，特征工程负责让线性模型表达更复杂的关系。

多元线性回归与 NumPy 向量化

Sun, 26 Jul 2026 00:00:00 +0800

1. 多元线性回归

1.1 从单特征到多特征

单变量线性回归只使用一个特征：

$$ f_{w,b}(x)=wx+b $$

多元线性回归同时使用多个特征。例如预测房价时，可以使用：

$x_0$：房屋面积
$x_1$：卧室数量
$x_2$：楼层数
$x_3$：房屋年龄

若共有 $n$ 个特征，则一个样本写成：

$$ \mathbf{x}^{(i)} = \left[x_0^{(i)},x_1^{(i)},\ldots,x_{n-1}^{(i)}\right] $$

其中：

$i$ 表示第几个训练样本；
$j$ 表示第几个特征；
$x_j^{(i)}$ 表示第 $i$ 个样本的第 $j$ 个特征。

数学教材常从 1 开始编号；Python 和本实验从 0 开始编号。

1.2 模型

多元线性回归模型为：

$$ f_{\mathbf{w},b}(\mathbf{x}) =w_0x_0+w_1x_1+\cdots+w_{n-1}x_{n-1}+b $$

使用向量点积可以简写为：

$$ \boxed{f_{\mathbf{w},b}(\mathbf{x})=\mathbf{w}\cdot\mathbf{x}+b} $$

其中：

$\mathbf{w}=[w_0,w_1,\ldots,w_{n-1}]$ 是长度为 $n$ 的参数向量；
$b$ 是标量偏置；
$\mathbf{w}\cdot\mathbf{x}=\sum_{j=0}^{n-1}w_jx_j$。

例如：

$$ f(\mathbf{x})=0.1x_0+4x_1+10x_2-2x_3+80 $$

如果房价单位为千美元，可解释为：面积每增加 1 平方英尺，预测价格增加 0.1 千美元；房龄每增加 1 年，预测价格减少 2 千美元。参数表达的是“其他特征保持不变时”的线性影响。

“多元线性回归”指多个输入特征。它不同于统计学中具有多个输出变量的“多变量回归”。

2. 训练数据的矩阵表示

若有 $m$ 个训练样本，每个样本有 $n$ 个特征，则输入数据组成矩阵：

$$ \mathbf{X}\in\mathbb{R}^{m\times n} $$

每一行是一个训练样本；
每一列是一种特征；
X[i, j] 是第 i 个样本的第 j 个特征；
X[i] 或 X[i, :] 是第 i 个样本的特征向量。

实验数据：

import numpy as np

X_train = np.array([
 [2104, 5, 1, 45],
 [1416, 3, 2, 40],
 [ 852, 2, 1, 35]
])
y_train = np.array([460, 232, 178])

其形状为：

X_train.shape # (3, 4)：3 个样本、4 个特征
y_train.shape # (3,)：3 个目标值

参数示例：

w_init = np.array([
 0.39133535,
 18.75376741,
 -53.36032453,
 -26.42131618
])
b_init = 785.1811367994083

w_init.shape # (4,)

3. 用 NumPy 实现预测

3.1 循环版本

def predict_single_loop(x, w, b):
 p = 0.0
 for j in range(x.shape[0]):
 p += x[j] * w[j]
 return p + b

3.2 向量化版本

def predict(x, w, b):
 return np.dot(x, w) + b

使用方式：

x_vec = X_train[0]
prediction = predict(x_vec, w_init, b_init)

x_vec 和 w_init 的形状都是 (4,)，np.dot(x_vec, w_init) 返回一个标量。

向量化版本的优势：

代码更短、更容易阅读；
底层使用经过优化的数值计算程序；
可利用 CPU 的并行指令及专门的线性代数库；
对大规模数据通常远快于 Python 层的显式循环。

向量化并不意味着“所有运算一定在一个时钟周期完成”，而是将循环交给优化后的底层实现，从而减少 Python 解释器开销并更充分地利用硬件。

4. 代价函数

单个样本的误差为：

$$ e^{(i)} =f_{\mathbf{w},b}(\mathbf{x}^{(i)})-y^{(i)} $$

平方误差代价函数：

$$ \boxed{ J(\mathbf{w},b) =\frac{1}{2m} \sum_{i=0}^{m-1} \left( f_{\mathbf{w},b}(\mathbf{x}^{(i)})-y^{(i)} \right)^2 } $$

Python 实现：

def compute_cost(X, y, w, b):
 m = X.shape[0]
 cost = 0.0

 for i in range(m):
 prediction = np.dot(X[i], w) + b
 cost += (prediction - y[i]) ** 2

 return cost / (2 * m)

进一步向量化：

def compute_cost_vectorized(X, y, w, b):
 errors = X @ w + b - y
 return np.sum(errors ** 2) / (2 * X.shape[0])

其中 @ 在这里执行矩阵与向量的乘法：

X : (m, n)
w : (n,)
X @ w : (m,)
y : (m,)

5. 多元线性回归的梯度

对每个参数 $w_j$：

$$ \boxed{ \frac{\partial J}{\partial w_j} =\frac{1}{m} \sum_{i=0}^{m-1} \left( f_{\mathbf{w},b}(\mathbf{x}^{(i)})-y^{(i)} \right)x_j^{(i)} } $$

对偏置 $b$：

$$ \boxed{ \frac{\partial J}{\partial b} =\frac{1}{m} \sum_{i=0}^{m-1} \left( f_{\mathbf{w},b}(\mathbf{x}^{(i)})-y^{(i)} \right) } $$

循环实现：

def compute_gradient(X, y, w, b):
 m, n = X.shape
 dj_dw = np.zeros(n)
 dj_db = 0.0

 for i in range(m):
 error = np.dot(X[i], w) + b - y[i]
 for j in range(n):
 dj_dw[j] += error * X[i, j]
 dj_db += error

 return dj_db / m, dj_dw / m

完全向量化实现：

def compute_gradient_vectorized(X, y, w, b):
 m = X.shape[0]
 errors = X @ w + b - y
 dj_dw = X.T @ errors / m
 dj_db = np.sum(errors) / m
 return dj_db, dj_dw

形状检查：

errors : (m,)
X.T : (n, m)
X.T @ errors : (n,)
dj_dw : (n,)
dj_db : scalar

6. 批量梯度下降

更新规则：

$$ w_j \leftarrow w_j-\alpha\frac{\partial J}{\partial w_j} $$$$ b \leftarrow b-\alpha\frac{\partial J}{\partial b} $$

向量形式：

$$ \boxed{ \mathbf{w} \leftarrow \mathbf{w}-\alpha\nabla_{\mathbf{w}}J } $$

实现：

import copy
import math

def gradient_descent(
 X, y, w_in, b_in,
 cost_function, gradient_function,
 alpha, num_iters
):
 w = copy.deepcopy(w_in)
 b = b_in
 J_history = []

 for i in range(num_iters):
 dj_db, dj_dw = gradient_function(X, y, w, b)

 # 使用同一次迭代计算出的梯度，同时更新所有参数
 w = w - alpha * dj_dw
 b = b - alpha * dj_db

 if i < 100_000:
 J_history.append(cost_function(X, y, w, b))

 if i % math.ceil(num_iters / 10) == 0:
 print(f"Iteration {i:4d}: Cost {J_history[-1]:8.2f}")

 return w, b, J_history

实验设置：

initial_w = np.zeros_like(w_init)
initial_b = 0.0
iterations = 1000
alpha = 5.0e-7

w_final, b_final, J_hist = gradient_descent(
 X_train,
 y_train,
 initial_w,
 initial_b,
 compute_cost,
 compute_gradient,
 alpha,
 iterations
)

该实验的学习率很小，而且不同特征的数值范围差异大，因此 1000 次迭代后的预测仍不够准确。后续通常会通过特征缩放改善收敛速度。

7. NumPy 向量基础

7.1 一维数组

本课程用一维 NumPy 数组表示向量：

a = np.array([1, 2, 3, 4])
a.shape # (4,)

常用创建方式：

np.zeros(4) # 4 个 0
np.random.random_sample(4) # 4 个 [0, 1) 随机数
np.arange(4.0) # [0., 1., 2., 3.]
np.random.rand(4) # 4 个 [0, 1) 随机数

(4,) 表示含 4 个元素的一维数组，不是二维行矩阵 (1, 4)，也不是二维列矩阵 (4, 1)。

7.2 索引

a = np.arange(10)

a[2] # 第 3 个元素
a[-1] # 最后一个元素

访问一维数组的单个元素通常得到 NumPy 标量。

7.3 切片

格式：

a[start:stop:step]

stop 不包含在结果中。

a[2:7:1] # 索引 2、3、4、5、6
a[2:7:2] # 索引 2、4、6
a[3:] # 从索引 3 到末尾
a[:3] # 索引 0、1、2
a[:] # 全部元素，得到一个视图

7.4 常用向量运算

a = np.array([1, 2, 3, 4])

-a # 逐元素取负
np.sum(a) # 元素求和，返回标量
np.mean(a) # 均值，返回标量
a ** 2 # 逐元素平方
5 * a # 每个元素乘以 5

7.5 逐元素运算与点积

a = np.array([ 1, 2, 3, 4])
b = np.array([-1, 4, 3, 2])

a * b # 逐元素乘法，结果仍是向量
np.dot(a, b) # 点积：逐元素相乘后求和，结果是标量
a @ b # 对两个一维向量，同样是点积

手动实现点积：

def my_dot(a, b):
 result = 0.0
 for i in range(a.shape[0]):
 result += a[i] * b[i]
 return result

两个向量做逐元素运算或点积时，形状必须兼容。

7.6 向量性能示例

import time

size = 10_000_000
a = np.random.rand(size)
b = np.random.rand(size)

start = time.time()
vectorized_result = np.dot(a, b)
vectorized_time = time.time() - start

start = time.time()
loop_result = my_dot(a, b)
loop_time = time.time() - start

两种方法应给出近似相同的结果。浮点数运算顺序不同，可能造成极小的舍入误差，因此比较时宜使用：

np.isclose(vectorized_result, loop_result)

8. NumPy 矩阵基础

8.1 创建矩阵

二维数组使用形状元组：

np.zeros((1, 5)) # shape: (1, 5)
np.zeros((2, 1)) # shape: (2, 1)
np.random.random_sample((3, 4))

手动创建：

a = np.array([
 [5],
 [4],
 [3]
])

a.shape # (3, 1)

8.2 reshape

a = np.arange(6).reshape(3, 2)

结果：

[[0, 1],
 [2, 3],
 [4, 5]]

也可以写：

a = np.arange(6).reshape(-1, 2)

-1 表示让 NumPy 根据元素总数和另一个维度自动推断该维度。

8.3 矩阵索引

a[2, 0] # 第 3 行第 1 列的标量
a[2] # 第 3 行，返回 shape 为 (n,) 的一维数组
a[2, :] # 同上
a[:, 0] # 第 1 列，返回一维数组

8.4 矩阵切片

a = np.arange(20).reshape(-1, 10)

a[0, 2:7] # 第 1 行中索引 2 到 6
a[:, 2:7] # 所有行、索引 2 到 6 的列
a[:, :] # 全部行和列
a[1, :] # 第 2 行，结果是一维数组

9. 广播（Broadcasting）

广播允许 NumPy 在形状兼容时，将较小的数组“扩展”到较大的数组上执行逐元素运算。

最简单的例子是标量与向量：

a = np.array([1, 2, 3, 4])
a + 10
# [11, 12, 13, 14]

在线性模型中：

X @ w + b

X @ w 的形状是 (m,)，标量 b 会广播到每个预测值上。

判断广播是否兼容时，从形状的最后一个维度向前比较；对应维度相等，或其中一个为 1，通常即可广播。

广播很方便，但也可能隐藏形状错误。机器学习代码中应经常打印或断言 .shape。

10. 正态方程与梯度下降

线性回归还可以通过线性代数方法直接求解参数，常称为正态方程法。

特点：

无需像梯度下降那样反复迭代；
主要用于线性回归，不能自然推广到逻辑回归、神经网络等模型；
当特征数很大时，直接求解可能较慢；
实际项目中通常交给成熟的数值计算或机器学习库处理，不应手动计算矩阵逆。

本课程重点学习梯度下降，因为它能推广到更多机器学习模型。

11. 高频易错点

数学下标与 Python 下标不同

数学讲解可能从 1 开始；NumPy 从 0 开始。
(n,) 不等于 (n, 1)

前者是一维数组，后者是二维列矩阵。
a * b 不等于 np.dot(a, b)

前者逐元素相乘，后者对一维向量返回点积。
切片右端不包含

a[2:7] 包含索引 2 到 6。
更新梯度下降参数时要同步

同一轮中的 w 和 b 都应使用更新前的同一组梯度。
特征尺度会影响梯度下降速度

面积可能是上千，楼层数可能只有 1～3；尺度差异大会使代价函数狭长，导致收敛缓慢。
学习率过大或过小都不好

过大可能使代价震荡或发散；过小则收敛很慢。
浮点数结果不要直接用 == 比较

使用 np.isclose 或 np.allclose。
课程原文中的翻译错误

向量 [1,2,3,4] 的 shape (4,) 是一维，不是“二维向量”；向量的元素个数常称为长度或维数，而 NumPy 数组的 ndim 表示轴的数量。

12. 一页速记

# 预测
y_hat = X @ w + b

# 误差
errors = y_hat - y

# 代价
J = np.sum(errors ** 2) / (2 * m)

# 梯度
dj_dw = X.T @ errors / m
dj_db = np.sum(errors) / m

# 更新
w = w - alpha * dj_dw
b = b - alpha * dj_db

对应的核心公式：

$$ \boxed{ \hat{\mathbf{y}}=\mathbf{X}\mathbf{w}+b } $$$$ \boxed{ J(\mathbf{w},b)=\frac{1}{2m}\|\hat{\mathbf{y}}-\mathbf{y}\|_2^2 } $$$$ \boxed{ \nabla_{\mathbf{w}}J =\frac{1}{m}\mathbf{X}^{T}(\hat{\mathbf{y}}-\mathbf{y}) } $$$$ \boxed{ \frac{\partial J}{\partial b} =\frac{1}{m}\sum_{i=0}^{m-1}(\hat y^{(i)}-y^{(i)}) } $$

掌握这一条主线即可：

样本矩阵 X
→ 点积得到预测
→ 预测减目标得到误差
→ 由误差计算代价和梯度
→ 用梯度下降更新 w、b

机器学习基础：用梯度下降法训练模型

Sat, 25 Jul 2026 00:00:00 +0800

一、学习目标

梯度下降如何更新参数 $w$ 和 $b$？
导数项为什么能指引下降方向？
学习率 $\alpha$ 应该如何理解和选择？
如何用梯度下降训练一元线性回归模型？

二、梯度下降算法

梯度下降通过不断调整模型参数，使成本函数 $J(w,b)$ 尽可能小。

参数更新公式为：

$$w := w - \alpha \frac{\partial J(w,b)}{\partial w}$$$$b := b - \alpha \frac{\partial J(w,b)}{\partial b}$$

不断重复以上更新，直到算法收敛。

符号含义

符号	含义
$w, b$	模型参数
$J(w,b)$	成本函数，衡量预测误差
$\alpha$	学习率，控制每次更新的步长
$\frac{\partial J}{\partial w}$	成本函数相对于 $w$ 的偏导数
$\frac{\partial J}{\partial b}$	成本函数相对于 $b$ 的偏导数
$:=$	赋值，用右侧结果更新左侧变量

赋值与相等的区别

$w := w - \alpha \frac{\partial J}{\partial w}$ 表示“计算右边的结果，然后把结果存入 $w$”，而不是断言左右两边在数学上永远相等。

在 Python 中，= 是赋值，== 是相等性判断。

三、为什么必须同时更新 $w$ 和 $b$

梯度下降要求两个参数基于同一组旧参数进行更新。

正确做法：

temp_w = w - alpha * dj_dw # dj_dw 和 dj_db 都根据更新前的 w, b 计算
temp_b = b - alpha * dj_db

w = temp_w
b = temp_b

不正确的顺序更新：

temp_w = w - alpha * dj_dw
w = temp_w # w 已被更新

temp_b = b - alpha * dj_db # 此时计算用的是新的 w，不是旧的
b = temp_b

问题在于：计算新 $b$ 时，$w$ 已经被更新，两个参数不再基于同一个旧状态进行计算。标准梯度下降所指的是同步更新。

四、导数项的直观含义

为了理解导数，暂时只考虑一个参数：

$$w := w - \alpha \frac{dJ(w)}{dw}$$

导数表示成本曲线在当前位置的斜率。

导数为正

$$\frac{dJ}{dw} > 0 \implies w_{\text{new}} = w - \text{正数}$$

$w$ 变小，在图像上向左移动。当位于最低点右侧时，向左移动能够降低成本。

导数为负

$$\frac{dJ}{dw} < 0 \implies w_{\text{new}} = w - \alpha(\text{负数}) = w + \text{正数}$$

$w$ 变大，在图像上向右移动。当位于最低点左侧时，向右移动能够降低成本。

导数为零

在局部最小值处，$\frac{dJ}{dw} = 0$，于是 $w_{\text{new}} = w$，参数保持不变。梯度下降到达最低点后会自然停止移动。

核心直觉

梯度下降之所以使用“减去导数”，是因为导数指向函数增长最快的方向，而导数的反方向能够降低成本。

五、学习率 $\alpha$

学习率控制每次参数更新的步长，通常取较小的正数，例如 $\alpha = 0.01$。

学习率太小

每次更新的步长很小
成本通常仍会下降，但需要大量迭代
训练速度非常慢

学习率太大

参数可能跨过最低点
成本可能反而增加
参数可能在最低点两侧来回震荡
算法可能无法收敛，甚至发散

为什么固定学习率也能收敛

当参数逐渐接近最低点时，成本函数的斜率会越来越小：$\left|\frac{dJ}{dw}\right| \to 0$

即使学习率 $\alpha$ 保持不变，实际更新量 $\alpha \frac{dJ}{dw}$ 也会自然变小。因此梯度下降通常表现为：

离最低点较远时步长较大
接近最低点时步长逐渐减小
最终停留在最低点附近

六、一元线性回归模型

模型为：

$$f_{w,b}(x) = wx + b$$

其中 $x$ 是输入特征（如房屋面积），$f_{w,b}(x)$ 是预测值（如预测房价），$w$ 是斜率，$b$ 是截距。

七、平方误差成本函数

使用 $m$ 个训练样本时，成本函数为：

$$J(w,b) = \frac{1}{2m} \sum_{i=1}^{m} \left(f_{w,b}(x^{(i)}) - y^{(i)}\right)^2$$

其中 $x^{(i)}$ 是第 $i$ 个样本的输入，$y^{(i)}$ 是真实值，$m$ 是训练样本数量。

前面的 $\frac{1}{2}$ 是为了在求导时抵消平方项产生的系数 2，使梯度公式更简洁。

八、线性回归的梯度公式

成本函数相对于 $w$ 的偏导数：

$$\frac{\partial J(w,b)}{\partial w} = \frac{1}{m} \sum_{i=1}^{m} \left(f_{w,b}(x^{(i)}) - y^{(i)}\right) x^{(i)}$$

成本函数相对于 $b$ 的偏导数：

$$\frac{\partial J(w,b)}{\partial b} = \frac{1}{m} \sum_{i=1}^{m} \left(f_{w,b}(x^{(i)}) - y^{(i)}\right)$$

两者的区别：$w$ 的导数末尾需要乘 $x^{(i)}$，$b$ 的导数不需要。

九、完整的梯度下降算法

每轮迭代先计算：

$$d_w = \frac{1}{m} \sum_{i=1}^{m} \left(wx^{(i)} + b - y^{(i)}\right) x^{(i)}$$$$d_b = \frac{1}{m} \sum_{i=1}^{m} \left(wx^{(i)} + b - y^{(i)}\right)$$

然后同步更新：

$$w := w - \alpha \, d_w$$$$b := b - \alpha \, d_b$$

重复以上过程，直到成本不再明显下降，或者参数变化已经非常小。

十、收敛、局部最小值与全局最小值

收敛

梯度下降“收敛”通常表示：成本函数不再明显下降，$w$ 和 $b$ 的变化越来越小，参数已经接近某个最小值。

局部最小值 vs 全局最小值

局部最小值：某个点比附近其他点都低，但不一定是整个函数的最低点
全局最小值：在所有可能的参数取值中，成本函数值最低的点

线性回归的优势

线性回归的平方误差成本函数是凸函数（碗形函数），具有以下性质：

只有一个全局最小值
不存在多个不同的局部最小值
只要学习率选择合理，梯度下降就能收敛到全局最小值

十一、批量梯度下降

上述算法属于批量梯度下降（Batch Gradient Descent）。“批量”表示每次更新参数时都使用全部 $m$ 个训练样本（$\sum_{i=1}^{m}$），即每轮更新都会遍历整个训练集。

其他梯度下降方法可能每次只使用一个训练样本或一小批训练样本，但当前的一元线性回归使用的是完整训练集。

十二、Python 实现

计算梯度

def compute_gradient(x, y, w, b):
 m = x.shape[0]
 dj_dw = 0
 dj_db = 0

 for i in range(m):
 f_wb = w * x[i] + b # 预测值
 error = f_wb - y[i] # 预测误差

 dj_dw += error * x[i] # w 的梯度需要乘 x[i]
 dj_db += error # b 的梯度不需要乘 x[i]

 dj_dw /= m
 dj_db /= m

 return dj_dw, dj_db

计算成本

def compute_cost(x, y, w, b):
 m = x.shape[0]
 cost = 0

 for i in range(m):
 f_wb = w * x[i] + b
 cost += (f_wb - y[i]) ** 2

 return cost / (2 * m)

梯度下降主函数

def gradient_descent(x, y, w_in, b_in, alpha, num_iters,
 cost_function, gradient_function):
 J_history = []
 p_history = []

 w = w_in
 b = b_in

 for i in range(num_iters):
 # 先计算两个梯度（基于当前的 w, b）
 dj_dw, dj_db = gradient_function(x, y, w, b)

 # 同步更新参数
 w = w - alpha * dj_dw
 b = b - alpha * dj_db

 # 保存代价和参数（用于可视化）
 if i < 100000:
 J_history.append(cost_function(x, y, w, b))
 p_history.append([w, b])

 # 定期输出训练过程
 if i % math.ceil(num_iters / 10) == 0:
 print(f"Iteration {i:4}: Cost {J_history[-1]:0.2e} "
 f"w: {w:0.3e}, b: {b:0.5e}")

 return w, b, J_history, p_history

返回值：训练后的 w、b，每次迭代的代价 J_history，每次迭代的参数 p_history。

十三、运行实验

训练数据

x_train = np.array([1.0, 2.0]) # 房屋面积（千平方英尺）
y_train = np.array([300.0, 500.0]) # 房屋售价（千美元）

训练参数

w_init = 0
b_init = 0
iterations = 10000
alpha = 1.0e-2

运行

w_final, b_final, J_hist, p_hist = gradient_descent(
 x_train, y_train, w_init, b_init, alpha, iterations,
 compute_cost, compute_gradient
)

最终结果约为 $w \approx 199.99$，$b \approx 100.01$，即模型为 $f(x) = 200x + 100$。

梯度下降的收敛特点

成功运行时可以观察到：

代价在开始阶段迅速下降
dj_dw 和 dj_db 的绝对值逐渐减小
越接近最低点，梯度越小
梯度变小后，参数更新速度也会变慢
代价应持续下降并逐渐稳定

虽然学习率 $\alpha$ 保持不变，但实际更新量 = $\alpha \times$ 梯度，梯度变小时更新幅度自然变小。

十四、可视化

代价变化曲线

fig, (ax1, ax2) = plt.subplots(1, 2, constrained_layout=True, figsize=(12, 4))

ax1.plot(J_hist[:100]) # 训练初期：代价下降很快
ax2.plot(1000 + np.arange(len(J_hist[1000:])), J_hist[1000:]) # 训练后期：下降较慢

ax1.set_title("Cost vs. iteration (start)")
ax2.set_title("Cost vs. iteration (end)")
ax1.set_ylabel("Cost")
ax2.set_ylabel("Cost")
ax1.set_xlabel("Iteration step")
ax2.set_xlabel("Iteration step")
plt.show()

分开绘制是因为训练初期和后期下降速度差异大，用不同范围可以更清楚地观察变化。

梯度下降路径（等高线图）

fig, ax = plt.subplots(1, 1, figsize=(12, 6))
plt_contour_wgrad(x_train, y_train, p_hist, ax)
plt.show()

等高线代表不同的代价值，箭头代表参数 $(w, b)$ 的更新路径。可以观察到：参数不断向最低点移动，开始时梯度大步幅也大，接近最低点时梯度变小步幅缩短。

十五、模型预测

训练完成后，使用 $\hat{y} = w_{\text{final}} x + b_{\text{final}}$ 进行预测：

print(f"1000 sqft: {w_final * 1.0 + b_final:.1f} Thousand dollars")
print(f"1200 sqft: {w_final * 1.2 + b_final:.1f} Thousand dollars")
print(f"2000 sqft: {w_final * 2.0 + b_final:.1f} Thousand dollars")

房屋面积	预测售价
1000 平方英尺	300 千美元
1200 平方英尺	340 千美元
2000 平方英尺	500 千美元

虽然 1200 平方英尺不在训练数据中，模型仍可以根据学到的线性关系进行预测。

十六、学习率的影响

合适的学习率

代价持续下降，参数逐渐靠近最优值，算法最终收敛

学习率过小

更新步幅很小，算法能够稳定收敛，但训练速度较慢

学习率过大

参数可能跨过最低点，$w$ 和 $b$ 在正负之间振荡
梯度符号反复变化，参数绝对值越来越大
代价不断上升，算法最终发散

判断学习率过大的典型信号：

代价不降反升
参数绝对值越来越大
梯度不断改变符号
参数在最低点两侧大幅振荡

例如将学习率改为 0.8，只跑 10 次迭代就能观察到发散过程。

十七、常见错误与检查方法

没有同步更新参数：应先计算新 $w$ 和新 $b$，再统一赋值
学习率过小：成本下降但极其缓慢 → 适当增大 $\alpha$
学习率过大：成本上下震荡或越来越大 → 减小 $\alpha$
导数公式漏乘 $x^{(i)}$：计算 $w$ 的梯度时必须包含 $\text{error} \times x^{(i)}$，$b$ 的梯度只有误差项
没有观察成本变化：训练过程中应定期计算 $J(w,b)$，正常情况下成本应总体持续下降

十八、核心知识总结

梯度下降的目标是通过调整参数来最小化成本函数
学习率 $\alpha$ 控制每次更新的步长
导数的符号决定参数移动方向，大小影响移动幅度
$w$ 和 $b$ 必须基于同一组旧值同步更新
学习率太小导致收敛缓慢，太大导致震荡或发散
接近最低点时导数自然变小，更新步长也会变小
线性回归的平方误差成本函数是凸函数，只有一个全局最小值
批量梯度下降每次更新都会使用全部训练样本
训练完成后，使用 $f_{w,b}(x) = wx + b$ 对新数据进行预测

机器学习基础：线性回归模型

Tue, 21 Jul 2026 00:00:00 +0800

线性回归是机器学习里最适合入门的模型之一：它足够简单，可以把输入、预测、参数、成本函数这些核心概念讲清楚；它也足够重要，因为后续更复杂的模型训练，仍然离不开这些基本思想。本篇整理 Coursera 机器学习课程中的线性回归内容，从房价预测案例出发，梳理模型函数、训练数据、成本函数和梯度下降之间的关系。

线性回归的基本概念

线性回归（Linear Regression） 是一种监督学习模型，通过为数据拟合一条直线来预测连续数值。

以房价预测为例：

输入 x：房屋面积
输出 y：房屋价格
模型：一条尽可能贴合训练数据的直线

可将模型表示为：

$$\hat{y} = f_{w,b}(x) = wx + b$$

其中：

$x$：输入特征，例如房屋面积
$\hat{y}$：模型预测的房屋价格
$w$：直线的斜率
$b$：直线的截距

因为只有一个输入特征，这种模型称为单变量线性回归（Univariate Linear Regression）。“单变量”表示模型只有一个输入变量，而不是只有一个参数，该模型仍然包含两个参数 $w$ 和 $b$。

以后还可以使用多个输入特征预测房价，例如房屋面积、卧室数量、浴室数量、房屋年龄、地理位置等，属于多变量或多特征线性回归。

训练集与符号约定

训练集

用于训练模型的数据称为训练集（Training Set）。

房价预测的训练数据来自美国波特兰市，包含：

房屋面积，单位为平方英尺
房屋售价，单位为千美元

同一组数据可以通过两种方式表示：

散点图：横轴为房屋面积，纵轴为房屋价格，每个数据点对应一套已售房屋。如果训练集有 47 套房屋，图中就有 47 个数据点。

数据表：

房屋面积（平方英尺）	房屋价格（千美元）
2104	400
…	…

表格中的每一行对应一个训练示例，也对应散点图中的一个数据点。例如面积 2104 平方英尺，售价 400 千美元，即 400,000 美元。

符号约定

符号	含义	房价示例
$x$	输入特征（Feature）	房屋面积
$y$	真实值（Label / Target Variable）	房屋实际售价
$\hat{y}$	模型预测值	预测房价
$f_{w,b}(x)$	参数为 $w, b$ 的模型对 $x$ 的预测	$\hat{y} = wx + b$
$m$	训练样本总数	47
$(x^{(i)}, y^{(i)})$	第 $i$ 个训练样本	$(2104, 400)$

一个完整的训练示例由输入和正确输出组成 $(x, y)$。第 $i$ 个训练示例表示为 $(x^{(i)}, y^{(i)})$，其中 $x^{(i)}$ 是第 $i$ 个样本的输入，$y^{(i)}$ 是第 $i$ 个样本的正确输出。

需要特别注意：$x^{(2)}$ 表示“第二个训练示例的输入”，不是 $x$ 的平方。括号中的上标只是训练样本的编号。

为什么称为监督学习

训练集中同时提供了输入（房屋面积）和正确输出（房屋实际售价）。每套已售房屋的数据都相当于向模型提供一个带答案的学习示例，因此这种学习方式称为“监督学习”。

基本流程：

收集包含输入和正确输出的数据
使用这些数据训练模型
模型学习输入与输出之间的规律
将新输入交给模型
模型预测相应的输出

参数 $w$ 和 $b$ 的作用

斜率 $w$

$w$ 决定直线的倾斜程度：

w > 0：直线向右上方倾斜，x 增大时预测值增大
w = 0：直线是水平的，预测值不随 x 变化
w < 0：直线向右下方倾斜，x 增大时预测值减小

在房价问题中，$w$ 可以理解为房屋面积每增加一个单位，预测价格增加多少。$w$ 也称为权重或系数。

截距 $b$

$b$ 决定直线与纵轴的交点。当 $x = 0$ 时：

$$f(0) = b$$

因此 $b$ 是模型在输入为零时的预测值。

示例

当 $w = 0, b = 1.5$ 时：

$$f(x) = 1.5$$

无论输入是多少，预测结果始终为 1.5。

当 $w = 0.5, b = 0$ 时：

$$f(x) = 0.5x$$

直线斜率为 0.5，经过原点。

当 $w = 0.5, b = 1$ 时：

$$f(x) = 0.5x + 1$$

直线斜率仍为 0.5，但与纵轴相交于 1。

假设 $f(x) = 0.1x + 50$，当房屋面积为 1250 平方英尺时：

$$\hat{y} = 0.1 \times 1250 + 50 = 175$$

预测价格为 175,000 美元。

不同的 $w$ 和 $b$ 会形成不同的直线，也会产生不同的预测结果。

学习算法的任务

训练线性回归模型的核心任务，是根据训练数据选择合适的 $w$ 和 $b$，使直线尽可能贴近数据点。

完整过程可以表示为：

$$\{(x^{(i)}, y^{(i)})\}_{i=1}^{m} \longrightarrow \text{学习算法} \longrightarrow w, b \longrightarrow f_{w,b}(x)$$

也就是说：

将训练数据交给学习算法
学习算法寻找合适的 $w$ 和 $b$
得到模型 $f_{w,b}(x) = wx + b$
用模型预测新输入对应的 $\hat{y}$

客户的房屋尚未出售，因此其真实价格不在训练集中。模型需要先从已售房屋的数据中学习，再预测这套房屋的价格。

$y$ 与 $\hat{y}$ 的区别

$y$：实际目标值

$y$ 表示训练数据中的真实答案。例如 $y = 400$ 表示某套房屋的实际售价为 400 千美元。

$\hat{y}$：预测值

$\hat{y}$ 读作 “y hat”，表示模型对 $y$ 的估计：

$$\hat{y} = f_{w,b}(x) = wx + b$$

预测值不一定等于实际值：

$$\hat{y} \neq y$$

例如，模型预测某套房屋售价为 220,000 美元，但只有房屋真正售出后，才能知道真实售价 $y$。

需要明确区分：

$$\boxed{y = \text{真实值}, \qquad \hat{y} = \text{预测值}}$$

成本函数

为什么需要成本函数

不同的 $w$ 和 $b$ 会产生不同的直线。成本函数的作用是：

衡量一组 $w, b$ 所产生的直线，对训练数据拟合得有多好。

成本越小，通常说明预测值越接近真实值。

预测误差

对于第 $i$ 个训练样本 $(x^{(i)}, y^{(i)})$，模型预测值为：

$$\hat{y}^{(i)} = f_{w,b}(x^{(i)})$$

预测误差为：

$$\hat{y}^{(i)} - y^{(i)} = \text{预测值} - \text{真实值}$$

例如，模型预测价格为 280，真实价格为 300：

$$280 - 300 = -20$$

误差为 $-20$，表示模型低估了价格。

平方误差成本函数

线性回归常用的成本函数是平方误差成本函数：

$$\boxed{J(w,b) = \frac{1}{2m} \sum_{i=1}^{m} \left(f_{w,b}(x^{(i)}) - y^{(i)}\right)^2}$$

也可以写成：

$$J(w,b) = \frac{1}{2m} \sum_{i=1}^{m} \left(\hat{y}^{(i)} - y^{(i)}\right)^2$$

计算过程：

计算每个样本的预测值
用预测值减去真实值
将误差平方
把所有平方误差相加
除以 $2m$

为什么误差要平方

如果直接将误差相加，正负误差可能互相抵消：

$$(-20) + 20 = 0$$

但模型实际产生了两次误差。平方以后：

$$(-20)^2 + 20^2 = 800$$

因此：

所有误差都会变成非负数
较大的误差会受到更明显的惩罚
成本不会因为正负抵消而错误地变小

为什么除以 $m$ 和 $2$

除以 $m$：$m$ 是训练样本数量。除以 $m$ 相当于计算平均误差，使成本不会仅仅因为训练数据变多而自动增大。

再除以 $2$：主要是为了让后续求导和梯度下降的公式更简洁。是否除以 $2$ 不会改变最佳参数的位置。

成本函数的直观示例

为了方便观察，暂时令 $b = 0$，模型简化为：

$$f_w(x) = wx$$

训练集为：

$$(1, 1), \quad (2, 2), \quad (3, 3)$$

当 $w = 1$

预测值为 1, 2, 3，全部等于真实值：

$$J(1) = 0$$

模型完美拟合训练数据。

当 $w = 0.5$

预测值为 0.5, 1, 1.5。平方误差为：

$$(0.5-1)^2 + (1-2)^2 + (1.5-3)^2 = 0.25 + 1 + 2.25 = 3.5$$$$J(0.5) = \frac{3.5}{2 \times 3} \approx 0.58$$

当 $w = 0$

所有预测值都是 0：

$$J(0) = \frac{1^2 + 2^2 + 3^2}{6} = \frac{14}{6} \approx 2.33$$

当 $w = -0.5$

直线方向与数据趋势相反：

$$J(-0.5) = 5.25$$

结果对比

$w$	$J(w)$	拟合情况
$-0.5$	$5.25$	很差
$0$	$2.33$	较差
$0.5$	$0.58$	较好
$1$	$0$	最佳

这个例子中的最佳参数是 $w = 1$。

模型函数与成本函数的区别

两者容易混淆，需要明确区分：

模型函数 $f_{w,b}(x) = wx + b$

输入是 $x$（特征），输出是预测值 $\hat{y}$
模型图的坐标轴：横轴 $x$（房屋面积），纵轴 $y$ 或 $\hat{y}$（价格）
回答的问题：“这套房子预测多少钱？”

成本函数 $J(w,b)$

输入是模型参数 $w, b$，输出是模型的成本
成本图的坐标轴是参数和成本，而不是房屋面积与价格
回答的问题：“这组模型参数整体表现有多差？”

成本函数的图像

只有参数 $w$ 时（$b = 0$）

成本函数只有一个参数 $J(w)$，通常呈 U 形曲线：

成本 J
 ↑
 | \ /
 | \_____/
 +------------→ w
 最小值

最低点对应成本最小的 $w$。

同时使用 $w$ 和 $b$ 时

完整模型包含两个参数 $J(w,b)$，这时成本函数是一个三维曲面，通常类似碗形：

一个方向代表 $w$
一个方向代表 $b$
曲面的高度代表成本 $J(w,b)$

碗底对应成本函数的最小值，也就是最佳的 $w, b$。

等高线图

三维成本函数也可以用二维的等高线图表示。每条椭圆线表示成本相同的一组 $w, b$：

$$J(w_1, b_1) = J(w_2, b_2)$$

可以把等高线图理解成从正上方观察碗形曲面：

外层椭圆：成本通常较高
越靠近中心：成本通常越低
最内层椭圆中心：成本最小值附近

不同的 $w, b$ 即使成本相同，也可能对应不同的模型直线。

训练目标与梯度下降

训练目标

线性回归最终需要解决的问题是：

$$\boxed{\min_{w,b} J(w,b)}$$

也就是找到一组 $w, b$，使成本函数尽可能小。

完整逻辑：

选择 w, b
 ↓
得到直线 f(x) = wx + b
 ↓
计算每个样本的预测误差
 ↓
计算成本 J(w,b)
 ↓
不断调整 w, b
 ↓
找到成本最小的参数

为什么需要梯度下降

理论上可以手动尝试很多组 $w, b$，计算每一组参数的成本，再选择成本最低的一组。但这种方法效率非常低，当模型参数很多时，几乎无法手动完成。

因此需要一种能够自动调整参数、寻找成本函数最小值的算法：

$$\boxed{\text{梯度下降（Gradient Descent）}}$$

梯度下降不仅用于线性回归，也是训练神经网络和许多复杂人工智能模型的基础算法。

成本函数的代码实现

def compute_cost(x, y, w, b):
 m = x.shape[0] # 训练样本数量

 cost_sum = 0
 for i in range(m):
 f_wb = w * x[i] + b # 第 i 个样本的预测值
 cost = (f_wb - y[i]) ** 2 # 平方误差
 cost_sum = cost_sum + cost # 累加

 total_cost = cost_sum / (2 * m) # 计算平均成本
 return total_cost

逐步理解：

m = x.shape[0]：获取训练样本数量
cost_sum = 0：准备变量，累计所有样本的平方误差
for i in range(m)：逐个处理训练样本
f_wb = w * x[i] + b：计算预测值 $\hat{y}^{(i)} = wx^{(i)} + b$
cost = (f_wb - y[i]) ** 2：计算预测值和真实价格的平方误差
cost_sum = cost_sum + cost：把当前样本的误差加入总误差
total_cost = cost_sum / (2 * m)：按照成本函数公式计算最终成本

对应公式：

$$J(w,b) = \frac{1}{2m} \sum_{i=0}^{m-1} \left(wx^{(i)} + b - y^{(i)}\right)^2$$

验证示例

import numpy as np

x_train = np.array([1.0, 2.0])
y_train = np.array([300.0, 500.0])

w = 200
b = 100

两个预测分别是：

$$200 \times 1 + 100 = 300$$$$200 \times 2 + 100 = 500$$

预测值与真实值完全相同：

compute_cost(x_train, y_train, 200, 100) # 结果：0.0

这说明 $w = 200, b = 100$ 能完美拟合这两个数据点。

关键理解：

compute_cost() 只负责评价一组 $w, b$ 好不好
成本越小，模型对训练数据的拟合通常越好
两个点可以被一条直线完美穿过，因此成本可以为零；多个不共线的数据点无法全部完美命中，因此最低成本通常大于零

为什么先学线性模型

现实中的数据关系不一定是直线，也可能是曲线、抛物线或更复杂的非线性关系。但线性模型具有以下优点：

数学形式简单
容易理解和实现
便于观察模型参数的作用
是学习复杂机器学习模型的基础

因此，课程首先从线性函数入手，之后再扩展到非线性模型。

机器学习基础：监督学习与无监督学习

Mon, 20 Jul 2026 00:00:00 +0800

机器学习的任务看起来五花八门：预测房价、识别肿瘤、给新闻分组、发现异常交易。理解这些问题的第一步，是分清数据中有没有正确答案。本篇整理 Coursera 机器学习课程的基础内容，从这个区别出发，梳理监督学习与无监督学习的核心概念和典型应用。

监督学习

监督学习（Supervised Learning）让算法学习从输入 x 到输出 y 的映射：

$$x \longrightarrow y$$

也可以表示为：

$$\hat{y}=f(x)$$

x：输入或特征（Feature）
y：正确答案，也称标签（Label）
f：模型从数据中学习到的映射关系
\hat{y}：模型给出的预测结果

监督学习的核心特点是：训练数据中同时包含输入和正确答案。一条训练样本可以表示为 $(x,y)$。之所以称为“监督”学习，是因为正确标签 y 为算法提供了学习目标。

训练与预测

训练阶段向算法提供大量带标签的数据：

$$(x^{(1)},y^{(1)}),(x^{(2)},y^{(2)}),\ldots,(x^{(m)},y^{(m)})$$

算法观察输入与输出之间的关系，学习得到模型 f。训练完成后，将模型从未见过的新输入 x 交给模型，模型根据学到的规律输出预测结果 $\hat{y}$。

模型的目标不是简单记住训练数据，而是对未见过的数据也能作出准确预测。这种能力称为泛化能力（Generalization）。

典型应用

应用	输入 x	输出 y
垃圾邮件过滤	邮件内容	垃圾邮件 / 非垃圾邮件
语音识别	音频片段	对应文字
机器翻译	源语言文本	目标语言文本
在线广告	广告信息与用户信息	用户是否会点击
自动驾驶	图像、雷达等传感器数据	周围车辆位置
工业视觉检测	产品照片	有缺陷 / 无缺陷
房价预测	房屋面积等信息	房屋价格

每个应用的本质，都是从大量已标注样本中学习输入与输出之间的关系。

回归：预测一个数值

回归（Regression）是监督学习的一种，目标是预测一个可以连续变化的数值。

房价预测案例

假设输入是房屋面积，输出是房屋价格，现在需要预测一套 750 平方英尺的房屋值多少钱。

最简单的方法是拟合一条直线：

$$f(x)=wx+b$$

w：斜率，表示面积变化对价格的影响
b：截距

直线模型可能预测房屋价值约为 15 万美元。也可以拟合一条更复杂的曲线：

$$f(x)=w_2x^2+w_1x+b$$

曲线模型可能预测房屋价值接近 20 万美元。但不能因为某个模型给出的价格更高就选择它，而应该根据模型在数据上的客观表现进行选择。

模型太简单，可能无法充分学习规律；模型太复杂，则可能只记住训练数据，也就是发生过拟合（Overfitting），导致它在新数据上表现不好。

常见回归任务包括预测房价、气温、商品销量、运输时间和用户消费金额。它们的输出都可以在一定范围内连续变化。

分类：预测一个类别

分类（Classification）也是监督学习的一种，目标是预测一个离散类别。输出只能从有限数量的类别中选择，例如：

垃圾邮件 / 非垃圾邮件
有缺陷 / 无缺陷
猫 / 狗
患病 / 未患病

乳腺癌检测案例

假设要开发一个辅助医生诊断乳腺癌的系统，根据患者检查数据判断肿瘤属于：

良性（Benign）：不是癌症，危险程度相对较低
恶性（Malignant）：属于癌症，需要及时治疗

最简单的情况下，只使用肿瘤大小作为输入：

x：肿瘤大小
y：良性（0）或恶性（1）

每条训练数据可以表示为：

(1.2, 0)
(2.5, 0)
(4.8, 1)
(6.1, 1)

仅靠肿瘤大小可能不够准确，还可以同时使用患者年龄、肿块厚度、细胞大小均匀性和细胞形状均匀性等特征。此时，输入是一个包含多个特征的向量：

$$x=(x_1,x_2,\ldots,x_n)$$

监督学习中的 x 不一定是一个数字，也可以是一组特征。

决策边界

当输入包含肿瘤大小和患者年龄时，可以将样本画在二维坐标中：横轴是肿瘤大小，纵轴是患者年龄，圆圈表示良性，叉号表示恶性。

分类算法会尝试找到一条决策边界（Decision Boundary），将两类样本区分开来。新患者出现时，模型根据其特征位于边界的哪一侧预测类别。决策边界不一定是直线，也可能是曲线或更复杂的形状。

回归与分类的区别

对比项	回归	分类
预测目标	连续数值	离散类别
输出范围	可连续变化	有限个类别
典型输出	`183000`	良性 / 恶性
数字之间是否有连续意义	有	通常没有

判断标准是：模型在回答“具体是多少”，还是“属于哪一类”？

分类中的类别也可以用数字表示，例如 0 表示良性、1 表示恶性，但这些数字只是类别编号，不代表连续的数量关系。手写数字识别虽然输出 0 到 9，仍然属于分类，因为模型只需要从十个类别中选择，而不是预测任意连续数值。

二分类与多分类

只有两个可能类别的问题称为二分类（Binary Classification）：

问题	类别
垃圾邮件检测	垃圾 / 正常
欺诈检测	欺诈 / 正常
疾病检测	患病 / 未患病
广告点击预测	点击 / 不点击

存在三个及以上类别的问题称为多分类（Multiclass Classification）：

图片分类：猫 / 狗 / 鸟
新闻分类：体育 / 财经 / 科技 / 娱乐
手写数字识别：0～9
疾病诊断：疾病 A / 疾病 B / 疾病 C

类别可以用数字编号，也可以用文字表示。数字在这里只是标签，不能认为“狗 = 猫 + 1”。

无监督学习

无监督学习（Unsupervised Learning）的数据只有输入 x，没有输出标签 y：

$$x \quad \text{而不是} \quad (x,y)$$

算法需要自行从数据中寻找：

隐藏的结构
相似的数据群体
数据分布规律
异常的数据点
更简洁的数据表示

“无监督”表示训练数据没有为每个输入提供正确答案，并不代表算法不受控制，也不代表它比监督学习差。

与监督学习的对比

对比项	监督学习	无监督学习
输入数据	输入 x 和标签 y	只有输入 x
是否有正确答案	有	没有
学习目标	学习 x 到 y 的映射	发现数据中的结构和模式
典型任务	回归、分类	聚类、异常检测、降维
示例	房价预测、疾病诊断	客户分群、新闻聚类

以乳腺癌检测为例：如果数据包含患者年龄、肿瘤大小和良性/恶性标签，就可以用监督学习预测诊断结果；如果只有患者年龄和肿瘤大小而没有标签，算法只能寻找患者之间可能存在的群体或规律。

聚类：寻找相似群体

聚类（Clustering）的目标是将相似的数据点自动分配到同一个簇（Cluster）中。

它有三个特点：

数据没有预先定义的类别标签
算法根据数据之间的相似性进行分组
分组结果通常需要人结合领域知识解释

“相似”取决于选择了哪些特征，以及算法如何计算数据之间的距离。

谷歌新闻

谷歌新闻每天处理大量报道。如果多篇文章都提到“熊猫、双胞胎、动物园、日本”，聚类算法可能判断它们讲述的是同一事件，并将它们归为一组。

没有员工提前告诉算法哪些关键词一定属于同一主题。新闻内容每天都在变化，算法必须自动判断当天出现了哪些主题，以及哪些文章正在讨论同一件事。

DNA与基因数据

DNA 微阵列数据中，每一列表示一个人的基因活动，每一行表示一个特定基因。每个人可以表示为大量基因特征组成的向量。

聚类算法能够将基因表达模式相似的人分到同一组。算法不知道这些群体应该叫什么，只是在回答：这些基因数据中是否存在自然形成的不同类型？

客户细分

公司可以根据年龄、地区、购买记录和浏览行为等数据，把相似客户划分到不同细分市场。

例如，一个在线学习社区可能发现：一组用户希望提升技能，一组希望获得晋升或新工作，另一组希望了解 AI 对自身行业的影响。企业可以据此推荐内容并设计服务，这类应用称为市场细分（Market Segmentation）。

异常检测：寻找偏离正常模式的数据

异常检测（Anomaly Detection）的目标是发现与大多数数据明显不同的异常样本。

在金融系统中，一笔交易可能表现出以下异常：

交易金额特别大
交易地点异常
短时间内连续交易
登录设备突然变化
消费行为与过去完全不同

这些异常可能是欺诈的信号。常见应用还包括网络攻击检测、设备故障检测、工业产品异常检测和医疗异常指标检测。

需要注意，异常不等于欺诈，只表示该数据与正常模式不同。异常检测也可以采用监督学习方法，但当异常样本很少或没有可靠标签时，经常采用无监督或半监督方法。

降维：用更少特征表示数据

降维（Dimensionality Reduction）的目标是在尽量保留重要信息的前提下，用更少的特征表示原始数据。

假设原始数据包含 1000 个特征：

$$x=(x_1,x_2,\ldots,x_{1000})$$

降维算法可能将其压缩为几十个甚至两三个新特征：

$$z=(z_1,z_2,\ldots,z_k),\quad k \ll 1000$$

降维可以压缩数据、提高部分算法的运行效率、减少重复信息和噪声，也可以将高维数据转换为二维或三维，方便可视化。它不是随意删除数据，而是尽可能保留数据中最重要的信息。

如何判断学习类型

判断任务时，首先问：训练数据中是否提供了标签？

邮件带有垃圾/非垃圾标签：监督学习中的分类
房屋带有实际价格：监督学习中的回归
新闻没有主题标签，需要自动分组：无监督学习中的聚类
客户没有预设类型，需要自动细分：无监督学习中的聚类
患者带有患糖尿病/未患糖尿病标签：监督学习中的分类

同一个业务问题也可能因为数据是否有标签，而采用不同的学习方式。

优势与局限

无监督学习不需要为所有数据人工标注，可以处理大量无标签数据，并发现人们事先没有注意到的结构，因此很适合探索陌生数据。

它也有明显局限：没有标准答案，结果较难评估；算法找到的结构不一定具有实际意义；聚类结果会受到特征选择和算法的影响；最终通常仍需要领域知识进行解释。

知识框架

机器学习
├── 监督学习
│ ├── 回归：预测数值（房价、温度）
│ └── 分类：预测类别（垃圾邮件、肿瘤性质）
│ ├── 二分类
│ └── 多分类
│
└── 无监督学习
 ├── 聚类：寻找相似群体（新闻分组、客户细分）
 ├── 异常检测：寻找异常数据（欺诈检测）
 └── 降维：压缩数据并保留重要信息

监督学习使用带标签的 $(x,y)$ 数据，学习输入到输出的映射；无监督学习只有输入 x，目标是自动发现数据中的结构、模式或异常。两者并无高下之分，关键是根据数据和问题选择合适的方法。

术语表

中文	英文	含义
特征	Feature	描述样本的输入属性
标签	Label	训练数据中的正确答案
泛化	Generalization	对未见数据作出有效预测的能力
回归	Regression	预测连续数值
分类	Classification	预测离散类别
二分类	Binary Classification	只有两个输出类别
多分类	Multiclass Classification	存在三个及以上类别
决策边界	Decision Boundary	区分不同类别的边界
聚类	Clustering	将相似数据自动分组
簇	Cluster	聚类形成的数据群体
异常检测	Anomaly Detection	发现偏离正常模式的数据
降维	Dimensionality Reduction	用更少特征表示高维数据
市场细分	Market Segmentation	根据相似特征划分客户群体

Go 语言工程化：模块管理与项目结构

Mon, 13 Jul 2026 15:42:45 +0800

承接 Go 语言基础：从变量到指针和 Go 语言进阶：方法、接口与错误处理，这一篇覆盖 Go 项目的工程化核心：模块管理、包的组织、目录结构。

Go Modules

之前写的代码都在单个 .go 文件里，使用 package main，直接 go run xxx.go 就能跑。但真实项目通常会有几十个 .go 文件、多个包，还会用到第三方库。这些东西怎么管理？答案就是 Go Modules。

go.mod 是什么？

go.mod 就像项目的“身份证”，它主要记录三类信息：

模块路径是什么：module example.com/demo
项目使用哪个 Go 版本：go 1.26.3
项目依赖哪些第三方模块：由 require 指令记录

为什么要用 Go Modules？

假设你写了一个项目，用了第三方库。朋友拿到代码后，怎么知道需要哪些依赖和版本？

没有 go.mod：

朋友：你用了哪些库？

你：好像有 xxx、yyy，版本忘了……

有 go.mod：

朋友：看 go.mod 就知道了，执行 go mod download 或 go mod tidy 就能准备好依赖。

常用命令

`go mod init 模块路径`

在项目开始时创建 go.mod：

go mod init example.com/demo

生成的文件类似这样：

module example.com/demo

go 1.26.3

练习项目可以使用 demo 这类简单名称；准备发布的模块通常使用代码仓库地址，例如 github.com/用户名/项目名，这样别人才能通过稳定的路径导入它。

`go mod tidy`

go mod tidy 会根据源码中的 import 整理依赖：

添加代码需要、但 go.mod 还没有记录的模块
删除代码已经不再需要的模块
补充或清理 go.sum 中的校验信息

简单说，它会让模块文件与当前代码保持一致。改完依赖后跑一次，通常是个好习惯。

`go get 模块路径`

给当前模块添加或升级依赖：

go get github.com/gin-gonic/gin

它会解析并下载依赖，同时更新 go.mod 和 go.sum。如果你要安装一个命令行工具，而不是给当前项目添加依赖，应使用带版本号的 go install：

go install example.com/tool@latest

go.sum 是什么？

执行 go mod tidy、go get 或构建项目后，通常会出现 go.sum。它记录依赖模块内容的加密校验值：

项目使用某个模块的特定版本
go.sum 保存这个版本及其 go.mod 文件的校验值
再次下载时，Go 会验证拿到的内容是否一致

go.sum 不是用来锁死所有依赖版本的锁文件；真正决定依赖版本的是 go.mod 和 Go 的版本选择规则。go.mod 与 go.sum 都应该提交到 Git，通常不需要手动编辑 go.sum。

package 拆分

为什么要拆 package？

如果所有代码都堆在 main.go 里，用户管理、订单管理和数据库连接会逐渐混在一起。按职责拆包之后，结构会清晰很多：

demo/
 go.mod
 main.go # 程序入口
 user/
 user.go # 用户相关功能
 order/
 order.go # 订单相关功能
 db/
 db.go # 数据库相关功能

怎么拆？

先创建 user/user.go，声明它属于 user 包：

package user

import "fmt"

type User struct {
 Name string
 Age int
}

func Print(u User) {
 fmt.Printf("%s, %d\n", u.Name, u.Age)
}

再在项目根目录的 main.go 中导入它：

package main

import "example.com/demo/user"

func main() {
 u := user.User{Name: "Jasper", Age: 22}
 user.Print(u)
}

这里的导入路径由两部分组成：

example.com/demo/user
└── 模块路径 ──┘ └包目录

也就是：导入路径 = go.mod 中的模块路径 + 包所在的相对目录。

package 与可见性

同一目录下的普通 .go 文件必须属于同一个包。包名通常与目录名最后一段一致，这是一条强烈推荐的惯例，但不是“包名必须等于目录名”的语法规则。

标识符是否能被其他包使用，则由首字母大小写决定：

写法	可见范围
`User`、`Print`	首字母大写，可以被其他包访问
`user`、`print`	首字母小写，只能在当前包内访问

internal 访问控制

internal 是什么？

一句话：internal 是 Go 编译器真正认识的特殊目录，用来限制包的导入范围。

假设项目结构如下：

myapp/
 go.mod # module example.com/myapp
 cmd/api/main.go
 internal/db/db.go

example.com/myapp/internal/db 只能被 example.com/myapp 目录树中的代码导入：

// myapp/cmd/api/main.go：可以导入
import "example.com/myapp/internal/db"

另一个项目则不能导入它：

// otherapp/main.go：编译报错
import "example.com/myapp/internal/db"

更准确地说，规则不是“同一个模块才能用”，而是：只有位于 internal 父目录树中的代码才能导入它。大多数项目把 internal 放在模块根目录，所以看起来就像“只有本模块能用”。

目录	编译器是否特殊处理	用途
`internal/`	是，限制外部导入	不希望暴露给外部项目的实现
`pkg/`	否，只是社区惯例	明确准备对外复用的包，可选

常见项目结构

Go 官方没有规定一套所有项目都必须照搬的“标准目录结构”。下面是一种常见布局，适合已经出现多个入口和多个业务模块的项目：

myproject/
 cmd/ # 程序入口
 api/
 main.go # 启动 HTTP 服务
 worker/
 main.go # 启动后台任务
 internal/ # 不对模块外部开放的代码
 config/
 config.go # 配置读取
 db/
 db.go # 数据库连接
 user/
 user.go # 用户相关逻辑
 handler/
 handler.go # HTTP 处理函数
 pkg/ # 确实需要对外复用时再添加
 utils/
 utils.go
 go.mod
 go.sum

三个常见目录的职责：

cmd/：每个子目录对应一个可执行程序，包名为 main；通常只负责依赖组装、配置和启动
internal/：放不希望被外部项目导入的实现代码，不代表所有业务逻辑都必须塞在这里
pkg/：表达“这些包准备公开复用”的意图，没有编译器层面的特殊含义；小项目完全可以没有

目录不是越多越工程化。只有一个可执行程序的小项目，把 main.go 放在根目录也很正常；随着入口和职责增多，再引入 cmd/、internal/ 即可。

为什么要多一层 cmd/？

一个项目可能提供多个启动方式：

cmd/api/main.go # 启动 HTTP 服务
cmd/worker/main.go # 启动后台任务

它们是两个入口，但可以共享 internal/ 里的业务代码。cmd/ 下的程序应尽量轻量：

// cmd/api/main.go
package main

import "example.com/myproject/internal/server"

func main() {
 server.Start()
}

cmd/api 中不一定只能有一个 main.go，也可以有多个属于 package main 的文件；重要的是入口层保持轻薄，不把大量业务逻辑堆在这里。

引入第三方包

标准库是 Go 自带的，例如 fmt、net/http。标准库之外，由其他项目提供的包就是第三方包，例如：

github.com/gin-gonic/gin：Web 框架
github.com/jackc/pgx/v5：PostgreSQL 驱动与工具包
github.com/spf13/cobra：命令行应用框架

以 UUID 包为例，先添加依赖：

go get github.com/google/uuid

再在代码里导入并使用：

package main

import (
 "fmt"

 "github.com/google/uuid"
)

func main() {
 id := uuid.New()
 fmt.Println(id)
}

此时 go.mod 可能包含：

module example.com/user-api

go 1.26.3

require github.com/google/uuid v1.6.0

改动依赖后执行：

go mod tidy
go test ./...

第一条命令整理模块文件，第二条命令确认整个模块仍能编译并通过测试。到这里，一个 Go 项目从单文件走向模块化工程的基本骨架就搭起来了。

Go 语言基础：从变量到指针

Tue, 07 Jul 2026 00:00:00 +0800

一份 Go 入门语法梳理，从变量到指针，覆盖日常开发最常用的核心概念。

变量声明

两种方法。

1. `var` 标准形式

var name type = value // 标准形式
var pi = 22 // 可以自动推断类型，省略 type
var score int // 可以不给 value

声明不赋值时，系统自动给零值。

2. `:=` 简短声明

name := "草泥马"

比较常见。限制：

只能在函数里用（全局范围必须用 var）
不能只声明不赋值

常量与 iota

常量不可更改，直接用 const 声明：

const Pi = 3.14
const name = "xxx"

常量必须在编译期确定，不能把运行时的值赋给常量：

const now = time.Now() // ✗ 编译报错，time.Now() 是运行时才有的

iota 是 Go 在 const 块里提供的自动计数器：

const (
 Sunday = iota // 0
 Monday // 1
 Tuesday // 2
 Wednesday // 3
)

比较简洁。想跳过某个值，用 _ = iota 占位就好。

注意：Go 没有 enum 关键字，做枚举需要用 const + iota。

数据类型

Go 是强类型语言，类型间不能自动转换（区别于 JS、Python），只能手动强制转换：

var a = 10
var b = 3.14
// 要算 a + b，必须先转类型
float64(a) + b

基本类型一览

var i int = 42 // 平台相关，64 位系统就是 64 位
var i8 int8 = 127 // 范围 -128 ~ 127
var u uint = 42 // 无符号，没有负数
var f32 float32 = 3.14
var f64 float64 = 3.14 // 一般都用 float64
var s string = "hello"
var b bool = true // 只有 true/false，没有 1/0

rune 与 byte 的区别

var b byte = 'A' // byte 就是 uint8，存储一个 ASCII 字符
var r rune = '中' // rune 就是 int32，存储一个 Unicode 字符

为什么要这样？英文字母只占一个字节，而中文、emoji 占 3~4 个字节，一个 byte 装不下，需要 rune。

s := "hello"
len(s) // 5，len 对 string 返回字节数
len([]rune(s)) // 5，返回字符数

想拿字符数就用 len([]rune(s))。原理：[]rune(s) 把 string 转成 []rune 切片。

字符串的两种写法

s1 := "hello\nworld" // 双引号，解释型：\n 会被解释成换行
s2 := `hello\nworld` // 反引号，原始字符串：字面上的 \n 不会换行

切片 Slice

先说数组，但几乎不会用它：

var arr [3]int = [3]int{1, 2, 3} // 长度固定，声明时定死

所以实际开发用可变数组——切片。

slice 声明

nums := []int{1, 2, 3} // 字面量
s := make([]int, 0, 10) // make 指定长度 0，容量 10
var names []string // nil，长度 0，后面 append

len 与 cap

每个 slice 有两个属性：

len 长度：里面实际有多少个元素
cap 容量：底层数组最多能装多少个

s := make([]int, 3, 10)
fmt.Println(len(s)) // 3
fmt.Println(cap(s)) // 10

append 添加元素

nums := []int{1, 2, 3}
nums = append(nums, 4) // 末尾多了个 4
nums = append(nums, 5, 6, 7) // now [1,2,3,4,5,6,7]

注意：append 返回的是新的 slice，必须赋值回去。

扩容：当 append 超过 cap 时，Go 会自动分配一个更大的底层数组，把旧数据拷过去。你不需要手动管，但要知道这个机制存在——它会影响性能。

切片操作

nums := []int{10, 20, 30, 40, 50}
sub := nums[1:3] // 左闭右开 → [20, 30]
all := nums[:] // 全部
first := nums[:2] // [10, 20]
last := nums[2:] // [30, 40, 50]

⚠️ 陷阱：切片出来的 sub 和原 slice 共享底层数组，修改 sub 会影响 nums：

sub[0] = 999
fmt.Println(nums) // [10, 999, 30, 40, 50] —— nums 也被改了！

要独立拷贝用 copy。

遍历

fruits := []string{"apple", "banana", "cherry"}
for i, v := range fruits {
 fmt.Printf("[%d] %s\n", i, v)
}

// 不要索引就用 _
for _, v := range fruits {
 // ...
}

Map

其实就是映射。

// 创建一个 map，key 是 string，value 是 int
scores := map[string]int{
 "math": 90,
 "english": 85,
 "chinese": 92,
}

// 取值
fmt.Println(scores["math"]) // 90

// 添加/修改
scores["science"] = 88 // 新增
scores["math"] = 95 // 修改（key 已存在就覆盖）

// 删除
delete(scores, "english")

长度用 len()。

Comma-ok 模式

取一个不存在的 key 会怎么样？一般直接返回 value 类型的零值。但这会出问题——0 是真实分数，还是因为 key 不存在？所以提供 comma-ok 模式：

score, ok := scores["physics"]
if ok {
 fmt.Println("找到了：", score)
} else {
 fmt.Println("不存在")
}
// ok 是 bool 型变量

Map 的零值

var m map[string]int // nil map
m["a"] = 1 // 🙅 nil map 不能写入

和 slice 一样，声明之后必须初始化才能使用：

m := map[string]int{} // 方式 1：空字面量
m := make(map[string]int) // 方式 2：make

遍历

scores := map[string]int{"math": 90, "english": 85}
for subject, score := range scores { // 同时给 subject、score 赋值
 fmt.Printf("%s: %d\n", subject, score)
}

结构体 Struct

结构体的知识在 C/C++ 中已经讲过很多，这里给个框架：

type Car struct {
 Brand string
 Color string
 Money float64
}

创建实例：

var c Car
c.Brand = "特斯拉"
fmt.Println(c.Brand)

struct 与 map/slice 的区别

struct 是值类型，不同于 map、slice 底层数据共享。struct 可以直接赋值、修改元素，赋值时会拷贝一份完整数据。

struct 与 JSON 互转

这是实际开发中的高频操作。

import "encoding/json"

func main() {
 c := Car{Brand: "特斯拉", Color: "白色", Money: 25.99}

 // 转成 JSON
 jsonData, err := json.Marshal(c)
 if err != nil {
 fmt.Println("转换失败:", err)
 return
 }
 fmt.Println(string(jsonData)) // string() 将字节数组转为可读字符串
}

⚠️ 问题：JSON 里的字段是大写的 Brand，但前端习惯小写。

解决：struct tag，用反引号包裹：

type Car struct {
 Brand string `json:"brand"`
 Color string `json:"color"`
 Money float64 `json:"money"`
}

这样序列化出来的 JSON key 就是小写了。注意反引号 ` 里面整个 json:"xxx" 是一个整体，冒号后面不能有空格。

流程控制

三个核心：if/else、switch、for（Go 没有 while）。

if/else

Go 的 if 可以带初始化语句，用 ; 分隔：

if age := 20; age >= 18 {
 fmt.Println("成年人")
}
// age 仅在 if 块内生效

⚠️ 如果用到了 else，Go 强制要求 } else { 必须在同一行，不然编译报错：

if condition {
 // ...
} else {
 // ...
}

switch

Go 的 switch 不需要写 break，每个 case 自动结束：

day := "Monday"
switch day {
case "Monday":
 fmt.Println("星期一")
case "Tuesday":
 fmt.Println("星期二")
default:
 fmt.Println("其他")
}

for 循环

Go 只有 for，但有四种写法：

1. 经典写法（和 C 一样）

for i := 0; i < 5; i++ {
 // ...
}

2. 当 while 用（只有一个条件）

i := 0
for i < 5 {
 i++
}

3. 无限循环（配合 break）

for {
 fmt.Println("一直跑")
 break
}

4. range 遍历（实际开发中用得最多）

// 遍历 slice
nums := []int{10, 20, 30}
for i, v := range nums {
 fmt.Println(i, v)
}

// 遍历 map
scores := map[string]int{"张三": 90, "李四": 85}
for k, v := range scores {
 fmt.Println(k, v)
}

range 后面可以只用一个变量接收值，用 _ 跳过不需要的：

for _, v := range nums {
 // 只要值，不要索引
}

注意：for 的三部分不用括号，但分号不能省。

函数

Go 用 func 定义函数，函数必须定义在函数外。格式正常，重点看多返回值——这是 Go 的特色。

func divide(a, b float64) (float64, error) {
 if b == 0 {
 return 0, fmt.Errorf("除数不能为零")
 }
 return a / b, nil
}

func main() {
 result, err := divide(10, 3)
 if err != nil {
 fmt.Println("出错了:", err)
 } else {
 fmt.Println("结果:", result)
 }
}

几点注意：

error 是 Go 内置的接口类型，表示错误
没出错时返回 nil
fmt.Errorf 创建一个带错误信息的 error

Go 的错误处理模式就是 返回值 + if 判断，没有 try-catch。这在后面写项目时会反复见到。

指针

核心概念：

概念	符号	作用
取地址	`&a`	获取变量 a 的内存地址
解引用	`*p`	通过地址，读取或修改那个地址里的值

指针类型：

普通类型	对应指针类型	读法
int	`*int`	指向 int 的指针
string	`*string`	指向 string 的指针
User	`*User`	指向 User 的指针

指针的零值是 nil：

var p *int // p 的零值是 nil，没有指向任何东西

两个必须记住的事：

Go 函数传参永远是复制。想改原件，必须传指针。
& 是"取地址"，* 是"去地址找东西"。两个方向相反。

直觉：普通变量是盒子里装着值，指针是纸条上写着"盒子在哪"。

指针与 struct

func birthday(u *User) {
 u.Age++ // Go 自动解引用，不用写 *u（语法糖）
}

func main() {
 user := User{"Jasper", 22}
 birthday(&user) // 传地址
 fmt.Println(user.Age) // 23
}

Go 中局部变量习惯用小驼峰 maxStudent 而不是大驼峰 MaxStudent。import 用小括号 () 而不是花括号 {}。

练习：学生成绩管理

一个综合 struct、slice、指针的小练习：

package main

import "fmt"

type Student struct {
 Name string
 Grade float64
}

// 找出成绩最高的学生
func findMaxGrade(students []Student) Student {
 maxStudent := students[0]
 for _, student := range students {
 if student.Grade > maxStudent.Grade {
 maxStudent = student
 }
 }
 return maxStudent
}

// 给学生加 5 分（通过指针修改原件，不需要返回值）
func plusFive(student *Student) {
 student.Grade += 5
}

func main() {
 students := []Student{
 {Name: "Alice", Grade: 85},
 {Name: "Bob", Grade: 90},
 {Name: "Charlie", Grade: 78},
 }
 maxStudent := findMaxGrade(students)
 plusFive(&maxStudent)
 fmt.Printf("最高分学生: %s, 成绩: %.2f\n", maxStudent.Name, maxStudent.Grade)
}

参考源

raw/go学习之路.md
raw/go.md

Go 语言进阶：方法、接口与错误处理

Tue, 07 Jul 2026 00:00:00 +0800

承接 Go 语言基础：从变量到指针，这一篇覆盖 Go 的进阶核心概念：方法、接口、错误处理，以及泛型入门。

方法

// 普通函数：参数是 Student
func greet(s Student) string {
 return "Hello, " + s.Name
}

// 方法：绑在 Student 上
func (s Student) greet() string {
 return "Hello, " + s.Name
}

区别就在于函数名前面多了一个 (s Student)，这叫接收者（receiver）。

调用方式不同：

student := Student{"Jasper", 90}

// 函数调用
greet(student)

// 方法调用
student.greet()

返回一个字符串可以用 fmt.Sprintf。

值接收者 vs 指针接收者

在接收者的类型前加 * 就变成指针接收者。值接收者只改副本，指针接收者改原件。

// 值接收者：改的是副本
func (s Student) setScore(score float64) {
 s.Grade = score // 不影响原值
}

// 指针接收者：改的是原件
func (s *Student) setScore(score float64) {
 s.Grade = score // 修改原值
}

接口

Go 中最重要的概念之一。

// 定义接口：任何有 speak() 方法的类型，都算 Speaker
type Speaker interface {
 speak() string
}

// Dog 有 speak() 方法，Dog 实现了 Speaker
type Dog struct {
 Name string
}

func (d Dog) speak() string {
 return "Woof"
}

// 同理 Cat 亦如此
type Cat struct {
 Name string
}

func (c Cat) speak() string {
 return "Meow"
}

// 通用函数：接受任何 Speaker
func makeItSpeak(s Speaker) {
 fmt.Println(s.speak())
}

func main() {
 dog := Dog{"Buddy"}
 cat := Cat{"Kitty"}
 makeItSpeak(dog) // Woof!
 makeItSpeak(cat) // Meow!
}

三个要点：

接口定义：type Speaker interface { speak() string } — 定义了一个"能力"，不关心谁实现
隐式实现：Dog 和 Cat 都有 speak() 方法，所以它们自动"算"是 Speaker，不需要显式声明 implements
通用函数：makeItSpeak(s Speaker) 接受任何 Speaker，不关心具体是 Dog 还是 Cat

嵌入接口

小接口可以组合成大接口：

// 两个独立接口
type Speaker interface { speak() string }
type Walker interface { walk() string }

// 嵌入组合
type SpeakerWalker interface {
 Speaker // 把 Speaker 的方法拿过来
 Walker // 把 Walker 的方法拿过来
}

效果：SpeakerWalker 自动拥有 speak() 和 walk() 两个方法。

接口哲学：小接口 > 大接口

Go 的接口是隐式实现的：

// C++ / Java：必须显式声明"我实现了这个接口"
class Person implements Speaker { ... }

// Go：只要你有方法，就自动满足接口
type Person struct { Name string }
func (p Person) speak() string { return "hi" }
// Person 自动满足 Speaker，不需要声明

标准库里最常见的接口：

// io.Reader — 只有一个方法
type Reader interface {
 Read(p []byte) (n int, err error)
}

// io.Writer — 只有一个方法
type Writer interface {
 Write(p []byte) (n int, err error)
}

Go 标准库里很多接口只有 1~2 个方法，而不是把所有功能堆在一个大接口里。

为什么小接口好？

容易实现 — 一个方法的接口，任何类型都能轻松满足
容易组合 — 用嵌入把小接口组合成大接口
灵活 — 你只关心你需要的能力，不关心具体类型

特性	Go	Java/C++
实现方式	隐式（自动满足）	显式（需要声明）
接口大小	通常 1-2 个方法	通常很多方法
设计哲学	小接口，按需组合	大接口，一次定义

io.Reader 与 io.Writer

这是 Go 标准库里最常用的两个接口，用来处理"数据流"。

先想一个问题：从哪里读数据？

从文件读
从网络读
从键盘读
从字符串读

这些地方都能读数据，但它们的实现完全不同。接口解决这个问题：

// io.Reader：任何"能读出数据"的东西
type Reader interface {
 Read(p []byte) (n int, err error)
}

翻译成大白话：

“你只要有 Read 方法，能往 p 里填数据，你就是个 Reader”

参数/返回	含义
`p []byte`	一个空的容器（桶），你把读到的数据放进去
返回 `n int`	实际读了多少字节
返回 `err error`	读取过程中有没有出错

为什么这个接口牛？因为它只有一个方法，所以实现简单、使用广泛——标准库里几百个函数都接受 Reader。

// 这些类型都实现了 io.Reader
// - os.File （文件）
// - strings.Reader （字符串）
// - bytes.Buffer （字节缓冲区）
// - net.Conn （网络连接）

// 通用函数：不关心数据从哪来，只管读
func printAll(r io.Reader) {
 data := make([]byte, 100)
 n, _ := r.Read(data)
 fmt.Println(string(data[:n]))
}

// 从文件读
file, _ := os.Open("test.txt")
printAll(file)

// 从字符串读
str := strings.NewReader("hello")
printAll(str)

同一个函数，能处理不同类型的数据源——这就是接口的价值。

接口	方法数	作用
`io.Reader`	1	能读
`io.Writer`	1	能写
`io.Closer`	1	能关闭
`io.ReadWriter`	2	能读能写（嵌入组合）

Go 的设计哲学：把大能力拆成小接口，按需组合。

空接口 any 与类型断言

有时候需要处理"任意类型"，这时候用空接口：

// any 是 interface{} 的别名
func printAnything(v any) {
 fmt.Println(v)
}

但是有个问题：拿到的是 any，不知道具体的类型怎么办？此时引出类型断言与 type switch。

类型断言

func printAnything(v any) {
 if s, ok := v.(string); ok {
 fmt.Println("是字符串:", s)
 } else if n, ok := v.(int); ok {
 fmt.Println("是整数:", n)
 } else {
 fmt.Println("其他类型:", v)
 }
}

Type Switch

更简洁的写法：

func printAnything(v any) {
 switch val := v.(type) {
 case string:
 fmt.Println("是字符串:", val)
 case Student:
 fmt.Println("是学生:", val)
 }
}

v.(type) 是 Go 的特殊语法，只能在 switch 里用，意思是"告诉我 v 的实际类型是什么"。val 会自动变成对应分支的类型。

Comma-Ok 模式详解

这是 Go 里处理"可能失败的操作"的通用模式，类型断言只是其中一个用法。

s, ok := v.(string)

尝试把 v 转成 string
如果成功：s = 转换后的值，ok = true
如果失败：s = 空字符串零值，ok = false

关键点：如果不写 ok，断言失败会直接 panic（程序崩溃）。所以一般都用 , ok 安全地处理：

// 不安全：失败会 panic
s := v.(string)

// 安全：失败只是 ok = false
s, ok := v.(string)

接口 vs Type Switch

方式	优点	缺点
接口	扩展性好，加新类型不用改函数	需要提前定义接口
Type Switch	直观，能处理任意类型	加新类型要改函数

错误处理

strconv 是 Go 标准库里专门处理字符串和数字之间转换的包。strconv.Atoi = ASCII to Integer。

Go 的错误处理模式：

result, err := someFunction()
if err != nil {
 // 处理错误
 return ..., err // 往上层传
}
// 正常使用 result

核心规则：

错误是普通值，函数返回 error 接口
nil = 没错，非 nil = 有错（带错误信息）
函数只返回错误，调用方决定怎么处理

error 接口

error 是 Go 内置的接口，只有一个方法：

type error interface {
 Error() string
}

任何实现了 Error() string 方法的类型，都算 error。

创建自己的错误

使用 errors.New 或 fmt.Errorf：

import "errors"

func divide(a, b float64) (float64, error) {
 if b == 0 {
 return 0, errors.New("除数不能为零")
 }
 return a / b, nil
}

或者用 fmt.Errorf 带格式化：

return 0, fmt.Errorf("除数不能为零：%f", b)

错误包装

有时候你想在错误上加点上下文，但是不想丢失原始错误：

func readConfig(path string) (string, error) {
 data, err := os.ReadFile(path)
 if err != nil {
 // 包装原始错误，加上上下文
 return "", fmt.Errorf("读取配置文件失败：%w", err)
 }
 return string(data), nil
}

然后用 errors.Is 判断错误类型：

content, err := readFile("不存在的文件.txt")
if err != nil {
 fmt.Println("错误:", err)
 if errors.Is(err, os.ErrNotExist) {
 fmt.Println("原因：文件不存在")
 }
}

设计理念：错误处理就像"层层汇报"

想象一个公司出了问题：

员工：硬盘坏了（原始错误）
主管：服务器出问题了（包装一层）
经理：系统故障（再包装一层）

如果只传一句话：经理只知道"系统故障"，不知道根本原因，没法针对性解决。

如果层层包装但保留原始原因：经理收到 → 系统故障 → 服务器出问题 → 硬盘坏了。经理可以用 errors.Is 查问：“是不是硬盘的问题？"——穿透所有包装，直接找到根本原因。

代码对应：

// 底层：硬盘坏了
os.ReadFile("xxx") // 返回 os.ErrNotExist（文件不存在）

// 中层：服务器出问题了
fmt.Errorf("读取文件失败: %w", err) // 包装，但保留原始错误

// 顶层：经理
if errors.Is(err, os.ErrNotExist) {
 // 穿透包装，发现根本原因是"文件不存在"
 fmt.Println("原因：文件不存在")
}

三种方式对比：

// 方式1：只传原始错误（不好）
return err // main 只知道 "no such file or directory"，不知道是哪个文件

// 方式2：只传新错误（不好）
return errors.New("读取文件失败") // main 不知道为什么失败

// 方式3：包装（正确）
return fmt.Errorf("读取文件失败: %w", err) // main 既知道上下文，又能判断原因

Sentinel Errors（哨兵错误）

就是预先定义好的错误值，让我们可以用 errors.Is 判断。os.ErrNotExist 就是一个 Sentinel Error。自己也可以定义：

var ErrInvalidAge = errors.New("年龄不能为负数")

func setAge(age int) error {
 if age < 0 {
 return ErrInvalidAge
 }
 return nil
}

// 调用方
err := setAge(-1)
if errors.Is(err, ErrInvalidAge) {
 fmt.Println("年龄不合法")
}

panic 与 recover

Go 中大部分用 error 处理错误，但有些情况下程序直接崩溃——panic。

panic：程序崩溃
recover：捕获 panic，让程序继续运行

什么时候用 panic

程序遇到无法继续运行的严重错误：

func divide(a, b int) int {
 if b == 0 {
 panic("除数不能为零") // 程序崩溃
 }
 return a / b
}

什么时候用 recover

在服务器程序里，你不想因为一个请求崩溃就让整个服务器挂掉：

func safeDivide(a, b int) (result int, err error) {
 defer func() {
 if r := recover(); r != nil {
 err = fmt.Errorf("捕获 panic: %v", r)
 }
 // %v 是 Go 里最通用的格式化动词，意思是"用默认格式打印值"
 }()
 return divide(a, b), nil
}

几个要点：

命名返回值：(result int, err error) — Go 允许给返回值起名字，函数内部可以直接用这些名字，return 时可以省略返回值
defer：延迟执行，函数结束的时候才运行
recover：捕获 panic 的唯一方式，只能在 defer 里用

// defer 里的匿名函数：定义后立即调用
defer func() {
 if r := recover(); r != nil {
 // r 是 panic 传出来的信息
 fmt.Println("捕获到 panic:", r)
 }
}() // 定义完立刻调用

泛型（了解即可）

为什么需要泛型？

没有泛型时，同一个逻辑要写多份：

func maxInt(a, b int) int {
 if a > b { return a }
 return b
}

func maxFloat(a, b float64) float64 {
 if a > b { return a }
 return b
}

逻辑完全一样，只是类型不同。泛型用一个函数搞定：

func max[T int | float64 | string](a, b T) T {
 if a > b { return a }
 return b
}

泛型函数语法

func 函数名[类型参数 约束](参数) 返回类型

拆解 func max[T int | float64 | string](a, b T) T：

func max → 函数名
[T int | float64 | string] → T 可以是 int、float64 或 string
(a, b T) → a 和 b 都是 T 类型
T → 返回类型也是 T

调用时 Go 会自动推断 T 的类型：

max(1, 2) // T = int
max(1.5, 2.5) // T = float64
max("hello", "world") // T = string

类型约束

约束就是告诉编译器"T 必须是什么类型”。

常用约束：

[any] → 任意类型
[comparable] → 可以用 == 比较的类型
[constraints.Ordered] → 可以用 < > 比较的类型（int、float64、string）

自定义约束：

type Number interface {
 int | int32 | int64 | float32 | float64
}

func sum[T Number](nums []T) T {
 var total T
 for _, n := range nums {
 total += n
 }
 return total
}

泛型类型

泛型还能用在 struct 上：

type Stack[T any] struct {
 items []T
}

func (s *Stack[T]) push(item T) {
 s.items = append(s.items, item)
}

func (s *Stack[T]) pop() T {
 item := s.items[len(s.items)-1]
 s.items = s.items[:len(s.items)-1]
 return item
}

// 使用
intStack := &Stack[int]{}
intStack.push(1)
intStack.push(2)
fmt.Println(intStack.pop()) // 2

strStack := &Stack[string]{}
strStack.push("hello")
fmt.Println(strStack.pop()) // hello

参考源

raw/Go语言.md