人工智能必备数学知识学习笔记6：矩阵（矩阵不只是mn个数字）

什么是矩阵（Matrix）

代码实现：

1.在 Matrix.py中编写代码：

 1 #矩阵类
 2 from playLA.Vector import Vector
 3 
 4 
 5 class Matrix:
 6     # 餐数2：二维数组
 7     def __init__(self, list2d):
 8         self._values = [row[:] for row in list2d]#将数组变为矩阵
 9 
10     #返回矩阵的第index个行向量
11     def row_vector(self,index):
12         return Vector(self._values[index])
13 
14     # 返回矩阵的第index个列向量
15     def col_vector(self, index):
16         return Vector([row[index] for row in self._values])
17 
18     #返回矩阵pos位置的元素(根据元素的位置取元素值) :参数2：元组
19     def __getitem__(self, pos):
20         r,c = pos
21         return self._values[r][c]
22 
23     #返回矩阵的元素个数
24     def size(self):
25         r,c = self.shape()
26         return r*c
27 
28     #返回矩阵行数
29     def row_num(self):
30         return self.shape()[0]
31 
32     __len__ = row_num
33 
34     #返回矩阵列数
35     def col_num(self):
36         return self.shape()[1]
37 
38     #返回矩阵形状：（行数，列数）
39     def shape(self):
40         return len(self._values),len(self._values[0])
41 
42     #矩阵展示
43     def __repr__(self):
44         return "Matrix({})".format(self._values)
45 
46     __str__ = __repr__

2.在main_matrix.py编写代码：

 1 from playLA.Matrix import Matrix
 2 
 3 if __name__ == "__main__":
 4     #生成一个矩阵
 5     matrix = Matrix([[1,2],[3,4]])
 6     print(matrix)
 7     #矩阵的行数和列数（返回矩阵形状：（行数，列数））
 8     print("matrix.shape = {}".format(matrix.shape()))
 9     #返回矩阵的元素个数
10     print("matrix.size = {}".format(matrix.size()))
11     print("len(matrix) = {}".format(len(matrix)))
12     #根据元素的位置取元素值
13     print("matrix[0][0] = {}".format(matrix[0,0]))
14     # 返回矩阵的第index个行向量
15     print("matrix.row_vector = {}".format(matrix.row_vector(0)))
16     # 返回矩阵的第index个列向量
17     print("matrix.col_vector = {}".format(matrix.col_vector(0)))

3.运行main_matrix.py结果为：

 1 /Users/liuxiaoming/PycharmProjects/LinearAlgebra/venv/bin/python /Applications/PyCharm.app/Contents/plugins/python/helpers/pydev/pydevconsole.py --mode=client --port=62627
 2 import sys; print('Python %s on %s' % (sys.version, sys.platform))
 3 sys.path.extend(['/Users/liuxiaoming/PycharmProjects/LinearAlgebra'])
 4 PyDev console: starting.
 5 Python 3.8.2 (v3.8.2:7b3ab5921f, Feb 24 2020, 17:52:18) 
 6 [Clang 6.0 (clang-600.0.57)] on darwin
 7 >>> runfile('/Users/liuxiaoming/PycharmProjects/LinearAlgebra/main_matrix.py', wdir='/Users/liuxiaoming/PycharmProjects/LinearAlgebra')
 8 Matrix([[1, 2], [3, 4]])
 9 matrix.shape = (2, 2)
10 matrix.size = 4
11 len(matrix) = 2
12 matrix[0][0] = 1
13 matrix.row_vector = (1, 2)
14 matrix.col_vector = (1, 3)

矩阵的基本运算

矩阵加法：

矩阵数量乘法：

证明：

代码实现：

1.在 Matrix.py中编写代码：

 1 #矩阵类
 2 from playLA.Vector import Vector
 3 
 4 
 5 class Matrix:
 6     # 参数2：二维数组
 7     def __init__(self, list2d):
 8         self._values = [row[:] for row in list2d]#将数组变为矩阵
 9 
