NumPy矩阵运算函数详解：从基础创建到高级线性代数操作

NumPy矩阵运算函数详解

NumPy作为Python科学计算的核心库，提供了丰富且高效的矩阵运算函数。本文系统梳理了从基础创建到高级线性代数操作的常用函数，并通过代码示例展示具体用法，帮助读者快速掌握NumPy矩阵操作。

基本矩阵创建与操作

numpy.array() - 创建数组

功能：创建NumPy数组，是矩阵操作的基础。可将列表、元组等序列转换为NumPy数组。

import numpy as np
# 创建一维数组
arr1 = np.array([1, 2, 3, 4])
# 创建二维数组（矩阵）
matrix = np.array([[1, 2, 3], [4, 5, 6]])
# 指定数据类型
arr_float = np.array([1, 2, 3], dtype=np.float64)
print("一维数组:", arr1)
print("二维矩阵:n", matrix)
print("数据类型:", arr_float.dtype)

输出：一维数组: [1 2 3 4]；二维矩阵: [[1 2 3] [4 5 6]]；数据类型: float64

应用场景：任何需要将Python数据结构转换为NumPy数组的场景。

numpy.matrix() - 创建矩阵对象（已不推荐）

功能：创建专门的矩阵对象，提供类似MATLAB的矩阵操作接口。注意：官方已不推荐在新代码中使用。

mat = np.matrix([[1, 2], [3, 4]])
print("矩阵对象:n", mat)
print("类型:", type(mat))

输出：矩阵对象: [[1 2] [3 4]]；类型: <class 'numpy.matrix'>

特殊矩阵创建

numpy.zeros() - 创建全零矩阵

功能：创建指定形状的全零矩阵。

zeros_3x3 = np.zeros((3, 3))
zeros_3d = np.zeros((2, 3, 4))
print("3x3零矩阵:n", zeros_3x3)
print("2x3x4零数组形状:", zeros_3d.shape)

输出：3x3零矩阵: [[0. 0. 0.] [0. 0. 0.] [0. 0. 0.]]；2x3x4零数组形状: (2, 3, 4)

应用场景：初始化权重矩阵、创建掩码等。

numpy.ones() - 创建全1矩阵

功能：创建指定形状的全1矩阵。

ones_2x4 = np.ones((2, 4))
ones_int = np.ones((3, 3), dtype=int)
print("2x4全1矩阵:n", ones_2x4)

输出：2x4全1矩阵: [[1. 1. 1. 1.] [1. 1. 1. 1.]]

numpy.eye() / numpy.identity() - 创建单位矩阵

功能：创建单位矩阵（对角线为1，其余为0）。

I3 = np.eye(3)
I4 = np.identity(4)
rect_eye = np.eye(3, 5)
print("3x3单位矩阵:n", I3)
print("3x5对角矩阵:n", rect_eye)

输出：3x3单位矩阵: [[1. 0. 0.] [0. 1. 0.] [0. 0. 1.]]；3x5对角矩阵: [[1. 0. 0. 0. 0.] [0. 1. 0. 0. 0.] [0. 0. 1. 0. 0.]]

应用场景：线性代数运算、特征值分解、作为恒等变换。

numpy.diag() - 创建对角矩阵或提取对角线

功能：从对角线元素创建矩阵，或从矩阵提取对角线。

diag_matrix = np.diag([1, 2, 3, 4])
print("对角矩阵:n", diag_matrix)
matrix = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
diagonal = np.diag(matrix)
print("矩阵对角线:", diagonal)

输出：对角矩阵: [[1 0 0 0] [0 2 0 0] [0 0 3 0] [0 0 0 4]]；矩阵对角线: [1 5 9]

矩阵运算

numpy.dot() / @运算符 - 矩阵乘法

功能：矩阵点积/乘法。对于二维数组，计算矩阵乘积。

A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])
result1 = np.dot(A, B)
result2 = A @ B  # Python 3.5+ 推荐
result3 = A.dot(B)
print("A @ B = n", result1)
print("结果是否相同:", np.array_equal(result1, result2))

输出：A @ B = [[19 22] [43 50]]；结果是否相同: True

应用场景：神经网络前向传播、线性变换、3D图形变换。

numpy.matmul() - 矩阵乘法（更通用）

功能：矩阵乘法，支持广播机制。

A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])
result = np.matmul(A, B)
batch_A = np.random.randn(10, 3, 4)  # 10个3x4矩阵
batch_B = np.random.randn(10, 4, 5)  # 10个4x5矩阵
batch_result = np.matmul(batch_A, batch_B)  # 得到10个3x5矩阵
print("单个矩阵乘法:n", result)
print("批量矩阵乘法形状:", batch_result.shape)

输出：单个矩阵乘法: [[19 22] [43 50]]；批量矩阵乘法形状: (10, 3, 5)

