人工智能之数学基础篇—线性代数基础（下）

1 转置矩阵和逆矩阵

  在机器学习中，转置矩阵和逆矩阵是常用到的两个操作。

1.1 转置矩阵

  矩阵 $A$ 的行和列互相交换所产生的矩阵称为 $A$ 的转置矩阵，记为 $A^T$， 该运算称为矩阵的转置运算 ，其实质就是将矩阵的行变为列，列变为行。

  例如：$$A=\left[\begin{array}{ccc}2& 6& 10\\ 1& -2& 9\end{array}\right]，A^T=\left[\begin{array}{cc}2& 1\\ 6& -2\\ 10& 9\end{array}\right]$$

  （1）在 NumPy中，可以使用 np.transpose() 函数和 T 属性实现转置运算，结果相同。

【代码】：

import numpy as np

A = [[2, 6, 10], [1, -2, 9]]
B = np.array(A)
# 采用np.transpose()函数求转置矩阵
C1 = np.transpose(B)
print("C1 = \n", C1)
# 采用T属性求转置矩阵
C2 = B.T
print("C2 = \n", C2)

【运行结果】：

C1 = 
 [[ 2  1]
 [ 6 -2]
 [10  9]]
C2 = 
 [[ 2  1]
 [ 6 -2]
 [10  9]]

【注意】：不能直接对 list 类型的 $A$ 使用 T 属性。

  （2）矩阵的转置运算具有如下性质。

  $\bullet$ ${\left(A^T\right)}^T=A$
  $\bullet$ ${\left(A+B\right)}^T=A^T+B^T$
  $\bullet$ ${\left(\lambda A\right)}^T=\lambda A^T$
  $\bullet$ ${\left(AB\right)}^T=B^T{A}^T$
  $\bullet$ ${\left(A_1{A}_2\cdots A_n\right)}^T=A_n^T\cdots A_2^T{A}_1^T$

【代码】：

import numpy as np

A = [[1, 2, 3], [4, 5, 6]]
B = [[7, 8], [9, 10], [11, 12]]
C = np.array(A)
D = np.array(B)
print("矩阵相乘后的转置结果: \n", (C.dot(D)).T)
print("矩阵转置后相乘的结果: \n", D.T.dot(C.T))

【运行结果】：

矩阵相乘后的转置结果: 
 [[ 58 139]
 [ 64 154]]
矩阵转置后相乘的结果: 
 [[ 58 139]
 [ 64 154]]

  （3）利用矩阵的转置，可以创建对称矩阵。

  例如：随机产生一个元素值为 1~16 的三阶方阵，根据其上三角矩阵，创建一个对称矩阵，步骤如下。

  ① 利用 randint() 函数创建一个随机整数型的方阵。
  ② 获得上三角矩阵。
  ③ 求出对称矩阵。

【代码】：

import numpy as np

# 创建一个方阵
arr1 = np.random.randint(1, 16, size=[3, 3])
# 保留其上三角部分
arr2 = np.triu(arr1)
# 生成对称矩阵
arr2 += arr2.T - np.diag(np.diag(arr2))
print("arr1 = \n", arr1)
print("arr2 = \n", arr2)

【运行结果】：

arr1 = 
 [[ 6  1  8]
 [ 5 14  9]
 [ 5  3  9]]
arr2 = 
 [[ 6  1  8]
 [ 1 14  9]
 [ 8  9  9]]

【注意】：上三角矩阵和下三角矩阵相加时，主对角线上的元素会相加两次，所以要减去一次对角线上的元素。

  （4）通过验证 $A=A^T$， 判断 $A$ 是否为对称矩阵。

【代码】：

import numpy as np

arr1 = np.array([[1, 2], [3, 4]])
arr2 = np.array([[1, 2, 3], [2, 4, 5], [3, 5, 6]])
print("arr1是否为对称矩阵: ", np.allclose(arr1, arr1.T))
print("arr2是否为对称矩阵: ", np.allclose(arr2, arr2.T))

【运行结果】：

arr1是否为对称矩阵:  False
arr2是否为对称矩阵:  True

  （5）利用矩阵的转置，可以用行向量生成列向量。

【代码】：

import numpy as np

A = [[1, 2, 3, 4, 5]]
B = np.array(A)
C = B.T
print("行向量B = \n", B)
print("列向量C = \n", C)

【运行结果】：

行向量B = 
 [[1 2 3 4 5]]
列向量C = 
 [[1]
 [2]
 [3]
 [4]
 [5]]

【注意】：用矩阵转置可以将行向量转换为列向量，同理也可以实现列向量到行向量的转换。要注意的是，行向量初始化时的设置是 A = [[1, 2, 3, 4, 5]]，如果写为 A = [1, 2, 3, 4, 5]，转置后还是原一维数组。

【代码】：

import numpy as np

A = [1, 2, 3, 4, 5]
B = np.array(A)
C = B.T
print("B = ", B)
print("C = ", C)

【运行结果】：

B =  [1 2 3 4 5]
C =  [1 2 3 4 5]

1.2 逆矩阵

  逆矩阵类似于数学中实数的倒数，如果 $b\times a=a\times b=1$，则 $b$ 是 $a$ 的倒数，可以记为 $b=\frac{1}{a}=a^{-1}$。利用倒数，实数的除法运算可以转化为乘法运算，如 $a÷b=a\times \frac{1}{b}=a\times b^{-1}$， 矩阵没有除法运算，可以借助逆矩阵，间接实现矩阵的除法。

对于 $n$ 阶方阵 $A$，若存在 $n$ 阶方阵 $B$， 使得：$AB=BA=E$，其中 $E$ 为单位矩阵，记作：$B=A^{-1}$，$A=B^{-1}$。若 $A$ 可逆，则其逆矩阵唯一。

  例如：$$\left[\begin{array}{cc}1& 2\\ 2& 5\end{array}\right]\left[\begin{array}{cc}5& -2\\ -2& 1\end{array}\right]=\left[\begin{array}{cc}1& 0\\ 0& 1\end{array}\right]，\left[\begin{array}{cc}5& -2\\ -2& 1\end{array}\right]\left[\begin{array}{cc}1& 2\\ 2& 5\end{array}\right]=\left[\begin{array}{cc}1& 0\\ 0& 1\end{array}\right]$$所以上述两个矩阵互为逆矩阵。

  不是所有的方阵都有逆矩阵，没有逆矩阵的方阵称为奇异矩阵或不可逆矩阵，有逆矩阵的方阵称为非奇异矩阵或可逆矩阵。注意可逆性质只能用于方阵。

  逆矩阵在计算推导中非常有用，逆运算也是解线性方程组的一种方法。

