🏠 总目录📚 本教程 02 · shape 与 axis 到底怎么数 ← →

NUMPY / 02 · 02 · shape 和 axis 到底怎么数

axis=0,到底消掉了哪一维?

把“横着算还是竖着算”换成一个可核对的问题:输出的 shape,应该少掉哪一位?

你能从输入形状推到输出,并说明什么时候需要 keepdims。

axis 机制示意固定矩阵是 [[1,2,3],[4,5,6]]。沿 axis=0 求和得到 [5,7,9];图不把 axis 当作行号。x.shape = (2,3)123456sum(axis=0)579shape = (3,)keepdims → (1,3)
固定矩阵是 [[1,2,3],[4,5,6]]。沿 axis=0 求和得到 [5,7,9];图不把 axis 当作行号。

可选小实验 · 浏览器里的简化示意

先选一根轴,看输出留下什么。

猜测可以略过,操作也可以略过。这里不运行 NumPy,不测性能;完整代码与直接结果始终可读。

x = np.array([[1, 2, 3], [4, 5, 6]])
x.sum(axis=0)
x.sum(axis=0, keepdims=True)

默认 axis=0 时是 [5,7,9]。

输出 shape=(3,)。

不操作,直接看结果和使用条件

axis=0 得 [5,7,9],shape=(3,);axis=1 得 [6,15],shape=(2,)。keepdims=True 分别保留为 (1,3)、(2,1)。

axis 机制示意机制关系;完整条件见图注。x.shape = (2,3)123456sum(axis=0)579shape = (3,)keepdims → (1,3)
固定矩阵是 [[1,2,3],[4,5,6]]。沿 axis=0 求和得到 [5,7,9];图不把 axis 当作行号。
阅读范围、用时与原有实验记录
实验记录怎么读

本页原有耗时、内存、报错和环境值保留为原文记录;本轮内容审校未逐项复跑这些实验。版本、硬件、数据和测量方法都会影响结果,示例中的倍数也不是保证。需要复现时先核对依赖版本,再在同一输入下比较。

⏱ 48 分钟 | ⭐ axis=1 不是「第 1 行」也不是「按列」,是「把 1 号轴消掉」—— 换成这个说法之后你再也不会数错

01 / 完整解释

先说清输入与输出。

🎯 一句话

上面的实验用同一张表得到了三项合计或两项合计。要预测会留下几个数,先看哪个坐标在变化。

求和会把沿一根轴取到的多个值合成一个值,这类操作叫归约(reduction)。对 sum、mean 这样的归约,axis=k 指形状里从 0 开始数的第 k 个位置。默认不保留它,打开 keepdims=True 则把那一位留成 1。

不用去想「行」「列」「横着」「竖着」——那些说法在二维时勉强能用, 一到三维((B, L, D))就全乱。只看形状元组,看哪个数字没了。

📐 一、shape 是一个元组,从外往里读

形状(shape)是按轴编号排好的长度表,轴(axis)是一个可独立取值的坐标方向。(2,3) 有两个长度,ndim 是 2,size 是总格数 2×3=6。(3,) 末尾的逗号表示它是只含一个长度的元组,因此只有一根轴。

import numpy as np

a = np.arange(24).reshape(2, 3, 4)
print("shape =", a.shape, " ndim =", a.ndim, " size =", a.size)

for ax in (0, 1, 2):
    print(f"a.sum(axis={ax}).shape = {a.sum(axis=ax).shape}   <- {ax} 号轴被消掉了")

print("a.sum(axis=(0, 2)).shape =", a.sum(axis=(0, 2)).shape, "  <- 一次消两个")
print("a.sum().shape            =", a.sum().shape, "        <- 不给 axis 就全消光")

实跑输出:

对照

shape = (2, 3, 4) ndim = 3 size = 24

a.sum(axis=0).shape = (3, 4) <- 0 号轴被消掉了

a.sum(axis=1).shape = (2, 4) <- 1 号轴被消掉了