numpy.inner() - 向量内积

功能：计算向量内积或高维数组的内积。

v1 = np.array([1, 2, 3])
v2 = np.array([4, 5, 6])
inner_product = np.inner(v1, v2)  # 1*4 + 2*5 + 3*6 = 32
print("向量内积:", inner_product)

输出：向量内积: 32

numpy.outer() - 外积

功能：计算两个向量的外积。

v1 = np.array([1, 2, 3])
v2 = np.array([4, 5, 6, 7])
outer_product = np.outer(v1, v2)
print("外积矩阵:n", outer_product)
print("形状:", outer_product.shape)

输出：外积矩阵: [[ 4 5 6 7] [ 8 10 12 14] [12 15 18 21]]；形状: (3, 4)

应用场景：协方差矩阵计算、信号处理。

numpy.cross() - 向量叉积

功能：计算向量叉积（仅适用于2D或3D向量）。

a = np.array([1, 0, 0])
b = np.array([0, 1, 0])
cross_product = np.cross(a, b)  # [0, 0, 1]
print("叉积:", cross_product)

输出：叉积: [0 0 1]

矩阵分解与线性代数

numpy.linalg.inv() - 矩阵求逆

功能：计算方阵的逆矩阵。

A = np.array([[1, 2], [3, 4]])
try:
    A_inv = np.linalg.inv(A)
    print("矩阵A:n", A)
    print("逆矩阵:n", A_inv)
    print("验证 A @ A_inv:n", A @ A_inv)  # 应接近单位矩阵
except np.linalg.LinAlgError:
    print("矩阵不可逆")

输出：矩阵A: [[1 2] [3 4]]；逆矩阵: [[-2. 1. ] [ 1.5 -0.5]]；验证 A @ A_inv: [[1.0000000e+00 0.0000000e+00] [8.8817842e-16 1.0000000e+00]]

应用场景：求解线性方程组、线性回归。

numpy.linalg.pinv() - 伪逆矩阵

功能：计算矩阵的Moore-Penrose伪逆。

A = np.array([[1, 2], [3, 4], [5, 6]])
A_pinv = np.linalg.pinv(A)
print("矩阵A:n", A)
print("伪逆矩阵:n", A_pinv)
print("A @ A_pinv @ A ≈ A:n", A @ A_pinv @ A)

输出：矩阵A: [[1 2] [3 4] [5 6]]；伪逆矩阵: [[-1.33333333 -0.33333333 0.66666667] [ 1.08333333 0.33333333 -0.41666667]]；A @ A_pinv @ A ≈ A: [[1. 2.] [3. 4.] [5. 6.]]

numpy.linalg.det() - 行列式计算

功能：计算方阵的行列式。

A = np.array([[1, 2], [3, 4]])
det_A = np.linalg.det(A)
print("矩阵A:n", A)
print("行列式:", det_A)

输出：矩阵A: [[1 2] [3 4]]；行列式: -2.0000000000000004

应用场景：判断矩阵是否可逆、计算特征值。

numpy.linalg.eig() - 特征值和特征向量

功能：计算方阵的特征值和特征向量。

A = np.array([[1, -1], [2, 4]])
eigenvalues, eigenvectors = np.linalg.eig(A)
print("矩阵A:n", A)
print("特征值:", eigenvalues)
print("特征向量:n", eigenvectors)
# 验证：A * v = λ * v
for i in range(len(eigenvalues)):
    v = eigenvectors[:, i]
    λ = eigenvalues[i]
    print(f"验证特征向量 {i}: A*v = {A @ v}, λ*v = {λ * v}")

输出：矩阵A: [[ 1 -1] [ 2 4]]；特征值: [2. 3.]；特征向量: [[-0.70710678 0.4472136 ] [ 0.70710678 -0.89442719]]；验证特征向量 0: A*v = [-1.41421356 1.41421356], λ*v = [-1.41421356 1.41421356]；验证特征向量 1: A*v = [ 1.34164079 -2.68328157], λ*v = [ 1.34164079 -2.68328157]

应用场景：主成分分析(PCA)、振动分析、量子力学。

numpy.linalg.svd() - 奇异值分解

功能：计算矩阵的奇异值分解。

A = np.array([[1, 2], [3, 4], [5, 6]])
U, S, Vh = np.linalg.svd(A, full_matrices=False)
print("矩阵A:n", A)
print("U矩阵:n", U)
print("奇异值:", S)
print("Vh矩阵:n", Vh)
Sigma = np.diag(S)
A_reconstructed = U @ Sigma @ Vh
print("重建矩阵:n", A_reconstructed)