10     #矩阵类方法:返回一个r行c列的零矩阵：参数1：为零的类对象
11     @classmethod
12     def zero(cls,r,c):
13         return cls([[0] * c for _ in range(r)]) #创建一个r行c列为零的一个列表
14 
15     #返回两个矩阵的加法结果
16     def __add__(self, another):
17         # 校验两个矩阵的形状为一致（行数、列数一致）
18         assert self.shape() == another.shape(), 
19             "Error in adding. Shape of matrix must be same."
20         # 根据矩阵的加法公式：两个矩阵对应的每一行的每一个元素相加，获得新的矩阵(遍历两个矩阵对应的每一个行每个元素进行相加<第二步>，外部再遍历该矩阵的行数（循环的次数）<第一步>)
21         return Matrix([[a+b for a,b in zip(self.row_vector(i),another.row_vector(i))]
22                        for i in range(self.row_num())])
23 
24     # 返回两个矩阵的减法结果
25     def __sub__(self, another):
26         assert self.shape() == another.shape(), 
27             "Error in subtracting. Shape of matrix must be same."
28         return Matrix([[a - b for a, b in zip(self.row_vector(i), another.row_vector(i))]
29                        for i in range(self.row_num())])
30 
31     #返回矩阵的数量乘结果(矩阵乘以数字)：self * k
32     def __mul__(self, k):
33         #通过遍历每一行的每个元素e后分别乘以k<第一步>，外部再遍历该矩阵的行数（循环的次数）<第二步>
34         return Matrix([[e * k for e in self.row_vector(i)]
35                        for i in range(self.row_num())])
36 
37     # 返回矩阵的数量乘结果(数字乘以矩阵)：k * self
38     def __rmul__(self, k):
39         return self * k
40 
41     #返回数量除法的结果矩阵：self / k
42     def __truediv__(self, k):
43         return (1 / k) * self
44 
45     #返回矩阵取正的结果
46     def __pos__(self):
47         return 1 * self
48 
49     #返回矩阵取负的结果
50     def __neg__(self):
51         return -1 * self
52 
53     #返回矩阵的第index个行向量
54     def row_vector(self,index):
55         return Vector(self._values[index])
56 
57     # 返回矩阵的第index个列向量
58     def col_vector(self, index):
59         return Vector([row[index] for row in self._values])
60 
61     #返回矩阵pos位置的元素(根据元素的位置取元素值) :参数2：元组
62     def __getitem__(self, pos):
63         r,c = pos
64         return self._values[r][c]
65 
66     #返回矩阵的元素个数
67     def size(self):
68         r,c = self.shape()
69         return r*c
70 
71     #返回矩阵行数
72     def row_num(self):
73         return self.shape()[0]
74 
75     __len__ = row_num
76 
77     #返回矩阵列数
78     def col_num(self):
79         return self.shape()[1]
80 
81     #返回矩阵形状：（行数，列数）
82     def shape(self):
83         return len(self._values),len(self._values[0])
84 
85     #矩阵展示
86     def __repr__(self):
87         return "Matrix({})".format(self._values)
88 
89     __str__ = __repr__

2.在main_matrix.py编写代码：

 1 from playLA.Matrix import Matrix
 2 
 3 if __name__ == "__main__":
 4     #生成一个矩阵
 5     matrix = Matrix([[1,2],[3,4]])
 6     print(matrix)
 7     #矩阵的行数和列数（返回矩阵形状：（行数，列数））
 8     print("matrix.shape = {}".format(matrix.shape()))
 9     #返回矩阵的元素个数