a.sum(axis=2).shape = (2, 3) <- 2 号轴被消掉了

a.sum(axis=(0, 2)).shape = (3,) <- 一次消两个

a.sum().shape = () <- 不给 axis 就全消光

⭐ 规律一眼可见:输入 (2,3,4),axis=k 的输出就是把第 k 位删掉。 axis 还能给一个元组,一次删多位;不给就全删光,得到一个 NumPy 标量(这个结果的 shape=())。

shape 元组该怎么念:从左到右是从外层到内层。(2, 3, 4) 念成 「2 个 block,每个 block 里 3 行,每行 4 个数」。深度学习里最常见的 (B, L, D) 就是「B 个样本,每个样本 L 个位置,每个位置 D 维」。

⭐ 心法:想不清楚 axis 该填几,就问自己「我想让哪个数字从 shape 里消失」。 想得到「每个位置的 D 维向量的长度」?那要消掉 D,D 在第 2 位,所以 axis=2(或 axis=-1)。

🧩 二、二维的两个说法,为什么容易错

沿用开头的两行三列表。x[i,j] 指第 i 行、第 j 列的格子,两者都从 0 数起。

输入 x.shape=(2,3)
行号第 0 列第 1 列第 2 列
第 0 行123
第 1 行456
axis=0 · 固定列号,改变行号

1+4=5、2+5=7、3+6=9。行坐标已合并,只剩三个列位置,得到 [5,7,9],形状为 (3,)。

axis=1 · 固定行号,改变列号

1+2+3=6、4+5+6=15。列坐标已合并,只剩两个行位置,得到 [6,15],形状为 (2,)。

再把同样的读法用到「3 个样本 × 4 个特征」的表上。均值是先对固定组求和,再除以组内元素个数。第 0 个特征的均值是 (1+5+9)/3=5,第 0 个样本的均值是 (1+2+3+4)/4=2.5。先预测各有几个均值,再运行下面的代码。

import numpy as np

x = np.array([[1., 2., 3., 4.],
              [5., 6., 7., 8.],
              [9., 10., 11., 12.]])
print("x.shape =", x.shape, "  3 个样本 x 4 个特征")
print("x.mean(axis=0) =", x.mean(axis=0), " shape", x.mean(axis=0).shape,
      "  <- 消掉样本轴 = 每个特征的均值")
print("x.mean(axis=1) =", x.mean(axis=1), "     shape", x.mean(axis=1).shape,
      "  <- 消掉特征轴 = 每个样本的均值")

print("\n标准化时减的是哪一个:")
print("x - x.mean(axis=0)          能算,shape", (x - x.mean(axis=0)).shape)
try:
    x - x.mean(axis=1)
except ValueError as e:
    print("x - x.mean(axis=1)          ValueError:", e)
print("x - x.mean(axis=1, keepdims=True)  能算,shape",
      (x - x.mean(axis=1, keepdims=True)).shape)

实跑输出:

算一算

x.shape = (3, 4) 3 个样本 x 4 个特征

x.mean(axis=0) = [5. 6. 7. 8.] shape (4,) <- 消掉样本轴 = 每个特征的均值

x.mean(axis=1) = [ 2.5 6.5 10.5] shape (3,) <- 消掉特征轴 = 每个样本的均值

标准化时减的是哪一个:

x - x.mean(axis=0) 能算,shape (3, 4)

x - x.mean(axis=1) ValueError: operands could not be broadcast together with shapes (3,4) (3,)

x - x.mean(axis=1, keepdims=True) 能算,shape (3, 4)

⚠️ 「axis=0 是按列」这个说法为什么危险:它描述的是结果(结果确实是每列一个数), 但你要填的是被消掉的那根轴。二维时这两个说法碰巧能对上, 到了 (B, L, D) 上「按列」就没有意义了,而「消掉 1 号轴」永远有意义。