输出：矩阵A: [[1 2] [3 4] [5 6]]；U矩阵: [[-0.2298477 0.88346102] [-0.52474482 0.24078249] [-0.81964194 -0.40189603]]；奇异值: [9.52551809 0.51430058]；Vh矩阵: [[-0.61962948 -0.78489445] [-0.78489445 0.61962948]]；重建矩阵: [[1. 2.] [3. 4.] [5. 6.]]

应用场景：推荐系统、图像压缩、降维。

numpy.linalg.qr() - QR分解

功能：计算矩阵的QR分解。

A = np.array([[1, 2], [3, 4], [5, 6]])
Q, R = np.linalg.qr(A)
print("矩阵A:n", A)
print("Q矩阵:n", Q)
print("R矩阵:n", R)
print("验证 Q*R:n", Q @ R)

输出：矩阵A: [[1 2] [3 4] [5 6]]；Q矩阵: [[-0.16903085 0.89708523] [-0.50709255 0.27602622] [-0.84515425 -0.34503278]]；R矩阵: [[-5.91607978 -7.43735744] [ 0. 0.82807867]]；验证 Q*R: [[1. 2.] [3. 4.] [5. 6.]]

应用场景：线性最小二乘问题、特征值计算。

矩阵统计与操作

numpy.sum() - 求和

功能：沿指定轴计算数组元素的和。

A = np.array([[1, 2, 3], [4, 5, 6]])
print("矩阵:n", A)
print("所有元素和:", np.sum(A))
print("每列和:", np.sum(A, axis=0))
print("每行和:", np.sum(A, axis=1))

输出：矩阵: [[1 2 3] [4 5 6]]；所有元素和: 21；每列和: [5 7 9]；每行和: [ 6 15]

numpy.mean() - 平均值

功能：计算平均值。

A = np.array([[1, 2, 3], [4, 5, 6]])
print("矩阵:n", A)
print("全局均值:", np.mean(A))
print("列均值:", np.mean(A, axis=0))
print("行均值:", np.mean(A, axis=1))

输出：矩阵: [[1 2 3] [4 5 6]]；全局均值: 3.5；列均值: [2.5 3.5 4.5]；行均值: [2. 5.]

numpy.transpose() / .T - 矩阵转置

功能：计算矩阵转置。

A = np.array([[1, 2, 3], [4, 5, 6]])
A_transpose1 = np.transpose(A)
A_transpose2 = A.T
print("原始矩阵:n", A)
print("转置矩阵:n", A_transpose1)
print("两种方法结果相同:", np.array_equal(A_transpose1, A_transpose2))

输出：原始矩阵: [[1 2 3] [4 5 6]]；转置矩阵: [[1 4] [2 5] [3 6]]；两种方法结果相同: True

应用场景：协方差矩阵计算、线性代数公式实现。

矩阵求解与方程

numpy.linalg.solve() - 解线性方程组

功能：求解线性方程组 Ax = b。

# 解方程组:
# 1*x + 2*y = 5
# 3*x + 4*y = 6
A = np.array([[1, 2], [3, 4]])
b = np.array([5, 6])
x = np.linalg.solve(A, b)
print("系数矩阵 A:n", A)
print("常数项 b:", b)
print("解 x:", x)
print("验证 A*x = b:", A @ x)

输出：系数矩阵 A: [[1 2] [3 4]]；常数项 b: [5 6]；解 x: [-4. 4.5]；验证 A*x = b: [5. 6.]

numpy.linalg.lstsq() - 最小二乘解

功能：计算线性矩阵方程的最小二乘解。

# 拟合数据点 y = 2x + 1 + 噪声
x = np.array([0, 1, 2, 3, 4])
y = np.array([1, 3, 5, 7, 9]) + np.random.normal(0, 0.2, 5)
# 构建设计矩阵 A = [[1, x1], [1, x2], ...]
A = np.vstack([np.ones_like(x), x]).T
coeff, residuals, rank, s = np.linalg.lstsq(A, y, rcond=None)
print(f"拟合直线: y = {coeff[1]:.3f}x + {coeff[0]:.3f}")
print(f"残差平方和: {residuals[0]:.3f}")

输出：拟合直线: y = 2.096x + 0.974；残差平方和: 0.090

矩阵重塑与组合

numpy.reshape() - 改变数组形状

功能：改变数组形状而不改变数据。

A = np.arange(12)  # 0到11
A_reshaped = A.reshape(3, 4)
print("原始数组:", A)
print("重塑为3x4:n", A_reshaped)

输出：原始数组: [ 0 1 2 3 4 5 6 7 8 9 10 11]；重塑为3x4: [[ 0 1 2 3] [ 4 5 6 7] [ 8 9 10 11]]

numpy.concatenate() - 连接数组

功能：沿指定轴连接数组序列。

A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])
C_vertical = np.concatenate((A, B), axis=0)
C_horizontal = np.concatenate((A, B), axis=1)
print("矩阵A:n", A)
print("矩阵B:n", B)
print("垂直连接:n", C_vertical)
print("水平连接:n", C_horizontal)