10     print("matrix.size = {}".format(matrix.size()))
11     print("len(matrix) = {}".format(len(matrix)))
12     #根据元素的位置取元素值
13     print("matrix[0][0] = {}".format(matrix[0,0]))
14     # 返回矩阵的第index个行向量
15     print("matrix.row_vector = {}".format(matrix.row_vector(0)))
16     # 返回矩阵的第index个列向量
17     print("matrix.col_vector = {}".format(matrix.col_vector(0)))
18 
19     # 返回两个矩阵的加法结果
20     matrix2 = Matrix([[5,6],[7,8]])
21     print("add:{}".format(matrix + matrix2))
22     # 返回两个矩阵的减法结果
23     print("subtract:{}".format(matrix - matrix2))
24     #返回矩阵的数量乘结果(矩阵乘以数字)：self * k
25     print("scalar-mul:{}".format(matrix * 2))
26     # 返回矩阵的数量乘结果(数字乘以矩阵)：k * self
27     print("scalar-mul:{}".format(2 * matrix))
28     # 零矩阵类方法:返回一个2行3列的零矩阵
29     print("zero_2_3:{}".format(Matrix.zero(2,3)))

3.运行main_matrix.py结果为：

 1 /Users/liuxiaoming/PycharmProjects/LinearAlgebra/venv/bin/python /Applications/PyCharm.app/Contents/plugins/python/helpers/pydev/pydevconsole.py --mode=client --port=62885
 2 import sys; print('Python %s on %s' % (sys.version, sys.platform))
 3 sys.path.extend(['/Users/liuxiaoming/PycharmProjects/LinearAlgebra'])
 4 PyDev console: starting.
 5 Python 3.8.2 (v3.8.2:7b3ab5921f, Feb 24 2020, 17:52:18) 
 6 [Clang 6.0 (clang-600.0.57)] on darwin
 7 runfile('/Users/liuxiaoming/PycharmProjects/LinearAlgebra/main_matrix.py', wdir='/Users/liuxiaoming/PycharmProjects/LinearAlgebra')
 8 Matrix([[1, 2], [3, 4]])
 9 matrix.shape = (2, 2)
10 matrix.size = 4
11 len(matrix) = 2
12 matrix[0][0] = 1
13 matrix.row_vector = (1, 2)
14 matrix.col_vector = (1, 3)
15 add:Matrix([[6, 8], [10, 12]])
16 subtract:Matrix([[-4, -4], [-4, -4]])
17 scalar-mul:Matrix([[2, 4], [6, 8]])
18 scalar-mul:Matrix([[2, 4], [6, 8]])
19 zero_2_3:Matrix([[0, 0, 0], [0, 0, 0]])

把矩阵看做是对系统的描述

矩阵与向量的乘法

如果矩阵的行数为1时：

矩阵与矩阵的乘法

代码实现：

