矩阵运算法则这四个字，课堂上一听觉得没什么，一到自己动手做题或者跑数据就开始出错。这次干脆把从加减、数乘到乘法、转置、逆矩阵、行列式这些基本法则整理成一篇笔记，重点讲清楚每条法则是什么、为什么这样定义、实际用的时候有哪些坑。适合正在学线性代数的同学，也适合做数据分析、图像处理、机器学习时想补一补矩阵基础的朋友。

1. 先搞懂矩阵是什么：从数字表格到线性变换

1.1 矩阵的另一个身份：线性变换

第一次接触矩阵，绝大多数人都会觉得这就是一张数字表格，横竖整齐排好，仅此而已。这个视角不能说错，但它会严重限制你对后续所有运算法则的理解。

矩阵更本质的身份是线性变换。所谓变换，就是输入一个向量、输出另一个向量。比如下面这个 2×2 矩阵：

[ 0 -1 ] [ 1 0 ]

把它乘到任意向量[x, y]上：

[ 0 -1 ] × [ x ] = [ -y ] [ 1 0 ] [ y ] [ x ]

结果向量恰好是原向量逆时针旋转 90 度。所以这一个矩阵本身，就代表"旋转 90 度"这个操作。

我自己学矩阵最大的转折点，就是不再把它当表格，而是当成滤镜。一张照片经过不同滤镜会得到不同效果；多个滤镜叠加时，顺序不同，最终效果完全不同。矩阵乘法之所以规则那么"别扭"，本质上就是在描述这种操作的复合。

带着这个视角往下学，很多法则的"为什么"就都能讲通了。

1.2 维度匹配：动手前必须先做的事

矩阵的形状用"行数 × 列数"表示。一个 2 行 3 列的矩阵记作 2×3。向量可以看成特殊的矩阵，比如列向量就是 n×1 矩阵，行向量就是 1×n 矩阵。

形状匹配是所有矩阵运算的第一道门槛。

• 相加、相减：两个矩阵必须形状完全一致，2×3 只能和 2×3 加减。
• 矩阵乘法 A×B：要求 A 的列数等于 B 的行数，否则没有定义。

可以把维度匹配理解成 USB 接口：形状对不上，物理上就插不进去，后面所有运算都免谈。我见过太多人拿到题目不标维度直接开算，算到一半发现结果矩阵的行列数都对不上，只好从头再来。

实操习惯：拿到任何矩阵运算题目，先在草稿纸上把每个矩阵的维度标出来。这个习惯笨，但极其有效，后面所有章节都默认你已经做好了这一步。

2. 加减法和数乘怎么算：基础运算里的细节坑

2.1 矩阵加法：形状不一致一切免谈

矩阵加法的规则一句话就能说完：对应位置元素相加。

[ 1 2 ] [ 5 6 ] [ 6 8 ] [ 3 4 ] + [ 7 8 ] = [ 10 12 ]

第 1 行第 1 列加第 1 行第 1 列，第 1 行第 2 列加第 1 行第 2 列，依此类推。

因为是逐元素做加法，所以矩阵加法天然满足交换律和结合律：

• A + B = B + A
• (A + B) + C = A + (B + C)

这两个性质跟普通数字加法没有本质区别，不用死记。

但这里有个容易踩的坑：某些数值计算工具支持"广播"机制，比如形状不匹配时自动把小的矩阵扩展成大的形状再做运算。这是工程便利，不是数学法则。做题时绝不能默认两个不同形状的矩阵可以相加，2×3 和 1×3 在严格数学定义下就是不能加。

2.2 数乘：把整张矩阵一起缩放

数乘就是用一个数字 k 去乘矩阵，规则是矩阵里的每一个元素都乘上 k。

[ 1 2 ] [ 2 4 ] [ 3 4 ] × 2 = [ 6 8 ]

从线性变换的角度看，数乘就是把整个空间沿所有方向同时缩放。k 大于 1 是拉伸，k 在 0 到 1 之间是压缩，k 为负数还会翻到相反方向。