输出：矩阵A: [[1 2] [3 4]]；矩阵B: [[5 6] [7 8]]；垂直连接: [[1 2] [3 4] [5 6] [7 8]]；水平连接: [[1 2 5 6] [3 4 7 8]]

numpy.vstack()和numpy.hstack() - 垂直/水平堆叠

功能：垂直或水平堆叠数组。

A = np.array([1, 2, 3])
B = np.array([4, 5, 6])
C_vertical = np.vstack((A, B))
C_horizontal = np.hstack((A, B))
print("A:", A)
print("B:", B)
print("垂直堆叠:n", C_vertical)
print("水平堆叠:", C_horizontal)

输出：A: [1 2 3]；B: [4 5 6]；垂直堆叠: [[1 2 3] [4 5 6]]；水平堆叠: [1 2 3 4 5 6]

可视化示例

import matplotlib.pyplot as plt
import numpy as np
fig, axes = plt.subplots(2, 3, figsize=(12, 8))
# 1. 单位矩阵可视化
I = np.eye(5)
axes[0, 0].imshow(I, cmap='Blues', interpolation='nearest')
axes[0, 0].set_title('单位矩阵')
axes[0, 0].set_xticks(range(5))
axes[0, 0].set_yticks(range(5))
# 2. 随机矩阵可视化
random_matrix = np.random.randn(5, 5)
axes[0, 1].imshow(random_matrix, cmap='RdYlBu', interpolation='nearest')
axes[0, 1].set_title('随机矩阵')
axes[0, 1].set_xticks(range(5))
axes[0, 1].set_yticks(range(5))
# 3. 矩阵乘法示例
A = np.array([[1, 0.5], [0.5, 1]])
B = np.array([[1, 0], [0, 0.5]])
C = A @ B
axes[0, 2].imshow(C, cmap='viridis', interpolation='nearest')
axes[0, 2].set_title('矩阵乘法结果')
axes[0, 2].set_xticks(range(2))
axes[0, 2].set_yticks(range(2))
# 4. 特征向量可视化
eig_matrix = np.array([[2, 1], [1, 2]])
eigvals, eigvecs = np.linalg.eig(eig_matrix)
axes[1, 0].quiver([0, 0], [0, 0], eigvecs[0, :], eigvecs[1, :], angles='xy', scale_units='xy', scale=1, color=['r', 'b'])
axes[1, 0].set_xlim(-1.5, 1.5)
axes[1, 0].set_ylim(-1.5, 1.5)
axes[1, 0].set_title('特征向量')
axes[1, 0].grid(True)
axes[1, 0].set_aspect('equal')
# 5. SVD分解可视化
U, S, Vh = np.linalg.svd(eig_matrix)
axes[1, 1].imshow(U @ np.diag(S) @ Vh, cmap='plasma', interpolation='nearest')
axes[1, 1].set_title('SVD重建矩阵')
axes[1, 1].set_xticks(range(2))
axes[1, 1].set_yticks(range(2))
# 6. 3D矩阵可视化（使用2D切片）
matrix_3d = np.random.rand(4, 4, 4)
axes[1, 2].imshow(matrix_3d[:, :, 0], cmap='coolwarm', interpolation='nearest')
axes[1, 2].set_title('3D矩阵的2D切片')
axes[1, 2].set_xticks(range(4))
axes[1, 2].set_yticks(range(4))
plt.tight_layout()
plt.show()

总结与应用场景对比表

函数类别关键函数主要应用场景创建矩阵zeros(), ones(), eye(), diag()初始化、构建特殊矩阵基本运算dot(), matmul(), transpose()线性变换、神经网络高级运算cross(), outer(), inner()物理模拟、信号处理线性代数inv(), det(), eig(), svd()矩阵分解、降维、PCA方程求解solve(), lstsq()线性方程组、回归分析统计操作sum(), mean(), std()数据分析、特征工程矩阵操作reshape(), concatenate()数据预处理、批处理

性能提示

• 使用广播机制：避免显式循环，利用NumPy广播提高性能。
• 矩阵乘法选择：小矩阵用@运算符，批量矩阵用matmul。
• 原地操作：使用out参数避免不必要的内存分配。
• 数据类型选择：根据精度需求选择float32或float64。

# 性能优化示例
A = np.random.randn(1000, 1000)
B = np.random.randn(1000, 1000)
# 更快的矩阵乘法（使用优化的BLAS库）
result = A @ B  # 自动使用优化的实现
# 避免不必要的复制
C = np.empty_like(A)
np.matmul(A, B, out=C)  # 指定输出位置

NumPy的矩阵运算功能强大且高效，是科学计算和数据分析的基础工具。掌握这些函数能显著提升数据处理和模型开发的效率。