【逆矩阵性质】：

  $\bullet$ ${\left(A^{-1}\right)}^{-1}=A$
  $\bullet$ ${\left(A^T\right)}^{-1}={\left(A^{-1}\right)}^T$
  $\bullet$ ${\left(\lambda A\right)}^{-1}=\frac{1}{\lambda }{A}^{-1}$
  $\bullet$ ${\left(AB\right)}^{-1}=B^{-1}{A}^{-1}$

  在 NumPy 中，matrix 类型可以使用 np.linalg.inv() 函数或 $I$ 属性求方阵 A 的逆矩阵，而 array 类型只能通过 np.linalg.inv() 函数求逆矩阵，可以将 array 类型转换为 matrix 类型，然后使用 $I$ 属性。

  例如：先求出可逆矩阵的逆矩阵，然后将原矩阵与求出的逆矩阵相乘，并验证其结果是否为单位矩阵。

【代码】：

import numpy as np

A = [[1, 2], [2, 5]]
C1 = np.array(A)
C2 = np.mat(A)
C1_inverse = np.linalg.inv(C1)
C2_inverse = C2.I
print("C1_inverse = \n", C1_inverse)
print("C2_inverse = \n", C2_inverse)
print("C1与C1_inverse相乘的结果: \n", np.dot(C1, C1_inverse))

【运行结果】：

C1_inverse = 
 [[ 5. -2.]
 [-2.  1.]]
C2_inverse = 
 [[ 5. -2.]
 [-2.  1.]]
C1与C1_inverse相乘的结果: 
 [[1. 0.]
 [0. 1.]]

  例如：验证有的方阵没有逆矩阵。

【代码】：

import numpy as np

A = [[1, -4, 0, 2], [-1, 2, -1, -1], [1, -2, 3, 5], [2, -6, 1, 3]]
B = np.array(A)
B_inverse = np.linalg.inv(B)
print("B_inverse = \n", B_inverse)

【运行结果】：

Traceback (most recent call last):
  File "C:\Users\Dell\Desktop\AI_math_ws\2-15\main.py", line 5, in <module>
    B_inverse = np.linalg.inv(B)
  File "<__array_function__ internals>", line 5, in inv
  File "C:\Users\Dell\Desktop\AI_math_ws\2-15\venv\lib\site-packages\numpy\linalg\linalg.py", line 545, in inv
    ainv = _umath_linalg.inv(a, signature=signature, extobj=extobj)
  File "C:\Users\Dell\Desktop\AI_math_ws\2-15\venv\lib\site-packages\numpy\linalg\linalg.py", line 88, in _raise_linalgerror_singular
    raise LinAlgError("Singular matrix")
numpy.linalg.LinAlgError: Singular matrix

【结果说明】：

  报错信息显示，方阵 $B$ 是 Singular matrix（奇异矩阵），因此该矩阵无逆矩阵。

2 行列式

  在线性代数中，行列式是基本的数学工具，有着重要的应用。行列式是一个算式，经过计算后就是数。行列式主要用于判断矩阵是否可逆及计算特征方程。

2.1 行列式引例

  行列式起源于线性方程组的求解，如二元线性方程组：
