别再死记公式了！用Python的NumPy库5分钟搞定伴随矩阵求逆（附代码对比）

易行男·龙大崇

331人浏览 · 2026-06-29 10:45:02

易行男·龙大崇 · 2026-06-29 10:45:02 发布

别再死记公式了！用Python的NumPy库5分钟搞定伴随矩阵求逆（附代码对比）

线性代数中伴随矩阵求逆的方法，是许多工科学生又爱又恨的内容。爱的是它提供了一种通用的矩阵求逆方法，恨的是手工计算伴随矩阵的过程繁琐且容易出错。想象一下，当你花了半小时计算一个3×3矩阵的伴随矩阵，最后发现行列式算错了，那种挫败感简直让人抓狂。

好在，我们有Python和NumPy这个强大的组合。本文将带你用NumPy快速验证伴随矩阵求逆的结果，处理更高维度的矩阵，并深入理解手工计算与计算机计算的差异。我们会通过两个经典案例（2×2旋转矩阵和3×3一般矩阵）进行对比，并讨论数值精度、计算效率等实际问题。

1. 伴随矩阵求逆：原理回顾

在深入代码之前，我们先快速回顾一下伴随矩阵求逆的数学原理。对于一个n×n的可逆矩阵A，其逆矩阵可以通过以下公式计算：

A⁻¹ = (1/det(A)) * adj(A)

其中：

det(A) 是矩阵A的行列式
adj(A) 是A的伴随矩阵，即A的余子矩阵的转置

关键点 ：

只有当det(A)≠0时，矩阵A才是可逆的
对于2×2矩阵，伴随矩阵计算很简单：
```
adj([[a, b], [c, d]]) = [[d, -b], [-c, a]]
```
对于更大的矩阵，计算量呈指数级增长

注意：伴随矩阵(adjugate matrix)有时也被称为"古典伴随矩阵"(classical adjoint)，不要与现代的"伴随矩阵"(adjoint matrix)概念混淆。

2. NumPy实现：简洁高效的矩阵求逆

NumPy提供了极其简洁的矩阵求逆方法。让我们先看看基础用法：

import numpy as np

# 定义一个2×2矩阵
A = np.array([[1, 2], [2, 5]])

# 求逆矩阵
A_inv = np.linalg.inv(A)
print("逆矩阵:\n", A_inv)

输出结果：

逆矩阵:
 [[ 5. -2.]
 [-2.  1.]]

这与手工计算结果完全一致。NumPy的 linalg.inv 函数内部使用了更高效的数值算法（通常是LU分解），不仅速度快，而且精度高。

2.1 计算效率对比

为了展示NumPy的效率优势，我们创建一个随机的100×100矩阵进行测试：

import time

# 生成100×100随机矩阵
large_matrix = np.random.rand(100, 100)

# 计时开始
start_time = time.time()

# 计算逆矩阵
inv_large = np.linalg.inv(large_matrix)

# 计时结束
print(f"计算100×100矩阵逆矩阵耗时: {time.time()-start_time:.4f}秒")

在我的笔记本上，这个计算仅需约0.01秒——这是手工计算完全无法企及的速度。

3. 经典案例对比：手工计算 vs NumPy

3.1 案例1：旋转矩阵

考虑一个2×2旋转矩阵：

theta = np.pi/4  # 45度
A = np.array([
    [np.cos(theta), -np.sin(theta)],
    [np.sin(theta), np.cos(theta)]
])

手工计算结果（理论值）：

A⁻¹ = [[ cosθ, sinθ],
       [-sinθ, cosθ]]

NumPy计算结果：

print("NumPy计算结果:\n", np.linalg.inv(A))
print("理论结果:\n", A.T)  # 旋转矩阵的逆就是它的转置

输出对比：

NumPy计算结果:
 [[ 0.70710678  0.70710678]
 [-0.70710678  0.70710678]]
理论结果:
 [[ 0.70710678  0.70710678]
 [-0.70710678  0.70710678]]

两者完全一致，验证了我们的实现。

3.2 案例2：3×3一般矩阵

