python矩阵运算

Python矩阵运算

在Jupyter中写下你的Python矩阵基本运算的学习记录。按照附件1提供的参考资料，把七个实验完整地实践练习一遍。

Python矩阵基本运算

1、导入numpy数据包，使用mat函数创建一个2x3矩阵

import numpy as np
a = np.mat([[1,2,3],[4,5,6]])
a

matrix([[1, 2, 3],
        [4, 5, 6]])

2、使用shape可以获取矩阵的大小

a.shape

(2, 3)

3、使用下标读取矩阵中的元素

a.T

matrix([[1, 4],
        [2, 5],
        [3, 6]])

4、进行行列转换：

a.transpose()

matrix([[1, 4],
        [2, 5],
        [3, 6]])

a.T

matrix([[1, 4],
        [2, 5],
        [3, 6]])

5、实际上官方文档建议我们使用二维数组代替矩阵来进行矩阵运算；因为二维数组用得较多，而且基本可取代矩阵。比如：可见矩阵和数组基本上都可以

b = np.array([[1,2,3],[4,5,6]])
b

array([[1, 2, 3],
       [4, 5, 6]])

b.T

array([[1, 4],
       [2, 5],
       [3, 6]])

a + a

matrix([[ 2,  4,  6],
        [ 8, 10, 12]])

b + b

array([[ 2,  4,  6],
       [ 8, 10, 12]])

c = [[1,2,3],[4,5,6]]
c + c 

[[1, 2, 3], [4, 5, 6], [1, 2, 3], [4, 5, 6]]

Python矩阵乘法

1. 使用二维数组创建两个矩阵A和B

import numpy as np
A = np.array([[1,2,3],[4,5,6]])
B = np.array([[1,4],[2,5],[3,6]])

2. 先来一个矩阵的数乘，其实见识矩阵的每一个元素乘以该数

2*A

array([[ 2,  4,  6],
       [ 8, 10, 12]])

2*B

array([[ 2,  8],
       [ 4, 10],
       [ 6, 12]])

3. dot函数用于矩阵乘法，对于二维数组，它计算的是矩阵乘积，对于一维数组，它计算的是内积。注意交换矩阵的前后位置会导致不同的结果，看下面的例子

A*B

---------------------------------------------------------------------------

ValueError                                Traceback (most recent call last)

<ipython-input-23-47896efed660> in <module>
----> 1 A*B


ValueError: operands could not be broadcast together with shapes (2,3) (3,2) 

np.dot(A,B)

array([[14, 32],
       [32, 77]])

np.dot(B,A)

array([[17, 22, 27],
       [22, 29, 36],
       [27, 36, 45]])

4. 再创建一个二维数组

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