$$\{\begin{array}{c}{a}_{11}{x}_1+a_{12}{x}_2=b_1\\ a_{21}{x}_1+a_{22}{x}_2=b_2\end{array}$$

  通过消元法，变换得到：
$$\{\begin{array}{c}\left(a_{11}{a}_{22}-a_{12}{a}_{21}\right)x_1=b_1{a}_{22}-b_2{a}_{12}\\ \left(a_{11}{a}_{22}-a_{12}{a}_{21}\right)x_2=b_2{a}_{11}-b_1{a}_{21}\end{array}$$

  当 $a_{11}{a}_{22}-a_{12}{a}_{21}\ne 0$ 时，方程组有唯一解：
$$x_1=\frac{b_1{a}_{22}-b_2{a}_{12}}{a_{11}{a}_{22}-a_{12}{a}_{21}},x_2=\frac{b_2{a}_{11}-b_1{a}_{21}}{a_{11}{a}_{22}-a_{12}{a}_{21}}$$

  由此，观察出规律，在方程组解的表达式中，分母是由方程组的 4 个系数确定，提取 4 个系数并按它们在方程组中的位置，排列为二行二列的数表（横排称为行，竖排称为列），即：
$$\left|\begin{array}{cc}{a}_{11}& a_{12}\\ a_{21}& a_{22}\end{array}\right|=a_{11}{a}_{22}-a_{12}{a}_{21}$$

  因此，将形如 $\left|\begin{array}{cc}{a}_{11}& a_{12}\\ a_{21}& a_{22}\end{array}\right|$ 的表达式，称为二阶行列式。

  利用二阶行列式的概念，方程组的解可以表示为：
$$x_1=\frac{D_1}{D},x_2=\frac{D_2}{D}$$其中：

  $D=\left|\begin{array}{cc}{a}_{11}& a_{12}\\ a_{21}& a_{22}\end{array}\right|$ 称为系数行列式。

  $D_1=\left|\begin{array}{cc}{b}_1& a_{12}\\ b_2& a_{22}\end{array}\right|$ 是常数项 $b_1$ 和 $b_2$ 替代 $D$ 的第1列元素 $a_{11}$ 和 $a_{21}$ 所得行列式。

  $D_2=\left|\begin{array}{cc}{a}_{11}& b_1\\ a_{21}& b_2\end{array}\right|$ 是常数项 $b_1$ 和 $b_2$ 替代 $D$ 的第2列元素 $a_{12}$ 和 $a_{22}$ 所得行列式。

2.2 行列式的定义

  由二阶行列式推广得到 $n$ 阶行列式的定义：
$$\left|\begin{array}{cccc}{a}_{11}& a_{12}& \cdots & a_{1n}\\ a_{21}& a_{22}& \cdots & a_{2n}\\ ⋮& ⋮& \ddots & ⋮\\ a_{n1}& a_{n2}& \cdots & a_{nn}\end{array}\right|=\sum _{j_1{j}_2\cdots j_n}{\left(-1\right)}^t{a}_{1,j_1}\cdot a_{2,j_2}\cdots a_{n,j_n}$$

  其中，$a_{ij},i=1,2,\dots ,n,j=1,2,\dots ,n$ 称为行列式的元素，$a_{ij}$ 的第1个下标 $i$ 称为行标，表明该元素位于第 $i$ 行；第2个下标 $j$ 称为列标，表明该元素位于第 $j$ 列。

  求和公式中，$j_1{j}_2\cdots j_n$ 是 $1,2,\dots ,n$ 的一个排列，${\sum }_{j_1{j}_2\cdots j_n}^{}$ 是对 $j_1{j}_2\cdots j_n$ 取遍 $1,2,\dots ,n$ 的一切排列求和，共有 $n!$ 项。$t$ 为排列 $j_1{j}_2\cdots j_n$ 的逆序数。

  如：123 的排列为 123，132，213，232，312，321，排列 321 的逆序数为 3。

  常用的行列式如下。

  一阶行列式：$$\left|\begin{array}{c}{a}_1\end{array}\right|=a_1$$  二阶行列式：$$\left|\begin{array}{cc}{a}_{11}& a_{12}\\ a_{21}& a_{22}\end{array}\right|=a_{11}{a}_{22}-a_{12}{a}_{21}$$  三阶行列式：$$\left|\begin{array}{ccc}{a}_{11}& a_{12}& a_{13}\\ a_{21}& a_{22}& a_{23}\\ a_{31}& a_{32}& a_{33}\end{array}\right|=a_{11}{a}_{22}{a}_{33}+a_{12}{a}_{23}{a}_{31}+a_{13}{a}_{21}{a}_{32}-a_{13}{a}_{22}{a}_{31}-a_{12}{a}_{21}{a}_{33}-a_{11}{a}_{23}{a}_{32}$$

【例题】：已知如下行列式，求其值。
$$A=\left|\begin{array}{ccc}1& -2& 3\\ -1& 2& 1\\ -3& -4& -2\end{array}\right|$$

  解：根据定义解得，$$A=1\times 2\times \left(-2\right)+\left(-2\right)\times 1\times \left(-3\right)+3\times \left(-1\right)\times \left(-4\right)-3\times 2\times \left(-3\right)-\left(-2\right)\times \left(-1\right)\times \left(-2\right)-1\times 1\times \left(-4\right)=40$$
  方阵 $A$ 的行列式可用于判断 $A$ 是否可逆，方阵 $A$ 的行列式不为 0 ，可判定 $A$ 可逆。方阵 $A$ 的行列式为 0 当且仅当 $A$ 不可逆。

  行列式的性质：$${\left|A\right|}^{-1}=\frac{1}{\left|A\right|}$$

2.3 行列式与矩阵的区别

  行列式和矩阵表面上看上去相似，元素都按顺序排成行列表；都用 $a_{ij}$ 表示第 $i$ 行第 $j$ 列的元素；对行列的称呼一致，从上到下依次称作第 1 行，第 2 行，$\dots$，第 $n$ 行，从左到右依次称为第 1 列 ，第 2 列，$\dots$，第 $n$ 列 。但它们是两个不同的概念，主要区别见表1。

表1 向量的数乘

2.4 行列式的计算

  在 NumPy 中，方阵的行列式可以使用 np.linalg.det() 函数得到。

【例题】：已知如下行列式，求其值，并验证 ${\left|A\right|}^{-1}=\frac{1}{|A|}$。
$$A=\left|\begin{array}{ccc}1& -2& 3\\ -1& 2& 1\\ -3& -4& -2\end{array}\right|$$

【代码】：

import numpy as np

B = [[1, -2, 3], [-1, 2, 1], [-3, -4, -2]]
A = np.array(B)
det_A = np.linalg.det(A)
print("A的行列式的值为: ", det_A)
print("det_A的-1次方: ", det_A**(-1))
print("1/det_A: ", 1 / det_A)

【运行结果】：

A的行列式的值为:  40.000000000000014
det_A的-1次方:  0.02499999999999999
1/det_A:  0.02499999999999999

3 矩阵的秩

  矩阵可以看作是由向量组所构成，要理解矩阵的秩，需要先理解向量组的线性相关和线性无关的概念。矩阵的秩可用于计算线性方程组解的数目。

3.1 向量组

一个向量空间是由向量构成的非空集合 $V$，在这个集合中定义两个运算，称为加法和标量乘法（标量取实数），两种运算满足以下运算规律（对任意向量 $\alpha$，$\beta$，$\gamma$ 和标量 $k,\lambda \in R$ 均成立）。

  ① $\alpha$，$\beta$ 之和表示为 $\alpha +\beta$，仍在 $V$ 中。
  ② $\alpha +\beta =\beta +\alpha$
  ③ $\left(\alpha +\beta \right)+\gamma =\alpha +\left(\beta +\gamma \right)$
  ④ 在 $V$ 中存在元素 0（称为零元素），则对任何 $\alpha \in V$，都有 $\alpha +0=\alpha$
  ⑤ 对任何 $\alpha \in V$，都有 $V$ 中的元素 $\beta$，使 $\alpha +\beta =0$（称 $\beta$ 为 $\alpha$ 的负元素）。
  ⑥ $\alpha$ 与标量 $k$ 的乘法记为 $k\alpha$，仍在 $V$ 中。
  ⑦ $1\alpha =\alpha$
  ⑧ $k\left(\lambda \alpha \right)=\left(k\lambda \right)\alpha$。
  ⑨ $\left(k+\lambda \right)\alpha =k\alpha +\lambda \alpha$。
  ⑩ $k\left(\alpha +\beta \right)=k\alpha +k\beta$。

全体 $n$ 维向量所构成的集合 $R^n$ 叫作 $n$ 维向量空间。$R$ 表示实数。

  若干个同维数的列（行）向量所组成的集合叫作向量组，向量组可用于简化矩阵。设有 $m\times n$ 阶矩阵，将矩阵按列分块，每列用 ${\alpha }_i$ 表示 ，则矩阵可以表示为向量组 $\left[{\alpha }_1{\alpha }_2\cdots {\alpha }_n\right]$。其中：$${\alpha }_1=\left[\begin{array}{c}{a}_{11}\\ a_{21}\\ ⋮\\ a_{m1}\end{array}\right],{\alpha }_2=\left[\begin{array}{c}{a}_{12}\\ a_{22}\\ ⋮\\ a_{m2}\end{array}\right],{\alpha }_n=\left[\begin{array}{c}{a}_{1n}\\ a_{2n}\\ ⋮\\ a_{mn}\end{array}\right]$$每个 ${\alpha }_i$ 称为 $m$ 维列向量。

  同理，将矩阵按行分块，每行用 ${\beta }_i$ 表示，则矩阵可以表示为向量组：$$\left[\begin{array}{c}{\beta }_1\\ {\beta }_2\\ ⋮\\ {\beta }_m\end{array}\right]$$其中：$${\beta }_1=\left[a_{11}{a}_{12}\dots a_{1n}\right]$$$${\beta }_2=\left[a_{21}{a}_{22}\dots a_{2n}\right]$$$$⋮$$$${\beta }_m=\left[a_{m1}{a}_{m2}\dots a_{mn}\right]$$每个 ${\beta }_i$ 称为 $n$ 维行向量。

【例题】：在 NumPy 中利用切片获取矩阵的行列向量，如生成矩阵的第 1 行行向量和第 2 列列向量。

【代码】：

import numpy as np

A = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
print("A的第1行行向量: \n", A[1, :].reshape(1, -1))
print("A的第2列列向量: \n", A[:, 2].reshape(-1, 1))

【运行结果】：

A的第1行行向量: 
 [[5 6 7 8]]
A的第2列列向量: 
 [[ 3]
 [ 7]
 [11]]

【例题】：生成矩阵中的所有行向量和列向量。

【代码】：

import numpy as np

A = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
print("A的各行向量: ")
for i in range(np.shape(A)[0]):
    print("第", i, "行: ", A[i, :].reshape(1, -1))
print("A的各列向量: ")
for i in range(np.shape(A)[1]):
    print("第", i, "列: \n", A[:, i].reshape(-1, 1))

【运行结果】：

A的各行向量: 
第 0 行:  [[1 2 3 4]]
第 1 行:  [[5 6 7 8]]
第 2 行:  [[ 9 10 11 12]]
A的各列向量: 
第 0 列: 
 [[1]
 [5]
 [9]]
第 1 列: 
 [[ 2]
 [ 6]
 [10]]
第 2 列: 
 [[ 3]
 [ 7]
 [11]]
第 3 列: 
 [[ 4]
 [ 8]
 [12]]

3.2 向量组的线性相关和线性无关

$m$ 个 $n$ 维向量组成的向量组 $A:{\alpha }_1,{\alpha }_2,\dots ,{\alpha }_m$， 如果有一组数 $k_1,k_2,\dots ,k_m$ 使 $B=k_1{\alpha }_1+k_2{\alpha }_2+\dots k_m{\alpha }_m$，则称 $B$ 为向量组 $A$ 的一个线性组合，其中 $k_i\in R,{\alpha }_i\in R^n$。

给定向量组 $A:{\alpha }_1,{\alpha }_2,\dots ,{\alpha }_m$，若向量 $b$ 可以写为： $b=k_1{\alpha }_1+k_2{\alpha }_2+\dots k_m{\alpha }_m$，则称 $b$ 可由向量组 $A$ 线性表示。

  求向量 $b$ 是否能被 ${\alpha }_1,{\alpha }_2,\dots ,{\alpha }_m$ 表示，可以将其转化为线性方程组 $AX=B$ 的形式，$A$ 为由向量组 ${\alpha }_1,{\alpha }_2,\dots ,{\alpha }_m$ 构成的矩阵， $X$ 为 ${\left[k_1{k}_2\cdots k_m\right]}^T$，$B$ 为向量 $b$，解出 $X$，即表示向量能被 ${\alpha }_1,{\alpha }_2,\dots ,{\alpha }_m$ 表示。

给定向量组 $A:{\alpha }_1,{\alpha }_2,\dots ,{\alpha }_m$，任选 $s$ 个向量 ${\alpha }_1,{\alpha }_2,\dots ,{\alpha }_s$（其中$s\ge 1$），当 $k_1{\alpha }_1+k_2{\alpha }_2+\dots k_s{\alpha }_s=0$ 时，$k_1=k_2=\cdots k_s=0$，则称这些向量线性无关；当存在一组非零的 $k_1,k_2,\dots ,k_s$，使得 $k_1{\alpha }_1+k_2{\alpha }_2+\dots k_s{\alpha }_s=0$，则称这些向量线性相关。

  对于一个向量组 ${\alpha }_1,{\alpha }_2,\dots ,{\alpha }_m$ ，或者线性相关，或者线性无关。

  设向量组 $A$ 中 $s$ 个向量 ${\alpha }_1,{\alpha }_2,\dots ,{\alpha }_s$ 是线性无关，但任意 $s+1$ 个向量都线性相关，则称 ${\alpha }_1,{\alpha }_2,\dots ,{\alpha }_s$ 是向量组 $A$ 的一个极大无关组。

  若 ${\alpha }_1,{\alpha }_2,\dots ,{\alpha }_s$ 线性无关，则每一个向量都不可以由其他向量线性表示，即每个向量都可以看作有价值的内容，不能被其他向量取代。

  若 ${\alpha }_1,{\alpha }_2,\dots ,{\alpha }_s$ 线性相关，则至少有一个向量可以由其他向量线性表示，因此，这个向量可以被看作"多余的"向量，可以被其他向量取代，删除这个向量不影响有价值的内容。

  例如，假设矩阵 $$A=\left[\begin{array}{cccc}1& 2& -1& 1\\ 3& 2& 5& -1\\ 5& 6& 3& 1\end{array}\right]$$
  在矩阵 $A$ 中选取向量组：$${\alpha }_1=\left[\begin{array}{c}1\\ 3\\ 5\end{array}\right],{\alpha }_2=\left[\begin{array}{c}2\\ 2\\ 6\end{array}\right]$$
  设 $k_1{\alpha }_1+k_2{\alpha }_2=\overrightarrow{0}$，通过计算，只有当 $k_1=0,k_2=0$ 时，上式才会成立。所以，这两个向量构成的向量组是线性无关的，一个向量不能用另一个向量表示 。

  若选取向量组：$${\alpha }_1=\left[\begin{array}{c}1\\ 3\\ 5\end{array}\right],{\alpha }_2=\left[\begin{array}{c}2\\ 2\\ 6\end{array}\right]，{\alpha }_3=\left[\begin{array}{c}-1\\ 5\\ 3\end{array}\right]$$

  设 $k_1{\alpha }_1+k_2{\alpha }_2+k_3{\alpha }_3=\overrightarrow{0}$，通过计算，当 $k_1=3,k_2=-2,k_3=-1$ 时，上式成立。所以，上述 3 个向量线性相关， 一个向量可以用另外两个向量表示。

3.3 矩阵的秩

设矩阵 $A={\left(a_{ij}\right)}_{m\times n}$， 在 $A$ 中任取 $r$ 行 $r$ 列交叉处元素，按原相对位置组成的 $r$ 阶行列式（ 1 ≤ r ≤ m i n { m , n } 1\le r \le min\left \{ m,n \right \} 1≤r≤min{m,n}），称为 $A$ 的一个 $r$ 阶子式。

设矩阵 $A={\left(a_{ij}\right)}_{m\times n}$，有 $r$ 阶子式不为 0 ，任何 $r+1$ 阶子式（如果存在的话）全为 0 ，则称 $r$ 为矩阵的秩，记作 $R(A)$ 或秩 $(A)$。

  矩阵的秩是唯一的。零矩阵的秩为 0，非零矩阵的秩大于等于 1。

  $A$ 为 $n$ 阶方阵，$R(A)=n$，称 $A$ 为满秩矩阵（非奇异矩阵），当且仅当 $\left|A\right|=0$ 时 ， $R(A)<n$ ，称 $A$ 为降秩矩阵（奇异矩阵）。在特征值分解中会用到满秩矩阵。

  矩阵可以看作是一个行向量组或者列向量组，矩阵的秩就是矩阵的行向量组或者列向量组的极大线性无关组中所含向量的个数，也可以理解为矩阵的秩就是有价值的内容数目。

  从这个意义上，我们很容易理解实际应用场最中秩对应的例子，在色彩学中，黄、蓝、红 3 种颜色是三原色，不可由其他颜色混合而成，所以这 3 种颜色可以看作线性无关；其他颜色可以由三原色中的颜色混合而成 ，如黄色加上蓝色得到绿色，那么黄、蓝 、绿就是线性相关的，所以有价值的内容是黄色和蓝色。 由此可见，此情况的秩就是最少用多少种颜色能够混合调出你需要的所有颜色，即原色的数量，黄和蓝得到绿色，这 3 种颜色的秩就是 2 。

  设 $A$ 为 $m\times n$ 阶矩阵，秩为 $R(A)$，$x$ 为 $n$ 个未知量的向量，对于 $n$ 元齐次线性方程组 $Ax=0$， 当 $R(A)=n$ 时，只有零解。当 $R(A)=r<n$ 时，该方程的非零解存在但不唯一，其解集 $S$ 的秩 $R(S)=n-r$。对于 $n$ 元非齐次线性方程组 $Ax=b$， 增广矩阵记为 $B$，秩为 $R(B)$，该方程无解的充要条件是 $R(A)<R(B)$，有唯一解的充要条件是 $R(A)=R(B)=n$，有无穷多解的充要条件是 $R(A)=R(B)<n$。

  设 $A$ 为 $m\times n$ 阶矩阵，秩为 $R(A)$，矩阵的秩与向量组线性相关的关系如下：

  $\bullet$ $R(A)=m<n$，行向量组无关，列向量组相关；
  $\bullet$ $R(A)=k<min(m,n)$，行向量组、列向量组都相关；
  $\bullet$ $R(A)=n<m$，列向量组无关，行向量组相关；
  $\bullet$ $R(A)=m=n$，行向量组、列向量组都无关。

3.4 矩阵秩的计算

  在 NumPy 中，通过 np.linalg.matrix_rank 函数可以计算出矩阵的秩。

【代码】：

import numpy as np

E = np.eye(4)
print("R(E) = ", np.linalg.matrix_rank(E))
A = [[1, -4, 0, 2], [-1, 2, -1, -1], [1, -2, 3, 5], [2, -6, 1, 3]]
B = np.array(A)
print("R(B) = ", np.linalg.matrix_rank(B))

【运行结果】：

R(E) =  4
R(B) =  3

4 内积与正交

  机器学习的许多算法会用到内积的计算，内积可以用于判断两个向量是否正交，以及求向量间的距离等。

4.1 向量的内积

设有同型的两个 $n$ 维列向量，$x={\left[\begin{array}{cccc}{x}_1& x_2& \cdots & x_n\end{array}\right]}^T$，$y={\left[\begin{array}{cccc}{y}_1& y_2& \cdots & y_n\end{array}\right]}^T$，令 $\left[x,y\right]=x_1{y}_1+x_2{y}_2+\cdots +x_n{y}_n$，称 $\left[x,y\right]$ 为向量 $x$ 和向量 $y$ 的内积。内积也可以用 $x\cdot y$ 表示。

  显见，内积是两个向量之间的一种运算，结果为一个实数。

  内积可以用矩阵的乘法表示，$$\left[x,y\right]=\left[\begin{array}{cccc}{x}_1& x_2& \cdots & x_n\end{array}\right]\left[\begin{array}{c}{y}_1\\ y_1\\ ⋮\\ y_1\end{array}\right]=x^{T}y$$

【性质】：向量的内积具有以下性质。

  ① 对称性：$\left[x,y\right]=\left[y,x\right]$。
  ② 线性性质：$\left[\lambda x,y\right]=\lambda \left[x,y\right],\left[x+y,z\right]=\left[x,z\right]+\left[y,z\right]$。
  ③ 当 $x=0$ 时，$\left[x,x\right]=0$，当 $x\ne 0$ 时，$\left[x,x\right]>0$。

  （1）NumPy 中通过 $np.dot()$ 函数可以实现向量的内积运算，例如实现列向量 $C1$ 和 $C2$ 的内积运算。

【代码】：

import numpy as np

A = [[1, 2, 3]]
B = [[4, 5, 6]]
C1 = np.array(A).reshape(3, 1)  # C1为三维列向量
C2 = np.array(B).reshape(3, 1)  # C2为三维列向量
D1 = np.dot(C1.T, C2)           # 计算C1和C2的内积
D2 = np.dot(C2.T, C1)           # 计算C2和C1的内积
print("D1 =", D1)
print("D2 =", D2)

【运行结果】：

D1 = [[32]]
D2 = [[32]]

【结果说明】：

  通过 $np.reshape()$ 函数将数组形式转变为列向量，上述结果表明 $\left[A,B\right]=\left[B,A\right]$。

  （2） $C1$ 和 $C2$ 均为行向量，实现 $C1$ 和 $C2$ 的内积运算。

【代码】：

import numpy as np

A = [[1, 2, 3]]
B = [[4, 5, 6]]
C1 = np.array(A)        # C1为三维行向量
C2 = np.array(B)        # C2为三维行向量
D1 = np.dot(C1, C2.T)   # 计算C1和C2的内积
D2 = np.dot(C2, C1.T)   # 计算C2和C1的内积
print("D1 =", D1)
print("D2 =", D2)

【运行结果】：

D1 = [[32]]
D2 = [[32]]

  （3）注意不能直接对两个行向量或列向量用 $np.dot()$ 函数计算内积 。

【代码】：

import numpy as np

A = [[1, 2, 3]]
B = [[4, 5, 6]]
C1 = np.array(A)        # C1为三维行向量
C2 = np.array(B)        # C2为三维行向量
D = np.dot(C1, C2)      # 计算C1和C2的内积
print("D =", D)

【运行结果】：

ValueError: shapes (1,3) and (1,3) not aligned: 3 (dim 1) != 1 (dim 0)

  （4）用一维数组表示向量时，利用一维数组的 $np.dot()$ 函数或 $np.inner()$ 函数也可以求出向量的内积值。

【代码】：

import numpy as np

A = [1, 2, 3]
B = [4, 5, 6]
C1 = np.array(A)        # C1为一维数组
C2 = np.array(B)        # C2为一维数组
D1 = np.dot(C1, C2)     # 计算C1和C2的内积
D2 = np.inner(C1, C2)   # 计算C1和C2的内积
print("D1 =", D1)
print("D2 =", D2)

【运行结果】：

D1 = 32
D2 = 32

4.2 向量的长度

$\Vert x\Vert =\sqrt{\left[x,x\right]}=\sqrt{x_1^2+x_2^2+\cdots +x_n^2}$ 为 $n$ 为向量 $x$ 的长度，当 $\Vert x\Vert =1$ 时，称 $x$ 为单位向量。

  对于向量 $a$，如果 $x=\frac{a}{\Vert a\Vert }$，则 $x$ 是一个单位向量，由向量 $a$ 得到 $x$ 的过程称为向量 $a$ 的单位化（也称标准化），$x$ 和 $a$ 方向相同，长度为 1。支持向量机的推导过程中会使用向量的单位化概念。

【性质】：向量的长度具有非负性、齐次性和三角不等式等性质。

  ① 非负性：$\Vert x\Vert >0$。
  ② 齐次性：$\Vert \lambda x\Vert =\left|\lambda \right|\cdot \Vert x\Vert$。
  ③ 三角不等式：$\Vert x+y\Vert \le \Vert x\Vert +\Vert y\Vert$。

  （1）向量的长度可以利用 NumPy 中的 $np.linalg.norm$ 函数求出。可以根据单位向量的定义来进行单位向量的计算，通过计算 $\frac{a}{\Vert a\Vert }$ 得到 $a$ 的单位向量。通过对所求出的单位向量求长度，可以验证单位向量的长度为 1 。

【代码】：

import numpy as np

A = np.array([[0, 3, 4]])
len_A = np.linalg.norm(A)
print("向量A的长度: ", len_A)
C = A / len_A   # 向量A对应的单位向量
print("向量C的: ", C)
len_C = np.linalg.norm(C)
print("向量C的长度: ", len_C)

【运行结果】：

向量A的长度:  5.0
向量C的:  [[0.  0.6 0.8]]
向量C的长度:  1.0

  （2）利用向量长度的定义求出向最长度。

【代码】：

import numpy as np

A = np.array([[0, 3, 4]])
len_A = np.sum(A ** 2) ** 0.5
print("向量A的长度: ", len_A)

【运行结果】：

向量A的长度:  5.0

  （3）利用两个向量的内积和长度可以求出两个向量夹角的余弦值。$$\left[x,y\right]=\Vert x\Vert \ast \Vert y\Vert \ast cos\theta$$  $\theta$ 为两个向量的夹角，$cos\theta$ 的取值范围为 $[-1,1]$， 当两个向量的方向重合时夹角余弦取最大值1，当两个向量的方向完全相反时夹角余弦取最小值 -1。夹角的余弦值越大，说明夹角越小，两点相距就越近；值越小，说明夹角越大，两点相距就越远。

【代码】：

import numpy as np

A = np.array([[1, 1]])
B = np.array([[2, 0]])
C = A.dot(B.T)
cos_theta = C / (np.linalg.norm(A) * np.linalg.norm(B))
print("向量A和B夹角的余弦值为: ", cos_theta)

【运行结果】：

向量A和B夹角的余弦值为:  [[0.70710678]]

  （4）在机器学习中， 常用到下面两个公式。

  ① 将 $\left[x,y\right]=\Vert x\Vert \ast \Vert y\Vert \ast cos\theta$ 中的项重新排列，写为 $\left[x,y\right]=\Vert x\Vert \ast \Vert y\Vert \ast cos\theta =\left(\Vert y\Vert \ast cos\theta \right)\ast \Vert x\Vert$。$\Vert y\Vert \ast cos\theta$ 表示 $y$ 在 $x$ 方向上的投影长度，如下图所示。

  ② ${\Vert x\Vert }^2=\left[x,x\right]$

4.3 向量的正交

当 $\left[x,y\right]=0$，即向量 $x$ 和 向量 $y$ 的内积为 0 时，称向量 $x$ 和 向量 $y$ 正交。

  正交可以理解为向量相互垂直。若 $x=0$，则 $x$ 与任何向量正交。

  若 $n$ 维向量 ${\alpha }_1,{\alpha }_2,\cdots ,{\alpha }_r$ 是一组两两正交的非零向量，则称 ${\alpha }_1,{\alpha }_2,\cdots ,{\alpha }_r$ 为正交向量组， ${\alpha }_1,{\alpha }_2,\cdots ,{\alpha }_r$ 线性无关。

【例】：已知三维向量空间 $R^3$ 中两个向量 $${\alpha }_1=\left[\begin{array}{c}1\\ 1\\ 1\end{array}\right],{\alpha }_2=\left[\begin{array}{c}2\\ -4\\ 2\end{array}\right]$$正交，求非零向量 ${\alpha }_3$， 使 ${\alpha }_1,{\alpha }_2,{\alpha }_3$ 两两正交。

4.4 标准正交基

设 $V$ 为向量空间，设 $V$ 中有 $r$ 个向量 ${\alpha }_1,{\alpha }_2,\cdots ,{\alpha }_r$，若 ${\alpha }_1,{\alpha }_2,\cdots ,{\alpha }_r$ 线性无关，而且 $V$ 中任一向量都可由这 $r$ 个向量线性表示，则称这 $r$ 个向量构成的向量组 ${\alpha }_1,{\alpha }_2,\cdots ,{\alpha }_r$ 为向量空间 $V$ 的基。这些向量的个数 $r$ 称为向量空间 $V$ 的维数，称 $V$ 为 $r$ 维向量空间。

  一个向量空间有很多基，但是应用比较多的是标准正交基。

若 ${\alpha }_1,{\alpha }_2,\cdots ,{\alpha }_r$ 是向量空间 $V$ 的基，${\alpha }_1,{\alpha }_2,\cdots ,{\alpha }_r$ 均是单位向量，而且两两正交，则称 ${\alpha }_1,{\alpha }_2,\cdots ,{\alpha }_r$ 是向量空间 $V$ 的标准正交基。

  标准正交基一定线性无关，且向量两两垂直。

  例如，$$e_1=\left[\begin{array}{c}1\\ 0\\ 0\\ 0\end{array}\right],e_2=\left[\begin{array}{c}0\\ 1\\ 0\\ 0\end{array}\right],e_3=\left[\begin{array}{c}0\\ 0\\ 1\\ 0\end{array}\right],e_4=\left[\begin{array}{c}0\\ 0\\ 0\\ 1\end{array}\right]$$ 是四维空间 $R^4$ 的一个标准正交基。

若 $n$ 阶方阵 $A$ 满足 $A^{T}A=E$ 或 $A{A}^T=E$，则称 $A$ 为正交矩阵，简称正交阵。

【例】：验证方阵 $$A=\left[\begin{array}{ccc}0& 1& 0\\ \frac{1}{\sqrt{2}}& 0& \frac{1}{\sqrt{2}}\\ -\frac{1}{\sqrt{2}}& 0& \frac{1}{\sqrt{2}}\end{array}\right]$$ 为一个正交矩阵。

【代码】：

import numpy as np

A = np.array([[0, 1, 0],
              [1/2**0.5, 0, 1/2**0.5],
              [-1/2**0.5, 0, 1/2**0.5]])
print("A x A.T = ", np.round(A.dot(A.T), 0))

【运行结果】：

A x A.T =  [[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]

【结果说明】：

  使用 $np.round()$ 函数对原浮点数迸行四舍五入，结果为单位矩阵，所以 A 为正交矩阵。

  方阵 $A$ 为正交矩阵的充分必要条件是 $A$ 的列（行）向量都是单位向量，且两两正交，即 $A$ 的列（行）向量组构成标准正交基。

在复数范围内满足 $A^{T}A=E$ 或 $A{A}^T=E$，则称 $A$ 为酉矩阵。

  酉矩阵常用于奇异值分解 (SVD) 中，正交矩阵是实数特殊化的酉矩阵。

【性质】：正交矩阵具有如下的性质，

  $\bullet$ 若 $A$ 是正交矩阵，则 $A^{-1}=A^T$ 也是正交矩阵；
  $\bullet$ 若 $A$ 和 $B$ 是正交矩阵，则 $AB$ 也是正交矩阵。

5 综合实例一线性代数在实际问题中的应用

【例】：已知不同商店 3 种水果的价格 、不同人员需要水果的数量以及不同城镇不同人员的数目如表格所示。

  （1）计算在每个商店中每个人购买水果的费用。
  （2）计算在每个城镇中每种水果的购买量。

【问题分析】：

  可以用矩阵描述 3 个表格和所求的两个问题。将 3 个表格分别用矩阵 $A$ 、 $B$ 和 $C$ 表示， 设描述每个商店中每个人购买水果的费用的矩阵为 $D$，描述每个城镇中每种水果的购买量的矩阵为 $E$。

  （1）人员 $A$ 在商店 $A$ 购买的费用是 $5\times 8.5+10\times 4.5+3\times 9$，人员 $B$ 在商店 $A$ 购买的费用是 $4\times 8.5+5\times 4.5+5\times 9$，人员 $A$ 在商店 $B$ 购买的费用是 $5\times 9+10\times 4+3\times 9.5$，人员 $B$ 在商店 $B$ 购买的费用是 $4\times 9+5\times 4+5\times 9.5$， 根据矩阵的乘法 ， 求出 $D=BA$。
  （2）同理可以分析得到，$E=CB$。

【代码】：

import numpy as np

A = np.array([[8.5, 9], [4.5, 4], [9, 9.5]])    # 不同商店中3种水果的价格
B = np.array([[5, 10, 3], [4, 5, 5]])           # 不同人员需要水果的数量
C = np.array([[1000, 500], [2000, 1000]])       # 不同城镇中不同人员的数目
D = np.dot(B, A)                                # 每个商店中每个人购买水果的费用
E = np.dot(C, B)                                # 每个城镇中每种水果的购买量
print("每个商店中每个人购买水果的费用: \n", D)
print("每个城镇中每种水果的购买量: \n", E)

【运行结果】：

每个商店中每个人购买水果的费用: 
 [[114.5 113.5]
 [101.5 103.5]]
每个城镇中每种水果的购买量: 
 [[ 7000 12500  5500]
 [14000 25000 11000]]

【例】：将某线性系统用下列的线性方程组表示，求未知量 $x$、$y$、$z$ 的值，并验证结果。$$\{\begin{array}{c}x+2y+z=7\\ 2x-y+3z=7\\ 3x+y+2z=18\end{array}$$

【问题分析】：

  根据前面的理论知识，我们可以将该线性方程组表示为 $AX=B$，其中 $A$ 为系数矩阵，$X$ 为未知数矩阵，$B$ 为常数项矩阵。

  步骤1：求出系数矩阵 $A$ 的秩和增广矩阵 $(A,B)$ 的秩。
  步骤2：根据 $R(A)$ 和 $R(A,B)$ 的个数关系，选择不同的方法来求解。

【代码】：

import numpy as np

A = np.array([[1, 2, 1], [2, -1, 3], [3, 1, 2]])    # 系数矩阵
B = np.array([[7, 7, 18]]).reshape(3, 1)            # 常数项矩阵
print("系数矩阵A的大小: ", A.shape)
print("系数矩阵A的秩: ", np.linalg.matrix_rank(A))
AB = np.hstack((A, B))  # 增广矩阵
print("增广矩阵AB: \n", AB)
print("增广矩阵AB的秩: ", np.linalg.matrix_rank(AB))

【运行结果】：

系数矩阵A的大小:  (3, 3)
系数矩阵A的秩:  3
增广矩阵AB: 
 [[ 1  2  1  7]
 [ 2 -1  3  7]
 [ 3  1  2 18]]
增广矩阵AB的秩:  3

【结果说明】：

  未知数的个数为 3， $R(A)=R(A,B)=3$，因此有 3 种方法来求解矩阵 $X$。上述代码中使用了 $np.hstack()$ 函数实现将两个矩阵在水平方向上平铺，得到一个新矩阵。

  方法1：利用逆矩阵可以求解线性方程组 $AX=B$。

  根据数学方法，显见 $X=B/A$。但是矩阵没有除法运算，所以可以通过下面的方法求解 $X$：等式两边在相同位置同时乘以矩阵 $A$ 的逆矩阵，得到 $A^{-1}AX=A^{-1}B$，因为 $A{A}^{-1}=E$，$E$ 为单位矩阵，任何矩阵乘以单位矩阵的结果都是其本身。所以， $X=A^{-1}B$。通过验证 $AX=B$ 是否成立，确定 $X$ 是否为解。

【代码】：

import numpy as np

A = np.array([[1, 2, 1], [2, -1, 3], [3, 1, 2]])    # 系数矩阵
B = np.array([[7, 7, 18]]).reshape(3, 1)            # 常数项矩阵
A_inv = np.linalg.inv(A)                            # A的逆矩阵
X = np.dot(A_inv, B)                                # 未知数矩阵X
print("A的逆矩阵： \n", A_inv)
print("利用逆矩阵求出X的值: \n", X)
C = np.dot(A, X)
print("A和X的乘积: \n", C)
print("B和C是否相等: ", np.allclose(C, B))

【运行结果】：

A的逆矩阵： 
 [[-0.5 -0.3  0.7]
 [ 0.5 -0.1 -0.1]
 [ 0.5  0.5 -0.5]]
利用逆矩阵求出X的值: 
 [[ 7.]
 [ 1.]
 [-2.]]
A和X的乘积: 
 [[ 7.]
 [ 7.]
 [18.]]
B和C是否相等:  True

  方法2：NumPy 提供了 $np.linalg.solve()$ 函数解形如 $Ax=b$ 的线性方程组。

【代码】：

import numpy as np

A = np.array([[1, 2, 1], [2, -1, 3], [3, 1, 2]])    # 系数矩阵
B = np.array([[7, 7, 18]]).reshape(3, 1)            # 常数项矩阵
X = np.linalg.solve(A, B)                           # 未知数矩阵X
print("利用solve函数求出X的值: \n", X)
C = np.dot(A, X)
print("A和X的乘积: \n", C)
print("B和C是否相等: ", np.allclose(C, B))

【运行结果】：

利用solve函数求出X的值: 
 [[ 7.]
 [ 1.]
 [-2.]]
A和X的乘积: 
 [[ 7.]
 [ 7.]
 [18.]]
B和C是否相等:  True

【注意】：$np.linalg.solve()$ 函数要求系数矩阵 $A$ 必须是非奇异矩阵。

  方法3：利用 SymPy 库的 $solve()$ 函数可以解任意系数矩阵的线性方程组。

  $solve()$ 函数通常传入两个参数，第 1 个参数是方程的表达式（把方程所有的项移到等号的同一边形成的式子），第 2个参数是方程中的未知数，函数返回类型为字典型，代表方程的所有根。原方程组表示 $x+2y+z-7=0$， $2x-y+3z-7=0$，$3x+y+2z-18=0$。

【代码】：

import numpy as np
from sympy import *

x, y, z = symbols("x y z")  # 3个变量
eq = [x + 2*y + z - 7, 2*x - y + 3*z - 7, 3*x + y + 2*z - 18]
result = solve(eq, [x, y, z])
print("result = ", result)

【运行结果】：

result =  {x: 7, y: 1, z: -2}

【结果说明】：

  利用 SymPy 的 $solve()$ 函数求解的结果与NumPy 的 $solve()$ 函数求解结果一样。但是 SymPy 的$solve()$ 函数可以求解的方程组更多，如齐次方程或者系数矩阵为奇异矩阵。

【例】：解方程组：$$\{\begin{array}{c}x+2y+z-2w=0\\ 2x+3y-w=0\\ x-y-5z+7w=0\end{array}$$

  首先，验证系数矩阵 $A$ 的大小和秩。

【代码】：

import numpy as np
from sympy import *

A = np.array([[1, 2, 1, -2], [2, 3, 0, -1], [1, -1, -5, 7]])
print("系数矩阵A的大小: ", A.shape)
print("系数矩阵A的秩: ", np.linalg.matrix_rank(A))

【运行结果】：

系数矩阵A的大小:  (3, 4)
系数矩阵A的秩:  2

【结果说明】：

  显然，该方程非方阵，该线性方程组的解不唯一。因此可以利用方法 3 计算求解矩阵。

【代码】：

import numpy as np
from sympy import *

x, y, z, w = symbols("x y z w")
eq = [x + 2*y + z - 2*w, 2*x + 3*y - w, x - y - 5*z + 7*w]
result = solve(eq, [x, y, z, w])
print("result = ", result)

【运行结果】：

result =  {x: -4*w + 3*z, y: 3*w - 2*z}

【结果说明】：

  从输出的结果可以看出，$z$ 和 $w$ 是自由未知数，$x=-4w+3z,y=3w-2z$。

  SymPy 的 $solve()$ 函数返同类型为字典型。 所以通过 $result[x]$ 获取 $x$ 的表达式 ，利用 $evalf()$ 函数计算 $x$ 值。 $y$ 的计算方法同 $x$。

【代码】：

import numpy as np
from sympy import *

x, y, z, w = symbols("x y z w")
eq = [x + 2*y + z - 2*w, 2*x + 3*y - w, x - y - 5*z + 7*w]
result = solve(eq, [x, y, z, w])
A = {z: 1, w: 2}
x = float(result[x].evalf(subs=A))
y = float(result[y].evalf(subs=A))
print("x = ", x, ", y = ", y, ", z = ", 1, ", w = ", 2)

【运行结果】：

x =  -5.0 , y =  4.0 , z =  1 , w =  2