1.在 Matrix.py中编写代码：返回两个矩阵的乘法结果（矩阵乘以矩阵）

  1 #矩阵类
  2 from playLA.Vector import Vector
  3 
  4 
  5 class Matrix:
  6     # 参数2：二维数组
  7     def __init__(self, list2d):
  8         self._values = [row[:] for row in list2d]#将数组变为矩阵
  9 
 10     #矩阵类方法:返回一个r行c列的零矩阵：参数1：为零的类对象
 11     @classmethod
 12     def zero(cls,r,c):
 13         return cls([[0] * c for _ in range(r)]) #创建一个r行c列为零的一个列表
 14 
 15     #返回两个矩阵的加法结果
 16     def __add__(self, another):
 17         # 校验两个矩阵的形状为一致（行数、列数一致）
 18         assert self.shape() == another.shape(), 
 19             "Error in adding. Shape of matrix must be same."
 20         # 根据矩阵的加法公式：两个矩阵对应的每一行的每一个元素相加，获得新的矩阵(遍历两个矩阵对应的每一个行每个元素进行相加<第二步>，外部再遍历该矩阵的行数（循环的次数）<第一步>)
 21         return Matrix([[a+b for a,b in zip(self.row_vector(i),another.row_vector(i))]
 22                        for i in range(self.row_num())])
 23 
 24     # 返回两个矩阵的减法结果
 25     def __sub__(self, another):
 26         assert self.shape() == another.shape(), 
 27             "Error in subtracting. Shape of matrix must be same."
 28         return Matrix([[a - b for a, b in zip(self.row_vector(i), another.row_vector(i))]
 29                        for i in range(self.row_num())])
 30 
 31     #返回两个矩阵的乘法结果（矩阵乘以矩阵）
 32     def dot(self,another):
 33         if isinstance(another,Vector):#判断是否为向量：矩阵与向量的乘法
 34             assert self.col_num() == len(another),
 35                 "Error in Matrix_Vector Multiplication." #矩阵与向量的乘法错误
 36             return Vector([self.row_vector(i).dot(another) for i in range(self.row_num())])
 37         if isinstance(another,Matrix):#判断是否为矩阵：矩阵与矩阵的乘法
 38             assert self.col_num() == another.row_num(),
 39                 "Error in Matrix-Matrix Multiplication." #矩阵与矩阵的乘法错误
 40             # 将矩阵的每一行与另一矩阵的每一列进行向量间的点乘
 41             return Matrix([[self.row_vector(i).dot(another.col_vector(j)) for j in range(another.col_num())]
 42                             for i in range(self.row_num())])
 43 
 44     #返回矩阵的数量乘结果(矩阵乘以数字)：self * k
 45     def __mul__(self, k):
 46         #通过遍历每一行的每个元素e后分别乘以k<第一步>，外部再遍历该矩阵的行数（循环的次数）<第二步>
 47         return Matrix([[e * k for e in self.row_vector(i)]
 48                        for i in range(self.row_num())])
 49 
 50     # 返回矩阵的数量乘结果(数字乘以矩阵)：k * self
 51     def __rmul__(self, k):
 52         return self * k
 53 
 54     #返回数量除法的结果矩阵：self / k
 55     def __truediv__(self, k):
 56         return (1 / k) * self
 57 
 58     #返回矩阵取正的结果
 59     def __pos__(self):
 60         return 1 * self
 61 
 62     #返回矩阵取负的结果
 63     def __neg__(self):
 64         return -1 * self
 65 
 66     #返回矩阵的第index个行向量
 67     def row_vector(self,index):
 68         return Vector(self._values[index])
 69 
 70     # 返回矩阵的第index个列向量
 71     def col_vector(self, index):
 72         return Vector([row[index] for row in self._values])
 73 
 74     #返回矩阵pos位置的元素(根据元素的位置取元素值) :参数2：元组
 75     def __getitem__(self, pos):
 76         r,c = pos
 77         return self._values[r][c]
 78 
 79     #返回矩阵的元素个数
 80     def size(self):
 81         r,c = self.shape()
 82         return r*c
 83 
 84     #返回矩阵行数
 85     def row_num(self):
 86         return self.shape()[0]
 87 
 88     __len__ = row_num
 89 
 90     #返回矩阵列数
 91     def col_num(self):
 92         return self.shape()[1]
 93 
 94     #返回矩阵形状：（行数，列数）
 95     def shape(self):
 96         return len(self._values),len(self._values[0])
 97 
 98     #矩阵展示
 99     def __repr__(self):
100         return "Matrix({})".format(self._values)
101 
102     __str__ = __repr__

2.在main_matrix.py编写代码：返回两个矩阵的乘法结果（矩阵乘以矩阵）

 1 from playLA.Matrix import Matrix
 2 from playLA.Vector import Vector
 3 
 4 if __name__ == "__main__":
 5     #生成一个矩阵
 6     matrix = Matrix([[1,2],[3,4]])
 7     print(matrix)
 8     #矩阵的行数和列数（返回矩阵形状：（行数，列数））
 9     print("matrix.shape = {}".format(matrix.shape()))