数乘满足这些法则：

• k(A + B) = kA + kB
• (m + n)A = mA + nA
• (mn)A = m(nA)

最需要注意的是区分"数乘"和"矩阵乘法"。数乘是每个元素缩放，而矩阵乘法是行和列的内积运算。在代码里尤其危险，有些语言里A * 2没问题，2 * A通常也没问题，但一旦你把 2 写成一个 1×1 的矩阵，再去和 A 做真正的矩阵乘法，维度可能就不匹配，直接报错。

3. 矩阵乘法怎么算：行乘列规则与三条反直觉性质

3.1 行乘列的正确姿势与一个简单例子

矩阵乘法是整个矩阵运算的核心，规则可以用一句话概括：结果矩阵第 i 行第 j 列的元素，等于左边矩阵第 i 行与右边矩阵第 j 列逐项相乘再求和。

用公式写就是：

C[i][j] = Σ A[i][k] × B[k][j]

拿两个 2×2 矩阵举例：

A = [ 1 2 ] B = [ 5 6 ] [ 3 4 ] [ 7 8 ] A × B = [ 1×5 + 2×7 1×6 + 2×8 ] = [ 19 22 ] [ 3×5 + 4×7 3×6 + 4×8 ] [ 43 50 ]

维度规律是：A 是 m×n，B 是 n×p，那么 AB 是 m×p。中间的 n 必须相等，这也是为什么说"内维度必须匹配"。

这里还藏着一个性能直觉：一次矩阵乘法需要做 m×n×p 次乘加。如果 m、n、p 都很大，运算量是惊人的。后面很多优化技巧，比如分块、缓存复用、先合并矩阵减少乘法次数，本质上都是在想办法降低这个数字。

3.2 为什么矩阵乘法偏偏要这样定义

这是初学者问得最多的一个问题：为什么矩阵乘法不是逐元素相乘，而是要搞出行乘列这么麻烦的规则？

答案很简单：因为矩阵代表的是变换，矩阵乘法代表的是变换的复合。

假设你先做变换 B，再做变换 A，那么把两步合并成一步，得到的矩阵应该是多少？数学推导的结果就是行乘列规则。每一列的操作逻辑很清晰：最终结果矩阵的第 j 列，等于左边矩阵乘以右边矩阵的第 j 列。也就是说，复合变换对第 j 个基向量做了什么，完全取决于右边矩阵的第 j 列被左边矩阵映射到哪里。

你可以用生活中的例子理解：先切菜再炒菜，和先炒菜再切菜完全不同。矩阵乘法的定义必须保证"合并后的矩阵"等价于"按顺序依次应用两个变换"。如果改成逐元素乘法，两个变换的复合关系就完全对不上了。

这也是为什么矩阵乘法满足结合律：(AB)C = A(BC)。因为变换复合本身就是按顺序进行的，括号只是决定你先把哪两个变换合并成一步，不会改变最终的整体变换效果。

3.3 交换律、消去律、零因子：三条反直觉法则

矩阵乘法有两个地方跟普通数的乘法非常不一样，初学者特别容易翻车。

第一，矩阵乘法不满足交换律。AB 大概率不等于 BA。

A = [ 1 1 ] B = [ 1 0 ] [ 0 1 ] [ 1 1 ] AB = [ 2 1 ] BA = [ 1 1 ] [ 1 1 ] [ 1 2 ]

两者完全不同。在图像处理里，旋转和缩放矩阵的顺序写反，输出的图片就直接歪掉。我自己的项目里就犯过这种错，后来学乖了，凡是复合变换，一律先在纸上把顺序写清楚。

第二，矩阵乘法不满足消去律。AB = AC 不能直接推出 B = C，除非 A 是可逆矩阵。原因在于 A 可能把不同的向量映射到同一个结果上，信息丢了就补不回来。

同样地，AB = 0 也不能推出 A = 0 或 B = 0。比如：