⭐ 当形状是(样本数,特征数),按特征中心化用 axis=0。每个特征减自己的均值, 要消掉的是样本那根轴。站内几处裸用都是这个形状: theory_md/05b-PCA的推导.md:231 写 Xc = X - X.mean(axis=0)(PCA 的中心化), theory_md/08-偏差方差分解.md:301 写 preds.mean(axis=0)(对多次重采样的预测求平均)。

02 / 完整解释

留轴、加轴与占位不是一回事。

🪜 三、keepdims 为什么存在

看上面那个 ValueError:x 是 (3,4),x.mean(axis=1) 是 (3,),两者不能广播。 因为轴被删掉之后,那根轴的位置信息也没了。

import numpy as np

x = np.arange(12, dtype=float).reshape(3, 4)

s1 = x.sum(axis=1)
s2 = x.sum(axis=1, keepdims=True)
print("keepdims=False ->", s1.shape, s1)
print("keepdims=True  ->", s2.shape)
print(s2)

print("\n每行除以自己的行和(keepdims=True,能广播回去):")
print(x / s2)

print("\n换成 keepdims=False:")
try:
    print(x / s1)
except ValueError as e:
    print("ValueError:", e)

实跑输出:

关键信息

keepdims=False -> (3,) [ 6. 22. 38.]
keepdims=True -> (3, 1)
[[ 6.]
[22.]
[38.]]
每行除以自己的行和(keepdims=True,能广播回去):
[[0. 0.16666667 0.33333333 0.5 ]
[0.18181818 0.22727273 0.27272727 0.31818182]
[0.21052632 0.23684211 0.26315789 0.28947368]]
换成 keepdims=False:
ValueError: operands could not be broadcast together with shapes (3,4) (3,)

⭐ keepdims=True 的作用是把消掉的那根轴留成长度 1,(3,) 变成 (3,1)。 长度 1 的轴可以被广播拉伸回去(规则见第 03 章), 例如刚才的 [6,15] 会以 [[6],[15]] 存放,两个和的数值没变,各自对应的行位置也明确了。

⭐ 先看结果要对齐哪根轴。 对 (3,4) 的表,每行一个均值时,(3,1) 能按行对齐;每列一个均值时,(4,) 已能按列对齐,(1,4) 也可以。

这就是 ML 基础 附录 C 第 1 题 那行 z = z - z.max(axis=1, keepdims=True) 里 keepdims 的全部理由: 减完之后 z 还要保持 (N, C)。 ⚠️ 那道题里 keepdims 只是顺手写的,没人解释过它为什么必须在。

➕ 四、加一根轴:None 和 np.newaxis

如果手上已经只有 [6,15] 这两个和,可以用 [:, None] 给它加回列轴,得到 [[6],[15]]。keepdims 随求和保留原轴的位置,None 则给现成的数组插入一根长度为 1 的轴,不会求和。插在前面得到 [[6,15]],形状就成了 (1,2)。

import numpy as np

v = np.arange(4)
print("v.shape          =", v.shape)
print("v[:, None].shape =", v[:, None].shape, "  <- 在后面插一根长度 1 的轴(列向量)")
print("v[None, :].shape =", v[None, :].shape, "  <- 在前面插(行向量)")
print("np.newaxis is None ->", np.newaxis is None)

print("\nv[:,None] - v[None,:] 得到一张差值表:")
print(v[:, None] - v[None, :])

x = np.arange(12).reshape(3, 4)
print("\nx.sum(axis=-1).shape =", x.sum(axis=-1).shape, " 和 axis=1 一样")
print("x.reshape(-1).shape  =", x.reshape(-1).shape, " 这里的 -1 是'你替我算',不是轴号")

实跑输出:

关键信息

v.shape = (4,)
v[:, None].shape = (4, 1) <- 在后面插一根长度 1 的轴(列向量)
v[None, :].shape = (1, 4) <- 在前面插(行向量)
np.newaxis is None -> True
v[:,None] - v[None,:] 得到一张差值表:
[[ 0 -1 -2 -3]
[ 1 0 -1 -2]
[ 2 1 0 -1]
[ 3 2 1 0]]
x.sum(axis=-1).shape = (3,) 和 axis=1 一样
x.reshape(-1).shape = (12,) 这里的 -1 是'你替我算',不是轴号

