Python矩阵运算

最新推荐文章于 2026-06-14 20:48:43 发布

原创最新推荐文章于 2026-06-14 20:48:43 发布 · 2.1k 阅读

25 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#python #矩阵 #开发语言

Python 同时被 2 个专栏收录

104 篇文章

订阅专栏

MachineLearning

23 篇文章

订阅专栏

Python矩阵运算

使用的是Numpy库来进行的运算

一、环境配置

1737353589_nubthqcw7g.png1737353586954.png

使用：

pip install numpy -i https://mirrors.aliyun.com/pypi/

进行安装

安装完成后可以导入

import numpy as np

二、矩阵创建

2.1 单位阵

创建单位阵：

e2 = np.eye(4)  # 创建四阶单位阵 np.identity(4) 也可以创建

1737360164_zrygz6673m.png1737360163224.png

2.2 全一阵

np.ones((3, 3)), np.zeros((3, 3))   # 创建全为一，零的矩阵 3x3

2.3 随机矩阵

np.random.randint(1, 100, (3,3))  # 创建1-100随机数字的矩阵
np.random.rand(3,3)  # 创建0-1的随机小数矩阵

2.4 序列矩阵

# 创建一个包含 1 到 9 的矩阵，并 reshape 为 3x3 的矩阵  
# numpy.arange(start, stop, step, dtype=None)默认不包括终点 
np.arange(1, 10, 1).reshape((3, 3))

等间隔数值矩阵

# 创建包含从 0 到 1 的 9 个等间隔数值的数组  
# numpy.linspace(start, stop, num=50)默认包括终点  
np.linspace(1, 9)

2.5 对角矩阵

np.diag([1,2,3,4])  # 生成对角矩阵

2.6 其他

将其他数据转换为矩阵

data = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]  
mdata = np.mat(data)  # 将数组数据转换为矩阵  
# np.asarray(mdata)  # 将矩阵转换为数组
# np.matrix(data)  # 将数组数据转换为矩阵 
# mdata.tolist()  # 将mdata转换回多维列表
print(mdata)

1737360351_neb45qe2rg.png1737360350206.png

三、矩阵的运算

3.1 行列式

3.1.1 LU分解

手动计算行列式：
LU分解计算：

data = np.array([[2, 1, 1], [1, 3, 2], [1, 2, 2]])  

def get_lu(data: np.ndarray):  
	# 进行LU分解
    n = len(data)  
    if (not isinstance(data, np.ndarray)) or (n != len(data.copy().tolist()[0])):  # 如果不是矩阵或者不是方阵  
        raise ArithmeticError("Your data is error. The data is not a array or the matrix is not square.")  
    LU = np.zeros((n, n))  
    for i in range(n):  
        for j in range(i, n):  
            LU[i][j] = data[i][j] - sum(LU[i][k] * LU[k][j] for k in range(i))  
        for j in range(i+1, n):  
            LU[j][i] = (data[j][i] - sum(LU[j][k] * LU[k][i] for k in range(i))) / LU[i][i]  
    return LU  
  
LU = get_lu(data)  
deter = 1  
for i in range(len(LU)):  # 计算行列式，即对角元素的乘积
    deter *= LU[i][i]  
print(deter)

3.1.2 Gauss列主元消元法计算

data = np.array([[2, 1, 1], [1, 3, 2], [1, 2, 2]], dtype=float)  
def column_pivoting_elimination(data: np.ndarray):  
    n = len(data)  
    num_exchange = 0  # 记录交换的次数，行列式交换一次要添加负号  
    for i in range(n):  
        # 遍历列  
        # 找到主元  
        max_index = np.argmax(np.abs(data[i:, i])) + i  
        if max_index != i:  
            # 交换行  
            data[[i, max_index]] = data[[max_index, i]]  
            num_exchange += 1  
        # 消元  
        for j in range(i + 1, n):  
            # 遍历第j行  
            factor = data[j][i] / data[i][i]  
            data[j] = data[j] - factor * data[i]  
    return  data, num_exchange  
  
data, n = column_pivoting_elimination(data)  
deter = np.power(-1, n)  
for i in range(len(data)):  
    deter *= data[i][i]  
print(deter)

3.1.3 Numpy直接计算

data = np.array([[2, 1, 1], [1, 3, 2], [1, 2, 2]])  
np.linalg.det(data)  # 直接计算矩阵的行列式

3.2 矩阵转置

data = np.array([[2, 1, 1], [1, 3, 2], [1, 2, 2]])  
data.T

3.3 矩阵乘法

3.3.1 叉积

d1, d2 = np.array([1,0,1]), np.array([0,1,0])  
print(np.cross(d1, d2))

3.3.2 点积

d1, d2 = np.array([1,1,1]), np.array([0,1,2])  
print(np.dot(d1, d2))  # d1@d2

向量逐元素相乘：np.multiply(a,b)等价于a*b

3.4 逆矩阵和伴随矩阵

已知: $AA^{*}=|A|E$

# 逆矩阵求法：  
A = np.array([[-1,1,0],[-4,3,0],[1,0,2]])  
B = np.linalg.inv(A)  
# 伴随矩阵求法  
C = np.abs(np.linalg.det(A)) * B  
C

