列归一化（也叫 Z-score 标准化）指的是对二维数组的每一列独立计算均值和标准差，然后把该列的每个元素减去均值、除以标准差。这是机器学习预处理、信号去均值、图像像素归一化等场景的基础操作。numpy 对这类按轴运算有原生支持，配合广播机制可以在不写任何显式循环的情况下完成整列标准化。
理解 axis 参数与广播机制
numpy 中几乎所有统计函数都接受 axis 参数。arr.mean(axis=0) 表示沿着第 0 个轴（行方向）压缩，得到每一列的均值，结果是一个长度等于列数的一维数组。同理 arr.std(axis=0) 得到每列的标准差。这一点是列归一化的核心，很多人初学时会把 axis=0 和 axis=1 搞混，记住一个简单规则：axis 的值是"被压缩消失的那个轴"，axis=0 压缩行、按列统计，axis=1 压缩列、按行统计。
拿到每列的均值和标准差后，问题变成如何让一个形状为 (n_cols,) 的一维数组去作用到形状为 (n_rows, n_cols) 的二维数组上。这正是广播机制的用武之地：当两个数组形状不一致时，numpy 会自动在缺失的维度上扩展。一维数组在参与运算时默认对齐二维数组的最后一维，也就是列方向。因此 arr - mean 会把 mean 的每个元素广播到对应列的所有行上，实现逐列相减。
如果要按行归一化，需要把一维统计量 reshape 成 (n_rows, 1) 或者写成 arr.mean(axis=1, keepdims=True)。keepdims 参数会让统计结果保留被压缩的维度，形状从 (n_rows,) 变成 (n_rows, 1)，这样广播对齐就不会出错，是避免维度错误的推荐写法。
基础实现与零标准差列的处理
最直接的写法只需要三行，先计算列均值和列标准差，再做一次广播运算即可完成。
import numpy as np
# 构造一个 5 行 3 列的示例数据
data = np.array([
[1.0, 10.0, 100.0],
[2.0, 20.0, 200.0],
[3.0, 30.0, 300.0],
[4.0, 40.0, 400.0],
[5.0, 50.0, 500.0],
])
mean = data.mean(axis=0) # 每列均值，形状 (3,)
std = data.std(axis=0) # 每列标准差，形状 (3,)
normalized = (data - mean) / std
print(normalized.mean(axis=0)) # 接近全 0
print(normalized.std(axis=0)) # 接近全 1</code>这个版本有一个隐患：如果某一列所有元素相同（例如某列全部是 0），它的标准差为 0，除法会产生 inf 或 nan，后续任何基于该矩阵的计算都会被污染。实际工程中这种"常数列"很常见，比如 one-hot 编码后的稀疏特征、日志里的固定字段值。
稳妥的做法是用一个小阈值替换掉为零的标准差，或者借助 np.where 在除法前做防护。下面的写法对所有列都安全：
def column_normalize(arr, eps=1e-8):
mean = arr.mean(axis=0)
std = arr.std(axis=0)
# 把过小的标准差替换为 1，避免除零
safe_std = np.where(std < eps, 1.0, std)
return (arr - mean) / safe_std
# 包含常数列的测试
test = np.array([
[1.0, 7.0, 0.0],
[2.0, 7.0, 0.0],
[3.0, 7.0, 0.0],
])
result = column_normalize(test)
print(result)
# 第一列被正常标准化，第二列减均值后全为 0，第三列除以 1 后保持原样（此处第二、三列按列号依次对应）另一种思路是使用 np.errstate 上下文管理器临时屏蔽除零警告，再对结果做 nan 清洗，但这属于事后补救，代码可读性不如上面预先替换标准差的方案。eps 的取值没有严格标准，1e-8 到 1e-5 之间都可以，只要明显小于正常数据的尺度即可。
性能对比：循环逐列 vs 向量化广播
为什么强调用向量化而不是写 Python 循环？因为 numpy 的底层运算是用 C 实现的连续内存块操作，而 Python 层面的 for 循环每一列都要走一次解释器调度、创建临时数组。数据量一大，差距非常明显。
下面用一个 100 万行、20 列的矩阵做对比，先逐列循环标准化，再用广播一次性完成，统计两者耗时：
import numpy as np
import time
np.random.seed(42)
big = np.random.randn(1_000_000, 20)
# 方式一：逐列循环
start = time.perf_counter()
result_loop = np.empty_like(big)
for col in range(big.shape[1]):
col_mean = big[:, col].mean()
col_std = big[:, col].std()
result_loop[:, col] = (big[:, col] - col_mean) / col_std
t_loop = time.perf_counter() - start
# 方式二：向量化广播
start = time.perf_counter()
result_vec = (big - big.mean(axis=0)) / big.std(axis=0)
t_vec = time.perf_counter() - start
print(f"循环耗时: {t_loop:.4f} 秒")
print(f"向量化耗时: {t_vec:.4f} 秒")
print(f"结果一致: {np.allclose(result_loop, result_vec)}")在典型环境下，循环版本大约需要 0.2 秒以上，而向量化版本通常在几毫秒内完成，差距接近两个数量级。矩阵越大、列数越多，差距越大。原因在于循环版本对每一列都要切片、计算、再写回，总共产生 20 次解释器层面的来回；向量化版本只调用两次统计函数和一次广播运算，全程在 C 层面连续内存上执行。
如果想进一步压榨性能，还可以注意两点。第一，std 默认计算总体标准差（ddof=0），如果需要样本标准差要传 ddof=1，两者数值略有差异但性能开销相同。第二，确保输入数组是 C 连续布局的 float 类型，如果原始数据是 int 或者从 pandas 转来的非连续视图，先 np.ascontiguousarray(arr, dtype=np.float64) 转一次，能避免广播过程中的隐式拷贝。
复用统计量：训练集与测试集保持一致
在机器学习流程里有一个容易被忽视的坑：对训练集和测试集分别做归一化。这种做法会让两套数据使用不同的均值和标准差，模型在训练阶段学到的数值分布与推理阶段对不上，尤其当测试集样本量小时，偏差可能非常严重。
正确做法是只在训练集上计算 mean 和 std，把这两个统计量保存下来，测试集和新数据一律复用：
class ColumnStandardizer:
def __init__(self, eps=1e-8):
self.eps = eps
self.mean = None
self.std = None
def fit(self, x):
self.mean = x.mean(axis=0)
std = x.std(axis=0)
self.std = np.where(std < self.eps, 1.0, std)
return self
def transform(self, x):
return (x - self.mean) / self.std
# 用法：训练集 fit，测试集只 transform
train = np.random.randn(10000, 5) * [1, 10, 100, 1000, 1]
test = np.random.randn(2000, 5) * [1, 10, 100, 1000, 1]
scaler = ColumnStandardizer().fit(train)
train_norm = scaler.transform(train)
test_norm = scaler.transform(test)
print(train_norm.mean(axis=0)) # 全 0
print(test_norm.mean(axis=0)) # 接近 0 但不严格为 0，这是正常的这个思路与 sklearn 的 StandardScaler 完全一致，如果项目里已经在用 sklearn，直接调用 StandardScaler().fit_transform(train) 即可，它内部同样是基于 numpy 的向量化实现。自己手写的好处是可以剥离依赖、嵌入到纯 numpy 的数据管道中，并且能自由定制 eps 处理逻辑。
最后补充一点，如果数据规模大到内存放不下整个二维数组，可以考虑分块处理：第一遍流式累积每列的和与平方和，据此推出均值和标准差，第二遍再分块做减除运算。numpy 官方的 memmap 或者 h5py 加 np.memmap 都能配合这种两遍扫描策略，让归一化在磁盘数据上完成而不需要一次性载入内存。