⭐ np.newaxis 就是 None 本身(np.newaxis is None 为 True), 两种写法完全等价 —— x[:, np.newaxis] 更长但更醒目,x[:, None] 更短。 ⚠️ 站内 np.newaxis 这个写法命中 0 次,[:, None] 只在两处出现过 (data_md/06:184 的 MinHash、ml_md/附录C:399 的 K-means),两处都是裸用、没有一个字的解释 —— 但你在别人的代码里两种写法都会见到。

⭐ v[:,None] - v[None,:] 这个组合是全站最值钱的一个模式: (4,1) 和 (1,4) 相减,广播成 (4,4),一次拿到所有两两组合。 第 03 章会用它算 400 个点的两两距离, ml_md/附录C:399 那行 X[:, None, :] - C[None, :, :](K-means 算距离)也是同一个模式的三维版。

⚠️ 五、两个 -1 不是一回事(高频混淆)

同一个数字出现在两个参数位置,任务就变了。先看它是交给归约,还是交给改形状。

写法 -1 的含义 例子
x.sum(axis=-1) 轴号,从后往前数:-1 = 最后一根轴,-2 = 倒数第二根 (3,4) 的 axis=-1 等于 axis=1
x.reshape(-1) 「这一位你替我算」,把总元素数除以其他维度得出 (3,4).reshape(-1) = (12,);.reshape(2,-1) = (2,6)

⭐ 区分办法:axis= 后面的 -1 是轴号,reshape() 括号里的 -1 是占位符。

⭐ 为什么大家爱写 axis=-1:因为它不依赖数组有几维。 (B, L, D) 和 (L, D) 都可以写 axis=-1 来消掉最后那根特征轴, 只要特征轴仍在最后,即使在前面加了轴,代码也不用改。

⚠️ reshape 的目标形状里,-1 最多出现一次。reshape(-1, -1) 会报 ValueError: can only specify one unknown dimension,因为两个未知数解不出来。

转置和改形状,为什么同形不同值?

还是开头的六个数。现在想让原来每一列的两个数排在同一行。两种写法都能给出 (3,2),先看它们各自怎样选第一行。

转置(transpose)· 交换两个坐标的位置

二维数组的 x.T 让旧的第 j 列变成新表的第 j 行。 新格 [j,i] 读取旧格 [i,j],所以先取旧表第 0 列的 1 和 4,整张新表是 [[1,4],[2,5],[3,6]]。

重塑(reshape)· 按索引顺序重新分组

x.reshape(3,2) 默认按 order="C" 读,最右边的坐标先变化。这里依次读出 1,2,3,4,5,6,再每两个数分一行,得到 [[1,2],[3,4],[5,6]]。原来的 2×3 和新的 3×2 都是 6 格。

先猜哪种写法保留旧表的列关系。下面先打印位置和形状,再检查结果是否和输入共用数据。

import numpy as np

x = np.array([[1, 2, 3], [4, 5, 6]])
transposed = x.T
reshaped = x.reshape(3, 2)
repacked = transposed.reshape(6)

print(x.shape)                           # (2, 3)
print(transposed.shape, transposed.tolist())  # (3, 2) [[1, 4], [2, 5], [3, 6]]
print(reshaped.shape, reshaped.tolist())  # (3, 2) [[1, 2], [3, 4], [5, 6]]
print(repacked.shape, repacked.tolist())  # (6,) [1, 4, 2, 5, 3, 6]
print(np.shares_memory(x, transposed))   # True
print(np.shares_memory(x, reshaped))     # True
print(np.shares_memory(x, repacked))     # False