3.5 方程组求解

如求解：
$\left\{\begin{matrix} -x_1+3x_2+2x_3=4\\ x_2+x_3=2\\ 3x_1+2x_2=4\\ \end{matrix}\right.$
转换成矩阵形式为：
$\begin{pmatrix} -1 &3 &2 \\ 0 & 1 & 1\\ 3& 2&0 \end{pmatrix} x = \begin{pmatrix} 4\\ 2\\ 5 \end{pmatrix}$
代码求解为：

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

奇异矩阵不好求解，在这里忽略

3.6 特征值特征向量

如求，
$A=\begin{pmatrix} -1 & 1 & 0\\ -4& 3 & 0\\ 1& 0&2 \end{pmatrix}$ 的特征值和特征向量：

A = np.array([[-1,1,0],[-4,3,0],[1,0,2]])  
eig_val, eig_vectror = np.linalg.eig(A)  
print("特征值，及其所对应的特征向量为：")  
for i in range(len(eig_val)):  
    print(f"{eig_val[i]}:{eig_vectror[:, i]}")

3.7 矩阵范数

data = np.array([[2, 1, 1], [1, 3, 2], [1, 2, 2]])  
# 计算矩阵的二范数（默认）  
norm_2 = np.linalg.norm(data)  
print("矩阵的二范数:\n", norm_2)  
  
# 计算矩阵的 1 范数（列和的最大值）  
norm_1 = np.linalg.norm(data, ord=1)  
print("矩阵的 1 范数:\n", norm_1)  
  
# 计算矩阵的无穷范数（行和的最大值）  
norm_inf = np.linalg.norm(data, ord=np.inf)  
print("矩阵的无穷范数：\n",norm_inf)  
#%%

四、矩阵索引

4.1 基本索引

即所用坐标法进行矩阵元素的索引，矩阵的索引从0开始，可以使用行、列的索引来访问特定元素。

data = np.array([[2, 1, 1], [1, 3, 2], [1, 2, 2]])  
  
# 访问第一行第二列的元素  
data[0, 1]

4.2 矩阵切片

切片操作可以用于选择矩阵中的一部分。语法为 [start:stop:step]。

data = np.array([[2, 1, 1], [1, 3, 2], [1, 2, 2]])  
  
# 选择前两行的所有列  
row_slice = data[:2, :]  
print("前两行的子矩阵:\n", row_slice)  
  
# 选择所有行的第二列  
col_slice = data[:, 1]  
print("所有行的第二列:\n", col_slice)  
  
# 选择前两行和前两列  
sub_matrix = data[:2, :2]  
print("子矩阵:\n", sub_matrix)  
  
# 选择所有行，每隔一列取一个元素  
step_slice = data[:, ::2]  
print("步长为2的子矩阵:\n", step_slice)

4.3 布尔索引

布尔索引允许通过条件筛选矩阵中的元素，返回满足条件的元素。

# 选择矩阵中所有大于5的元素
bool_index = data[data > 5]
print("大于5的元素:", bool_index)

4.4 多次索引

通过指定多个索引来访问矩阵中的特定元素。即，进行多次基本索引

data = np.array([[2, 1, 1], [1, 3, 2], [1, 2, 2]])  
print(data)  
print(data[[0,0],[0,1]])

4.5 子矩阵索引

可以通过使用多个索引列表选择特定的行和列组成子矩阵。

data = np.array([[2, 1, 1], [1, 3, 2], [1, 2, 2]])  
print(data)  
# 选择第 1 和 2 行，第 2 和 3 列，生成子矩阵  
sub_matrix = data[[0, 2], :][:, [1, 2]]  
print("子矩阵:\n", sub_matrix)

五、矩阵分解

5.1 LU 分解

LU 分解将矩阵分解为一个下三角矩阵和一个上三角矩阵。

import scipy.linalg as la  
A = np.array([[-1,1,0],[-4,3,0],[1,0,2]])  
P, L, U = la.lu(A)  
# P Permutation matrix  
print(P, L, U, sep="\n")

P；为置换矩阵，即 $LU = P A$
在对矩阵进行 LU 分解时，先检查主元位置的元素。若主元为或绝对值很小，就需要在该列中寻找绝对值较大的元素所在行，通过构建置换矩阵来交换行，以确保主元非零且尽可能大，提高分解的稳定性和准确性。
在后续的求解过程中，求解 $A x = b$ 即求解， $P A x = LUx = P b$

5.2 QR 分解

QR 分解将矩阵分解为正交矩阵和上三角矩阵

A = np.array([[-1,1,0],[-4,3,0],[1,0,2]])
Q, R = np.linalg.qr(A)
print("Q 矩阵:\n", Q)
print("R 矩阵:\n", R)

5.3 SVD 分解

SVD 是将矩阵分解为三个矩阵：左奇异矩阵、对角矩阵（奇异值）、右奇异矩阵。

A = np.array([[-1,1,0],[-4,3,0],[1,0,2]])  
U, S, V = np.linalg.svd(A)  
print("U 矩阵:\n", U)  
print("奇异值:\n", S)  
print("V 矩阵:\n", V)  
print("A:", np.dot(U, np.dot(np.diag(S), V)))