10     #返回矩阵的元素个数
11     print("matrix.size = {}".format(matrix.size()))
12     print("len(matrix) = {}".format(len(matrix)))
13     #根据元素的位置取元素值
14     print("matrix[0][0] = {}".format(matrix[0,0]))
15     # 返回矩阵的第index个行向量
16     print("matrix.row_vector = {}".format(matrix.row_vector(0)))
17     # 返回矩阵的第index个列向量
18     print("matrix.col_vector = {}".format(matrix.col_vector(0)))
19 
20     # 返回两个矩阵的加法结果
21     matrix2 = Matrix([[5,6],[7,8]])
22     print("add:{}".format(matrix + matrix2))
23     # 返回两个矩阵的减法结果
24     print("subtract:{}".format(matrix - matrix2))
25     #返回矩阵的数量乘结果(矩阵乘以数字)：self * k
26     print("scalar-mul:{}".format(matrix * 2))
27     # 返回矩阵的数量乘结果(数字乘以矩阵)：k * self
28     print("scalar-mul:{}".format(2 * matrix))
29     # 零矩阵类方法:返回一个2行3列的零矩阵
30     print("zero_2_3:{}".format(Matrix.zero(2,3)))
31 
32     # 返回两个矩阵的乘法结果（矩阵乘以矩阵）
33     T = Matrix([[1.5,0],[0,2]])
34     p = Vector([5,3])
35     print("T.dot(p) = {}".format(T.dot(p)))
36     P = Matrix([[0,4,5],[0,0,3]])
37     print("T.dot(P) = {}".format(T.dot(P)))
38     print("matrix.dot(matrix2) = {}".format(matrix.dot(matrix2)))
39     print("matrix2.dot(matrix) = {}".format(matrix2.dot(matrix)))

3.运行main_matrix.py结果为：

 1 /Users/liuxiaoming/PycharmProjects/LinearAlgebra/venv/bin/python /Applications/PyCharm.app/Contents/plugins/python/helpers/pydev/pydevconsole.py --mode=client --port=65252
 2 import sys; print('Python %s on %s' % (sys.version, sys.platform))
 3 sys.path.extend(['/Users/liuxiaoming/PycharmProjects/LinearAlgebra'])
 4 PyDev console: starting.
 5 Python 3.8.2 (v3.8.2:7b3ab5921f, Feb 24 2020, 17:52:18) 
 6 [Clang 6.0 (clang-600.0.57)] on darwin
 7 runfile('/Users/liuxiaoming/PycharmProjects/LinearAlgebra/main_matrix.py', wdir='/Users/liuxiaoming/PycharmProjects/LinearAlgebra')
 8 Matrix([[1, 2], [3, 4]])
 9 matrix.shape = (2, 2)
10 matrix.size = 4
11 len(matrix) = 2
12 matrix[0][0] = 1
13 matrix.row_vector = (1, 2)
14 matrix.col_vector = (1, 3)
15 add:Matrix([[6, 8], [10, 12]])
16 subtract:Matrix([[-4, -4], [-4, -4]])
17 scalar-mul:Matrix([[2, 4], [6, 8]])
18 scalar-mul:Matrix([[2, 4], [6, 8]])
19 zero_2_3:Matrix([[0, 0, 0], [0, 0, 0]])
20 T.dot(p) = (7.5, 6)
21 T.dot(P) = Matrix([[0.0, 6.0, 7.5], [0, 0, 6]])
22 matrix.dot(matrix2) = Matrix([[19, 22], [43, 50]])
23 matrix2.dot(matrix) = Matrix([[23, 34], [31, 46]])

矩阵乘法的性质和矩阵的幂

注：由于矩阵 A乘以B 不等于 B乘以A 所以下方的公式无法得出 2AB的概念，只能将该方程拆解为AB + BA

矩阵的转置

代码实现：矩阵的转置与Numpy中矩阵的使用