np.shares_memory 检查两份数组的数据是否有重叠。本例中转置和直接重塑都得到视图(view),也就是从同一批数据读取的另一种方式;先转置再按默认顺序压平则得到拷贝(copy)。压平要依次读取 1,4,2,5,3,6,在原存放顺序里从 1 到 4 向后跨三格,从 4 到 2 又向前跨两格,无法用固定的间隔读成一维视图。从 shape 无法判断是否共享。 第 04 章解释为什么共享时改一边可能影响另一边,第 05 章再解释何时需要拷贝。

03 / 完整解释

换一个形状,再核对一次。

📋 六、一页速记

想干的事 写法
消掉第 k 根轴 a.sum(axis=k) / a.mean(axis=k) / a.max(axis=k)
消掉最后一根轴(不管几维) a.sum(axis=-1)
一次消好几根 a.sum(axis=(0, 2))
全消光成标量 a.sum()
归约后在原轴位置留长度 1(便于对齐) a.sum(axis=k, keepdims=True)
凭空插一根长度 1 的轴 a[:, None] / a[None, :] / a[..., None]
压平成一维 a.reshape(-1) / a.ravel()
只知道一部分形状 a.reshape(2, -1)
找最大值的位置而不是值 a.argmax(axis=k)(⭐ 输出 shape 和 a.max(axis=k) 一样)

⚠️ ...(Ellipsis) 是「剩下的轴全要」:a[..., 0] 不管 a 有几维, 都表示「最后那根轴取第 0 个」。和 a[:, :, 0] 相比,它不依赖维数。

🔗 这一章连到哪里

相关的地方 为什么
03 · 广播的三条规则 ⭐ 本章的 keepdims 和 None 只说了「留一根长度 1 的轴」,为什么长度 1 就能拉伸是那一章的正题
05 · 内存布局、stride 与 C/F order ⭐ 本章说 axis 是形状元组里的位置。那一章讲每根轴在内存里对应多大的跳步,以及为什么 sum(axis=0) 和 sum(axis=1) 耗时能差 2 倍
06 · 索引的四种形态 a[:, None] 用的是索引语法。那一章讲清索引的四种形态各自返回什么
11 · 从 NumPy 到 PyTorch ⚠️ PyTorch 里同一件事叫 dim 不叫 axis,报错信息和文档全用 dim
数学原理 05b · PCA 的推导 那里的 Xc = X - X.mean(axis=0) 是本章第二节的现场:中心化要消掉样本轴
数学原理 08 · 偏差方差分解 那里的 preds.mean(axis=0) / preds.var(axis=0) 是同一个形状:多次重采样的预测堆成 (次数, 样本),消掉「次数」那根轴
数学原理 01b · KL 散度 那里的 np.sum(P * np.log(q), axis=1) 是「每个样本的分布求和」——消掉的是类别轴
ML 基础 附录 C · 手撕代码速查 ⭐ 第 1 题那行 z - z.max(axis=1, keepdims=True) 是本章第三节的正主。那是一道题的写法,这一章是它成立的理由

✅ 检查点

  1. axis=k 到底是什么意思?用一句不含「行」「列」的话说清楚。
  2. (2,3,4) 的数组,sum(axis=1) 输出什么形状?sum(axis=(0,2)) 呢?sum() 呢?
  3. 「axis=0 就是按列」这个说法哪里危险?
  4. 按特征中心化(每个特征减自己的均值)该用 axis=0 还是 axis=1?为什么?
  5. keepdims=True 解决的是什么问题?什么时候必须加、什么时候不用加?
  6. np.newaxis 和 None 是什么关系?v[:,None] - v[None,:] 得到什么?
  7. ⭐ x.sum(axis=-1) 里的 -1 和 x.reshape(-1) 里的 -1,含义分别是什么?怎么区分?
  8. 特征总在最后一轴时,为什么 axis=-1 比固定写 axis=2 更好复用?
  9. 对于开头的两行三列表,x.T[0,1] 与 x.reshape(3,2)[0,1] 各是几?哪个保留旧表的列关系?