5. 我们验证一个矩阵乘法的结合性 （AB)C=A(BC）

np.dot(np.dot(A,B),C)

array([[ 46, 124],
       [109, 295]])

np.dot(A,np.dot(B,C))

array([[ 46, 124],
       [109, 295]])

6. 接着看一下对加法的分配性 （A+B)C=AC+BC，C(A+B）=CA+CB

D = B - 1
print(D)

[[0 3]
 [1 4]
 [2 5]]

np.dot(A,B+D)

array([[ 22,  58],
       [ 49, 139]])

np.dot(A,B)+np.dot(A,D)

array([[ 22,  58],
       [ 49, 139]])

7. 数乘的结合性，也一样啦：

2*(np.dot(A,B))

array([[ 28,  64],
       [ 64, 154]])

np.dot(A,2*B)

array([[ 28,  64],
       [ 64, 154]])

np.dot(2*A,B)

array([[ 28,  64],
       [ 64, 154]])

np.dot(A,2*B)

array([[ 28,  64],
       [ 64, 154]])

8. 接着我们用到一个新知识，使用eye创建一个单位矩阵，单位矩阵的定义就是看下面的步骤

I=np.eye(3)
print(I)

[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]

9. 我们看一下，一个矩阵A乘以一个单位矩阵，还是它本身

np.dot(A,I)

array([[1., 2., 3.],
       [4., 5., 6.]])

python矩阵转置

1. 先创建一个矩阵A

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

2. 我们使用属性T来得到矩阵A的转置矩阵

A.T

array([[1, 4],
       [2, 5],
       [3, 6]])

3. 我们验证第一个性质

4. (A’)’=A

A.T.T

array([[1, 2, 3],
       [4, 5, 6]])

5. 再创建两个尺寸相同的矩阵

B = np.array([[1,4],[2,5],[3,6]])
D = np.array([[0,3],[1,4],[2,5]])

6. 验证矩阵转置的第二个性质：(A±B)’=A’±B’

(B+D).T

array([[ 1,  3,  5],
       [ 7,  9, 11]])

B.T+D.T

array([[ 1,  3,  5],
       [ 7,  9, 11]])

7. 验证矩阵转置的第三个性质：(KA)’=KA’

10*A.T

array([[10, 40],
       [20, 50],
       [30, 60]])

(10+A).T

array([[11, 14],
       [12, 15],
       [13, 16]])

8. 验证矩阵转置的第四个性质：(A×B)’= B’×A’

np.dot(A,B).T

array([[14, 32],
       [32, 77]])

np.dot(A.T,B.T)

array([[17, 22, 27],
       [22, 29, 36],
       [27, 36, 45]])

np.dot(B.T,A.T)

array([[14, 32],
       [32, 77]])

python求方阵的迹

1. 先引入numpy
2. 创建一个方阵（方阵也就是行数等于列数的矩阵）

E = np.array([[1,2,3],[4,5,6],[7,8,9]])

3. 用trace计算方阵的迹

np.trace(E)

15

4. 再创建一个方阵F

F =E-2
print(F)

[[-1  0  1]
 [ 2  3  4]
 [ 5  6  7]]

5. 验证一下方阵的迹等于方阵的转置的迹

np.trace(E)

15

np.trace(E.T)

15

6. 验证一下方阵的乘积的迹等于

np.trace(np.dot(E,F))

171

np.trace(np.dot(F,E))

171

7. 验证一下方阵的和的迹等于方阵的迹的和

np.trace(E+F)

24

np.trace(E)+np.trace(F)

24

python方阵的行列式计算方法

1. 行列式的算法：这是二阶方阵行列式
   

2. 行列式的算法：这是三阶行列式
   

3. 先引入numpy模块

4. 创建两个方阵

E = np.array([[1,2,3],[4,5,6],[7,8,9]])
F = np.array([[-1,0,1],[2,3,4],[5,6,7]])

5. 使用det方法求得方阵E和方阵F的行列式

np.linalg.det(E)

-9.51619735392994e-16

np.linalg.det(F)

1.0658141036401459e-15

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

np.linalg.det(C)

1.0

python求逆矩阵/伴随矩阵

1. 先来求一下矩阵的逆，先引入numpy
   

2. 然后创建一个方阵

A = np.array([[1,-2,1],[0,2,-1],[1,1,-2]])

3. 使用linalg.det求得方阵的行列式

A_abs = np.linalg.det(A)
print(A_abs)

-2.9999999999999996

4. 使用linalg.inv求得方阵A的逆矩阵

B = np.linalg.inv(A)
print(B)

[[ 1.00000000e+00  1.00000000e+00 -1.11022302e-16]
 [ 3.33333333e-01  1.00000000e+00 -3.33333333e-01]
 [ 6.66666667e-01  1.00000000e+00 -6.66666667e-01]]

5. 接着我们利用公式：
   numpy的计算方法：

A_bansui = B * A_abs
print(A)

[[ 1 -2  1]
 [ 0  2 -1]
 [ 1  1 -2]]

python解多元一次方程

1. 首先看一下我们要解的方程，将这个方程格式调整好，按照x-y-z-常数项的顺序排列
   {x+2y+z=7
   2x-y+3z=7
   3x+y+2z=18}组

2. 将未知数的系数写下来，排列成一个矩阵a，如下

a = [[1,2,1],[2,-1,3],[3,1,2]]
a = np.array(a)
print(a)

[[ 1  2  1]
 [ 2 -1  3]
 [ 3  1  2]]

3. 常数项构成一个一维数组（向量）

b = [7,7,18]
b = np.array(b)
print(b)

[ 7  7 18]

4. 使用linalg.solve方法解方程，参数a指的是系数矩阵，参数b指的是常数项矩阵：

x = np.linalg.solve(a,b)
print(x)

[ 7.  1. -2.]

5. 我们得到的解对不对呢？使用点乘的方法可以验证一下，系数乘以未知数可以得到常数项。

np.dot(a,x)

array([ 7.,  7., 18.])