1.在 Matrix.py中编写代码：返回矩阵的转置矩阵

  1 #矩阵类
  2 from playLA.Vector import Vector
  3 
  4 
  5 class Matrix:
  6     # 参数2：二维数组
  7     def __init__(self, list2d):
  8         self._values = [row[:] for row in list2d]#将数组变为矩阵
  9 
 10     #矩阵类方法:返回一个r行c列的零矩阵：参数1：为零的类对象
 11     @classmethod
 12     def zero(cls,r,c):
 13         return cls([[0] * c for _ in range(r)]) #创建一个r行c列为零的一个列表
 14 
 15     #返回矩阵的转置矩阵
 16     def T(self):
 17         #将每一行的相同位置（每一列）元素提取出来变为行组成新的矩阵
 18         return Matrix([[e for e in self.col_vector(i)]
 19                        for i in range(self.col_num())])
 20 
 21     #返回两个矩阵的加法结果
 22     def __add__(self, another):
 23         # 校验两个矩阵的形状为一致（行数、列数一致）
 24         assert self.shape() == another.shape(), 
 25             "Error in adding. Shape of matrix must be same."
 26         # 根据矩阵的加法公式：两个矩阵对应的每一行的每一个元素相加，获得新的矩阵(遍历两个矩阵对应的每一个行每个元素进行相加<第二步>，外部再遍历该矩阵的行数（循环的次数）<第一步>)
 27         return Matrix([[a+b for a,b in zip(self.row_vector(i),another.row_vector(i))]
 28                        for i in range(self.row_num())])
 29 
 30     # 返回两个矩阵的减法结果
 31     def __sub__(self, another):
 32         assert self.shape() == another.shape(), 
 33             "Error in subtracting. Shape of matrix must be same."
 34         return Matrix([[a - b for a, b in zip(self.row_vector(i), another.row_vector(i))]
 35                        for i in range(self.row_num())])
 36 
 37     #返回两个矩阵的乘法结果（矩阵乘以矩阵）
 38     def dot(self,another):
 39         if isinstance(another,Vector):#判断是否为向量：矩阵与向量的乘法
 40             assert self.col_num() == len(another),
 41                 "Error in Matrix_Vector Multiplication." #矩阵与向量的乘法错误
 42             return Vector([self.row_vector(i).dot(another) for i in range(self.row_num())])
 43         if isinstance(another,Matrix):#判断是否为矩阵：矩阵与矩阵的乘法
 44             assert self.col_num() == another.row_num(),
 45                 "Error in Matrix-Matrix Multiplication." #矩阵与矩阵的乘法错误
 46             # 将矩阵的每一行与另一矩阵的每一列进行向量间的点乘
 47             return Matrix([[self.row_vector(i).dot(another.col_vector(j)) for j in range(another.col_num())]
 48                             for i in range(self.row_num())])
 49 
 50     #返回矩阵的数量乘结果(矩阵乘以数字)：self * k
 51     def __mul__(self, k):
 52         #通过遍历每一行的每个元素e后分别乘以k<第一步>，外部再遍历该矩阵的行数（循环的次数）<第二步>
 53         return Matrix([[e * k for e in self.row_vector(i)]
 54                        for i in range(self.row_num())])
 55 
 56     # 返回矩阵的数量乘结果(数字乘以矩阵)：k * self
 57     def __rmul__(self, k):
 58         return self * k
 59 
 60     #返回数量除法的结果矩阵：self / k
 61     def __truediv__(self, k):
 62         return (1 / k) * self
 63 
 64     #返回矩阵取正的结果
 65     def __pos__(self):
 66         return 1 * self
 67 
 68     #返回矩阵取负的结果
 69     def __neg__(self):
 70         return -1 * self
 71 
 72     #返回矩阵的第index个行向量
 73     def row_vector(self,index):
 74         return Vector(self._values[index])
 75 
 76     # 返回矩阵的第index个列向量
 77     def col_vector(self, index):
 78         return Vector([row[index] for row in self._values])
 79 
 80     #返回矩阵pos位置的元素(根据元素的位置取元素值) :参数2：元组
 81     def __getitem__(self, pos):
 82         r,c = pos
 83         return self._values[r][c]
 84 
 85     #返回矩阵的元素个数
 86     def size(self):
 87         r,c = self.shape()
 88         return r*c
 89 
 90     #返回矩阵行数
 91     def row_num(self):
 92         return self.shape()[0]
 93 
 94     __len__ = row_num
 95 
 96     #返回矩阵列数
 97     def col_num(self):
 98         return self.shape()[1]
 99 