👀 答案
  1. axis=k 表示沿第 k 根轴归约,默认在结果形状中移除这根轴。 不用想「横着竖着」——那些说法二维时勉强能用,到 (B,L,D) 就全乱。
  2. (2,3,4) → sum(axis=1) 得 (2,4)(第 1 位没了);sum(axis=(0,2)) 得 (3,)(一次删两位);sum() 得到 NumPy 标量,shape 是 ()。
  3. 它描述的是结果(结果确实是每列一个数),但你要填的是被消掉的那根轴。二维时碰巧能对上,到 (B,L,D) 上「按列」就没有意义了,而「消掉 1 号轴」永远有意义。
  4. axis=0。对「样本 × 特征」的表按特征中心化,要消掉的是样本那根轴,结果 shape 是 (4,)(每个特征一个数)。theory_md/05b:231 的 Xc = X - X.mean(axis=0) 就是这个形状。
  5. 归约时保留被合并轴的位置,后续可以按原轴对齐。以每行求和为例,x 是 (3,4),x.sum(axis=1) 是 (3,),x / s1 直接 ValueError;keepdims=True 给出 (3,1),长度 1 的轴能被拉伸回去,x / s2 就对了。先核对要保留哪根轴的位置。例如按特征求均值产生的 (4,) 已能和 (3,4) 对齐。
  6. np.newaxis 就是 None 本身(np.newaxis is None 为 True),两种写法完全等价。v[:,None] 是 (4,1)、v[None,:] 是 (1,4),相减广播成 (4,4),一次拿到所有两两组合(实跑那张差值表)。ml_md/附录C:399 的 X[:,None,:] - C[None,:,:] 是同一个模式的三维版。
  7. axis=-1 里的 -1 是轴号(从后往前数,-1 是最后一根);reshape(-1) 里的 -1 是「这一位你替我算」的占位符。区分办法:axis= 后面的是轴号,reshape() 括号里的是占位符。 ⚠️ reshape(-1,-1) 会报 can only specify one unknown dimension。
  8. 因为 axis=-1 不依赖数组有几维。(B,L,D) 和 (L,D) 都能写 axis=-1 消掉最后那根特征轴,只要特征轴仍在最后,代码就能复用。
  9. 分别是 4 和 2。转置的第 0 行取旧表第 0 列,重塑的第 0 行取默认读取顺序中的前两个数。

本节回顾

⚡ 走神救援

⭐ 归约时先找变化的坐标。 默认删掉结果形状中的这根轴,keepdims=True 则把对应长度写成 1。

别去想「行」「列」「横着竖着」——那些说法二维时勉强能用,到 (B, L, D) 就全乱。shape 元组从左到右是从外层到内层,(2,3,4) 念成「2 个 block,每个 3 行,每行 4 个数」。

⭐ 心法:想不清 axis 填几,就问「我想让哪个数字从 shape 里消失」。 ⚠️ 「axis=0 就是按列」这个说法危险:它描述的是结果,而你要填的是被消掉的那根轴——二维碰巧对得上,三维就没意义了。

⭐ 按特征中心化要消掉样本轴。数据排成「样本 × 特征」时,样本轴是 axis=0。

归约结果还要用来和原表计算时,先核对轴对齐。 例如行和留成 (3,1) 就能分别用于三行;列和是 (4,) 时已经按最后一轴对齐。

凭空插轴用 None(⭐ np.newaxis 就是 None 本身)。

⭐ v[:,None] - v[None,:] 是全站最值钱的一个模式:(4,1) 和 (1,4) 相减广播成 (4,4),一次拿到所有两两组合——K-means 算距离就是它的三维版。

⚠️⚠️ 两个 -1 不是一回事:axis=-1 里的 -1 是轴号(从后往前数),reshape(-1) 里的 -1 是「这一维你自己算」。

下一节 👉 03-广播的三条规则.md

打卡记录保存在你的浏览器里,首页能看到总进度

输出形状留成 (1,3) 以后,为什么又能和 (2,3) 一起算?下一章接着看广播。