考虑一个更复杂的3×3矩阵：

A = np.array([
    [1, 2, -1],
    [3, 4, -2],
    [5, -4, 1]
])

手工计算这个矩阵的伴随矩阵需要计算9个2×2子矩阵的行列式，非常繁琐。而使用NumPy：

# 计算行列式
det_A = np.linalg.det(A)
print("行列式:", det_A)

# 计算逆矩阵
A_inv = np.linalg.inv(A)
print("逆矩阵:\n", A_inv)

输出结果：

行列式: 2.0
逆矩阵:
 [[-2.   1.   0. ]
 [-6.5  3.  -0.5]
 [-16.   7.  -1. ]]

这与手工计算结果一致，但计算过程只需几毫秒。

4. 数值精度与实用建议

虽然NumPy的计算非常高效，但在处理接近奇异的矩阵（行列式接近0）时，数值精度问题需要注意。

4.1 数值精度测试

让我们构造一个接近奇异的矩阵：

B = np.array([
    [1, 2],
    [2, 4.00000001]
])

print("行列式:", np.linalg.det(B))  # 理论上应为0.00000001
print("逆矩阵:\n", np.linalg.inv(B))

输出：

行列式: 1.00000001e-08
逆矩阵:
 [[ 400000001. -200000000.]
 [-200000000.  100000000.]]

可以看到，虽然数学上这个矩阵是可逆的，但实际计算中会出现极大的数值，可能导致后续计算中的数值不稳定。

4.2 实用建议

检查条件数 ：计算前先用 np.linalg.cond() 检查矩阵条件数，条件数越大，矩阵越接近奇异
```
print("条件数:", np.linalg.cond(A))
```
使用伪逆 ：对于可能奇异的矩阵，考虑使用伪逆 np.linalg.pinv
数值稳定性 ：对于大型矩阵，直接求逆可能不是最佳选择，考虑使用矩阵分解或其他数值方法

5. 何时需要理解原理

虽然NumPy可以轻松完成矩阵求逆，但在以下情况下，理解伴随矩阵的原理仍然很重要：

理论推导 ：在证明定理或推导公式时，需要理解背后的数学原理
特殊结构矩阵 ：某些具有特殊结构的矩阵可能有简化的求逆方法
教学目的 ：学习阶段理解原理有助于建立扎实的数学基础
算法开发 ：开发新的数值算法时需要理解传统方法的优缺点

# 理解原理的代码示例：手动实现2×2矩阵求逆
def manual_inv_2x2(matrix):
    a, b = matrix[0,0], matrix[0,1]
    c, d = matrix[1,0], matrix[1,1]
    det = a*d - b*c
    if det == 0:
        raise ValueError("矩阵不可逆")
    return np.array([[d, -b], [-c, a]]) / det

# 测试手动实现
test_matrix = np.array([[1, 2], [3, 4]])
print("手动实现:\n", manual_inv_2x2(test_matrix))
print("NumPy结果:\n", np.linalg.inv(test_matrix))

6. 进阶应用：自定义伴随矩阵计算

虽然实际应用中我们很少需要手动计算伴随矩阵，但为了深入理解，我们可以实现一个通用的伴随矩阵计算函数：

def adjugate(matrix):
    n = matrix.shape[0]
    adj = np.zeros((n, n))
    
    for i in range(n):
        for j in range(n):
            # 计算余子式
            minor = np.delete(np.delete(matrix, i, axis=0), j, axis=1)
            adj[j, i] = ((-1) ** (i + j)) * np.linalg.det(minor)
    
    return adj

# 测试3×3矩阵
A = np.array([[1, 2, -1], [3, 4, -2], [5, -4, 1]])
print("伴随矩阵:\n", adjugate(A))
print("通过伴随矩阵计算的逆矩阵:\n", adjugate(A)/np.linalg.det(A))
print("NumPy直接计算的逆矩阵:\n", np.linalg.inv(A))

这个实现虽然直观，但计算复杂度是O(n!)，对于n>3的矩阵效率极低。在实际项目中，我们总是优先使用 np.linalg.inv 。