100     #返回矩阵形状：（行数，列数）
101     def shape(self):
102         return len(self._values),len(self._values[0])
103 
104     #矩阵展示
105     def __repr__(self):
106         return "Matrix({})".format(self._values)
107 
108     __str__ = __repr__

2.在main_matrix.py编写代码：返回矩阵的转置矩阵

 1 from playLA.Matrix import Matrix
 2 from playLA.Vector import Vector
 3 
 4 if __name__ == "__main__":
 5     #生成一个矩阵
 6     matrix = Matrix([[1,2],[3,4]])
 7     print(matrix)
 8     #矩阵的行数和列数（返回矩阵形状：（行数，列数））
 9     print("matrix.shape = {}".format(matrix.shape()))
10     #返回矩阵的元素个数
11     print("matrix.size = {}".format(matrix.size()))
12     print("len(matrix) = {}".format(len(matrix)))
13     #根据元素的位置取元素值
14     print("matrix[0][0] = {}".format(matrix[0,0]))
15     # 返回矩阵的第index个行向量
16     print("matrix.row_vector = {}".format(matrix.row_vector(0)))
17     # 返回矩阵的第index个列向量
18     print("matrix.col_vector = {}".format(matrix.col_vector(0)))
19 
20     # 返回两个矩阵的加法结果
21     matrix2 = Matrix([[5,6],[7,8]])
22     print("add:{}".format(matrix + matrix2))
23     # 返回两个矩阵的减法结果
24     print("subtract:{}".format(matrix - matrix2))
25     #返回矩阵的数量乘结果(矩阵乘以数字)：self * k
26     print("scalar-mul:{}".format(matrix * 2))
27     # 返回矩阵的数量乘结果(数字乘以矩阵)：k * self
28     print("scalar-mul:{}".format(2 * matrix))
29     # 零矩阵类方法:返回一个2行3列的零矩阵
30     print("zero_2_3:{}".format(Matrix.zero(2,3)))
31 
32     # 返回两个矩阵的乘法结果（矩阵乘以矩阵）
33     T = Matrix([[1.5,0],[0,2]])
34     p = Vector([5,3])
35     print("T.dot(p) = {}".format(T.dot(p)))
36     P = Matrix([[0,4,5],[0,0,3]])
37     print("T.dot(P) = {}".format(T.dot(P)))
38     print("matrix.dot(matrix2) = {}".format(matrix.dot(matrix2)))
39     print("matrix2.dot(matrix) = {}".format(matrix2.dot(matrix)))
40 
41     # 返回矩阵的转置矩阵
42     print("P.T = {}".format(P.T()))

3.运行main_matrix.py结果为：

 1 /Users/liuxiaoming/PycharmProjects/LinearAlgebra/venv/bin/python /Applications/PyCharm.app/Contents/plugins/python/helpers/pydev/pydevconsole.py --mode=client --port=50098
 2 import sys; print('Python %s on %s' % (sys.version, sys.platform))
 3 sys.path.extend(['/Users/liuxiaoming/PycharmProjects/LinearAlgebra'])
 4 PyDev console: starting.
 5 Python 3.8.2 (v3.8.2:7b3ab5921f, Feb 24 2020, 17:52:18) 
 6 [Clang 6.0 (clang-600.0.57)] on darwin
 7 >>> runfile('/Users/liuxiaoming/PycharmProjects/LinearAlgebra/main_matrix.py', wdir='/Users/liuxiaoming/PycharmProjects/LinearAlgebra')
 8 Matrix([[1, 2], [3, 4]])
 9 matrix.shape = (2, 2)