A = [ 1 0 ] B = [ 0 0 ] [ 0 0 ] [ 0 1 ]

AB 等于零矩阵，但 A 和 B 都不是零矩阵。这是矩阵世界跟实数世界差异最大的地方，第一次见到的人基本上都会愣一下。

结合律反而是有用的。比如计算 ABC，如果 A 是 1×10000，B 是 10000×10，C 是 10×100，先算 AB 再乘 C，需要约 101000 次乘加；先算 BC 再乘 A，需要约 11000000 次乘加，差了上百倍。这就是为什么工程代码里优化矩阵乘法时，很讲究运算顺序。

4. 转置和对称矩阵：为什么(AB)ᵀ要反序

4.1 转置的三条核心法则

转置就是把矩阵的行和列互换。一个 m×n 矩阵转置后变成 n×m。

转置的运算法则并不多，但其中有一条特别重要：

• (A + B)ᵀ = Aᵀ + Bᵀ
• (kA)ᵀ = kAᵀ
• (AB)ᵀ = BᵀAᵀ← 注意顺序反了

前两条很直观，转置不改变加法和数乘的结构。第三条是重灾区，几乎每次考试都会有人写成 (AB)ᵀ = AᵀBᵀ。

为什么转置要反序？可以这样理解：AB 表示先做 B 再做 A。转置相当于把这个复合变换"倒过来看"，那么自然应该是先对 A 做转置、再对 B 做转置，顺序反转。拿穿衣服类比：先穿衬衫再穿外套，脱的时候一定是先脱外套再脱衬衫。运算顺序和撤销顺序永远是反着的。

验证方式很简单，取 2×2 矩阵手算一遍就能看到 (AB)ᵀ 的第 i 行第 j 列元素确实等于 BᵀAᵀ 的对应元素。

4.2 对称矩阵与AᵀA：转置的真实用途

如果一个方阵满足 Aᵀ = A，就称它为对称矩阵。对称矩阵有非常好的性质，比如特征值一定是实数，这在很多工程计算里直接决定了算法能不能稳定运行。

有一个结论在最小二乘、回归分析里出现频率极高：AᵀA 一定是一个对称矩阵，而且通常是半正定的。因为 (AᵀA)ᵀ = Aᵀ(Aᵀ)ᵀ = AᵀA。这个性质是正规方程 AᵀAx = Aᵀb 的基础。

除此之外，任意一个方阵都可以拆成一个对称矩阵和一个反对称矩阵之和：

A = (A + Aᵀ)/2 + (A - Aᵀ)/2

这个公式看着简单，但在多元微积分里判断二次型、在力学里分解应变张量时都会反复出现。

实际写代码时，转置的反序问题最容易出 bug。如果你在推导公式时写漏了一个转置，或者把转置顺序写反，最终结果很可能方向完全正确、数值完全错误，非常隐蔽。

5. 逆矩阵和行列式：矩阵的除法与体积密码

5.1 逆矩阵：怎么求、怎么用

逆矩阵可以理解为矩阵世界里的除法。如果方阵 A 存在一个矩阵 B，使得 AB = BA = I（I 是单位矩阵，相当于数字 1），那么 B 就是 A 的逆矩阵，记作 A⁻¹。

2×2 矩阵的逆有现成公式：

A = [ a b ] [ c d ] A⁻¹ = 1/(ad - bc) × [ d -b ] [ -c a ]

注意分母 ad - bc，这个数就是 A 的行列式。行列式为 0 时，公式直接失效，矩阵不可逆。几何意义也很直白：如果这个矩阵代表的变换把整个平面压成一条线甚至一个点，那这个操作是不可逆的，没有哪个矩阵能"撤销"它。

逆矩阵有几条运算法则，同样需要盯住反序问题：

• (A⁻¹)⁻¹ = A
• (AB)⁻¹ = B⁻¹A⁻¹
• (Aᵀ)⁻¹ = (A⁻¹)ᵀ

第二条和转置的反序是同一个道理：先做的事要后撤销。先穿袜子再穿鞋，脱的时候必然先脱鞋再脱袜子。

逆矩阵最直观的应用是解线性方程组：Ax = b 两边左乘 A⁻¹，得到 x = A⁻¹b。不过我自己写代码解大规模方程组时，几乎不会真的去求逆矩阵，而是用消元法或矩阵分解。原因很实际：求逆的计算量大，数值稳定性也不如分解算法。但小规模问题、以及公式推导场景下，逆矩阵依然是最好用的记号。

5.2 行列式：它才是判断可逆的关键

行列式是方阵的一个标量，2×2 的时候就是 ad - bc，3×3 的时候按展开公式可以算出来，但不要只把它当计算题。

行列式的几何意义是线性变换对空间的体积缩放倍数。一个 2×2 矩阵把平面上的图形映射到新位置，面积变化了多少？答案就是行列式的绝对值。三维时则是体积的缩放。

行列式法则有下面几条需要记住：

• det(AB) = det(A) × det(B)
• det(Aᵀ) = det(A)
• det(A⁻¹) = 1 / det(A)
• 交换矩阵的两行或两列，行列式变号
• 某一行乘以 k，行列式变为原来的 k 倍

第一条 det(AB) = det(A)det(B) 尤其重要。它可以解释为什么行列式为 0 就不可逆：如果某个变换把空间压扁，体积缩放倍数是 0，那这个变换就谈不上有逆操作。

判断一个矩阵是否可逆，最稳定的方式就是算行列式。矩阵 A 可逆的充要条件是 det(A) ≠ 0。这个结论贯穿整个线性代数，从解方程组到特征值计算，到处都用得上。

6. 常见错误与排查技巧：做题写代码前先看这份速查

6.1 六个高频翻车现场

这六个问题里，前五个都是"看着像常识，实际动手就忘"的典型。我自己每个都踩过，其中转置反序那个坑让我排查了整整一个下午，最后发现问题不在代码逻辑，而在公式推导时漏了一个转置。

6.2 写代码前必做的矩阵运算检查清单

如果你用数值计算库写矩阵运算，我有一个固定的检查流程，分享出来：

1. 先打印形状：拿到矩阵先看 shape，别急着算。
2. 用单位矩阵做冒烟测试：任何矩阵乘单位矩阵，结果必须等于原矩阵。如果这一步不对，说明乘法实现本身有问题。
3. 用小规模随机矩阵验证法则：比如随机生成两个 2×2 矩阵，分别算 (AB)ᵀ 和 BᵀAᵀ，对比结果是否一致。这个方法几乎能覆盖所有法则类 bug。

代码示意一下：

import numpy as np A = np.array([[1.0, 2.0], [3.0, 4.0]]) B = np.array([[5.0, 6.0], [7.0, 8.0]]) # 矩阵乘法 print(A @ B) # 转置法则验证：(AB)ᵀ 应该等于 BᵀAᵀ print((A @ B).T) print(B.T @ A.T) # 两者应该完全一致

注意在 Python 里@才是矩阵乘法，*通常做逐元素乘法。很多初学者拿*做矩阵乘法，得到的结果和预期完全不是一回事。

6.3 避坑经验小结

最后分享一个我个人用过最笨但最有效的方法：每学一条新的矩阵运算法则，就手动算一个 2×2 的例子验证一下。比如学 (AB)ᵀ = BᵀAᵀ，就真的找两个 2×2 矩阵算一遍。花不了三分钟，但你的直觉会变得非常牢靠，考试和实际项目里都能少踩很多坑。

矩阵运算最容易出问题的从来不是计算量，而是顺序和条件判断。先把维度看清，再把顺序写对，最后用单位矩阵做一次验证，这三个习惯能覆盖绝大多数低级错误。后面学特征值、最小二乘、图像变换时，你会发现前期这些基本功打得越扎实，走弯路的时间越少。