10 matrix.size = 4
11 len(matrix) = 2
12 matrix[0][0] = 1
13 matrix.row_vector = (1, 2)
14 matrix.col_vector = (1, 3)
15 add:Matrix([[6, 8], [10, 12]])
16 subtract:Matrix([[-4, -4], [-4, -4]])
17 scalar-mul:Matrix([[2, 4], [6, 8]])
18 scalar-mul:Matrix([[2, 4], [6, 8]])
19 zero_2_3:Matrix([[0, 0, 0], [0, 0, 0]])
20 T.dot(p) = (7.5, 6)
21 T.dot(P) = Matrix([[0.0, 6.0, 7.5], [0, 0, 6]])
22 matrix.dot(matrix2) = Matrix([[19, 22], [43, 50]])
23 matrix2.dot(matrix) = Matrix([[23, 34], [31, 46]])
24 P.T = Matrix([[0, 0], [4, 0], [5, 3]])

3. (矩阵再numpy中的应用)文件 main_numpy_vector.py 编写代码

 1 import numpy as np
 2 
 3 if __name__ == "__main__":
 4 
 5     #矩阵的创建
 6     A =np.array([[1,2],[3,4]])
 7     print(A)
 8 
 9     #矩阵的属性
10     print(A.shape)#矩阵的形状（行数、列数）
11     print(A.T)#矩阵的转置
12 
13     #获取矩阵的元素(从零开始计算)
14     print(A[1,1])#矩阵的某个元素
15     print(A[0])#矩阵的行向量 等价于 A([0,:])
16     print(A[:,0])#矩阵的列向量（两个索引：索引1：冒号取全部行，索引2：某一列）
17 
18     #矩阵的基本运算
19     B = np.array([[5,6],[7,8]])
20     print("A + B = {}".format(A + B))
21     print("A - b = {}".format(A - B))
22     print("10 * A = {}".format(10 * A))
23     print("A * 10 = {}".format(A * 10))
24     print(A * B)#矩阵中每个元素对应元素相乘而已（不是线性代数中的矩阵相乘）
25     print("A.dot(B) = {}".format(A.dot(B)))#矩阵之间相乘
26 
27     p = np.array([10,100])
28     print("A + p = {}".format(A + p))#此处处理为广播机制处理，也就是每一行对应的每个元素进行相加，但不是线性代数中的矩阵加法
29     print("A + 1 = {}".format(A + 1))#此处处理为广播机制处理，也就是每一行对应的每个元素进行相加，但不是线性代数中的矩阵加法
30 
31     print("A.dot(p) = {}".format(A.dot(p)))#矩阵乘以向量

4. 运行文件 main_numpy_vector.py 结果为：

 1 /Users/liuxiaoming/PycharmProjects/LinearAlgebra/venv/bin/python /Users/liuxiaoming/PycharmProjects/LinearAlgebra/playLA/main_numpy_matrix.py
 2 [[1 2]
 3  [3 4]]
 4 (2, 2)
 5 [[1 3]
 6  [2 4]]
 7 4
 8 [1 2]
 9 [1 3]
10 A + B = [[ 6  8]
11  [10 12]]
12 A - b = [[-4 -4]
13  [-4 -4]]
14 10 * A = [[10 20]
15  [30 40]]
16 A * 10 = [[10 20]
17  [30 40]]
18 [[ 5 12]
19  [21 32]]
20 A.dot(B) = [[19 22]
21  [43 50]]
22 A + p = [[ 11 102]
23  [ 13 104]]
24 A + 1 = [[2 3]
25  [4 5]]
26 A.dot(p) = [210 430]
27 
28 Process finished with exit code 0