python进行矩阵计算可以用两个模块：numpy和sympy
1、Numpy
创建矩阵
from numpy import *
a1=array([1,2,3]) #数组
a2=mat([1,2,3]) #矩阵
a3=mat(a1)
b=matrix([1,2,3]) #matrix是矩阵的意思
print(a1)
print(a2)
print(a3)
print(shape(a1),shape(a2),shape(a3))
print(shape(b)) #shape——打印矩阵的行列数
结果：
[1 2 3]
[[1 2 3]]
[[1 2 3]]
(3,) (1, 3) (1, 3)
(1, 3)
from numpy import *
data1=mat(zeros((3,3))) #创建一个3*3的零矩阵，矩阵这里zeros函数的参数是一个tuple类型(3,3)
print(data1)
data2=mat(ones((2,4))) #创建一个2*4的1矩阵，默认是浮点型的数据，如果需要时int类型，可以使用dtype=int
print(data2)
data3=mat(random.rand(2,2)) #这里的random模块使用的是numpy中的random模块，random.rand(2,2)创建的是一个二维数组，需要将其转换成#matrix
print(data3)
data4=mat(random.randint(10,size=(3,3))) #生成一个3*3的0-10之间的随机整数矩阵，如果需要指定下界则可以多加一个参数
print(data4)
data5=mat(random.randint(2,8,size=(2,5))) #产生一个2-8之间的随机整数矩阵
print(data5)
data6=mat(eye(2,2,dtype=int)) #产生一个2*2的对角矩阵，其实是单位阵
print(data6)
data7=mat(diag([1,2,3])) #生成一个对角线为1、2、3的对角矩阵
print(data7)
结果：
[[0. 0. 0.]
[0. 0. 0.]
[0. 0. 0.]]
[[1. 1. 1. 1.]
[1. 1. 1. 1.]]
[[0.89395956 0.8750971 ]
[0.86046462 0.998561 ]]
[[1 3 2]
[1 4 6]
[1 4 5]]
[[4 5 7 7 7]
[4 2 6 2 4]]
[[1 0]
[0 1]]
[[1 0 0]
[0 2 0]
[0 0 3]]
将矩阵分为上三角矩阵、下三角矩阵和对角矩阵
矩阵A = 上三角矩阵+对角矩阵+下三角矩阵
triu
Upper triangle of an array.
tril
Lower triangle of an array.
diagonal
Return specified diagonals.
A = mat([[2, 1, 1], [1, 2, 1], [1, 1, 2]])
L = tril(A, -1) #下三角矩阵
U = triu(A,1) #上三角矩阵
D = diag(diag(A)) #对角矩阵
print(A)
print(L)
print(U)
print(D)
结果：
[[2 1 1]
[1 2 1]
[1 1 2]]
[[0 0 0]
[1 0 0]
[1 1 0]]
[[0 1 1]
[0 0 1]
[0 0 0]]
[[2 0 0]
[0 2 0]
[0 0 2]]
注意：
from numpy import *
A = mat([[2, 1, 1], [1, 2, 1], [1, 1, 2]])
print(diag(A))
print(diag(diag(A)))
结果：
[2 2 2]
[[2 0 0]
[0 2 0]
[0 0 2]]
矩阵对角线求和
trace
Sum along diagonals.
from numpy import *
A = mat([[2, 1, 1], [1, 2, 1], [1, 1, 2]])
print(trace(A))
结果：
6
操作矩阵之前需要引入numpy的linalg模块
numpy.linalg模块包含线性代数的函数。使用这个模块，可以计算逆矩阵、求特征值、解线性方程组以及求解行列式等
矩阵的逆矩阵
逆矩阵：inv()
from numpy import *
# numpy.linalg模块包含线性代数的函数。使用这个模块，可以计算逆矩阵、求特征值、解线性方程组以及求解行列式等
from numpy.linalg import *
A = mat([[1,2,3],[4,6,5],[9,8,7]])
print(inv(A))
print(A.I)
结果：
[[-0.06666667 -0.33333333 0.26666667]
[-0.56666667 0.66666667 -0.23333333]
[ 0.73333333 -0.33333333 0.06666667]]
[[-0.06666667 -0.33333333 0.26666667]
[-0.56666667 0.66666667 -0.23333333]
[ 0.73333333 -0.33333333 0.06666667]]
如果出现下面的错误提醒：
numpy.linalg.LinAlgError: Singular matrix
就表明这个矩阵没有逆矩阵
singular matrix ： 不可逆矩阵；奇异矩阵
矩阵的转置
A——矩阵
矩阵的转置：A.transpose()
from numpy import *
A = mat([[1,2,3],[4,5,6],[7,8,9]])
print(A.transpose())
print(A.T)
结果：
[[1 4 7]
[2 5 8]
[3 6 9]]
[[1 4 7]
[2 5 8]
[3 6 9]]
矩阵的行列式
A——矩阵
矩阵的行列式：det(A)
from numpy import *
# numpy.linalg模块包含线性代数的函数。使用这个模块，可以计算逆矩阵、求特征值、解线性方程组以及求解行列式等
from numpy.linalg import *
A = mat([[1,2,3],[4,5,6],[7,8,9]])
print(det(A))
B = mat([[1,2],[5,4]])
print(det(B))
结果：
0.0
-6.0
矩阵的特征向量和特征值
**特征值（eigenvalue）**即方程 Ax = ax 的根，是一个标量。其中，A 是一个二维矩阵，x 是一个一维向量。
**特征向量（eigenvector）**是关于特征值的向量
numpy.linalg模块中，eigvals函数可以计算矩阵的特征值，而eig函数可以返回一个包含特征值和对应的特征向量的元组
A——矩阵
矩阵的特征值：eigvals(A)
矩阵的特征向量和特征值：eig(A)
from numpy import *
# numpy.linalg模块包含线性代数的函数。使用这个模块，可以计算逆矩阵、求特征值、解线性方程组以及求解行列式等
from numpy.linalg import *
A = mat([[1,2,3],[4,5,6],[7,8,9]])
print(eigvals(A)) #特征值
print(eig(A)) #特征值和特征向量
结果：
[ 1.61168440e+01 -1.11684397e+00 -1.30367773e-15]
(array([ 1.61168440e+01, -1.11684397e+00, -1.30367773e-15]), matrix([[-0.23197069, -0.78583024, 0.40824829],
[-0.52532209, -0.08675134, -0.81649658],
[-0.8186735 , 0.61232756, 0.40824829]]))
矩阵相乘
矩阵相乘也就是矩阵的乘法操作要求左矩阵的列和右矩阵的行数要一致起来
m×n的矩阵与n×k的矩阵相乘为m×k的矩阵
可以用*或者dot()函数
from numpy import *
A = mat([[1,1,1],[2,2,2]])
B = mat([[3,3],[4,4],[5,5]])
print(A*B)
print(dot(A,B))
结果：
[[12 12]
[24 24]]
[[12 12]
[24 24]]
矩阵点乘
矩阵的点乘则要求矩阵必须维数相等，即MxN维矩阵乘以MxN维矩阵
矩阵点乘——multiply()
from numpy import *
A = mat([[1,1,1],[2,2,2]])
B = mat([[3,3,3],[4,4,4]])
print(multiply(A,B))
结果：
[[3 3 3]
[8 8 8]]
矩阵与矩阵外的常数相乘
from numpy import *
A = mat([[1,1,1],[2,2,2]])
print(A*2)
结果：
[[2 2 2]
[4 4 4]]
计算矩阵对应行列的最大、最小值、和
计算每一列、行的和：
from numpy import *
A = mat([[1,1],[2,3],[4,2]])
print(A.sum(axis=0)) #列和，这里得到的是1*2的矩阵
print(A.sum(axis=1)) #行和，这里得到的是3*1的矩阵
print(sum(A[1,:])) #计算第二行所有列的和（实际上是把第一行的数值加了起来），这里得到的是一个数值
print(A[1,:]) #这样的写法跟列表一样，行数是从0开始，0就是第一行
结果：
[[7 6]]
[[2]
[5]
[6]]
5
[[2 3]]
计算最大、最小值和索引
from numpy import *
import numpy as np
A = mat([[1,1],[2,3],[4,2]])
print(A.max()) #计算A矩阵中所有元素的最大值,这里得到的结果是一个数值
print(max(A[:,1])) #计算第二列的最大值，这里得到的是一个1*1的矩阵
print(A[1,:].max()) #计算第二行的最大值，这里得到的是一个一个数值
print(np.max(A,0)) #计算所有列的最大值，这里使用的是numpy中的max函数
print(np.max(A,1)) #计算所有行的最大值，这里得到是一个矩阵
print(np.argmax(A,0)) #计算所有列的最大值对应在该列中的索引
print(np.argmax(A[1,:])) #计算第二行中最大值对应在该行的索引
结果：
4
[[3]]
3
[[4 3]]
[[1]
[3]
[4]]
[[2 1]]
1
矩阵的分隔和合并
矩阵的分隔，同列表和数组的分隔一致。
from numpy import *
A = mat([[1,2,3],[4,5,6],[7,8,9]])
B = A[1:,1:] #分割出第二行以后的行和第二列以后的列的所有元素
print(A)
print(B)
结果：
[[1 2 3]
[4 5 6]
[7 8 9]]
[[5 6]
[8 9]]
矩阵的合并
vstack——列合并
hstack——行合并
from numpy import *
import numpy as np
# numpy.linalg模块包含线性代数的函数。使用这个模块，可以计算逆矩阵、求特征值、解线性方程组以及求解行列式等
from numpy.linalg import *
A = mat(ones((2,2)))
B = mat(eye(2))
C = vstack((A,B)) #按列合并，即增加行数
D = hstack((A,B)) #按行合并，即行数不变，扩展列数
print(A)
print(B)
print(C)
print(D)
结果：
[[1. 1.]
[1. 1.]]
[[1. 0.]
[0. 1.]]
[[1. 1.]
[1. 1.]
[1. 0.]
[0. 1.]]
[[1. 1. 1. 0.]
[1. 1. 0. 1.]]
矩阵、列表、数组的转换
列表可以修改，并且列表中元素可以使不同类型的数据，如下：
l1=[[1],'hello',3]
而numpy中数组，同一个数组中所有元素必须为同一个类型，有几个常见的属性：
from numpy import *
A = array([[1,2,3,4],[4,5,6,7],[6,7,8,9]])
m,n=A.shape
print(A.ndim)
print(m,n)
print(A.size) #元素总个数
print(A.dtype) #元素的类型
结果：
2
3 4
12
int32
numpy中的矩阵也有与数组常见的几个属性。
它们之间的转换：
from numpy import *
list = [[1,2],[3,2],[5,2]] #列表
a1 = array(list) #将列表转换成二维数组
a2 = mat(list) #将列表转化成矩阵
a3 = array(a2) #将矩阵转换成数组
a4 = a2.getA() #将矩阵转换成数组
a5 = a2.tolist() #将矩阵转换成列表
a6 = a1.tolist() #将数组转换成列表
print(list)
print(a1)
print(a2)
print(a3)
print(a4)
print(a5)
print(a6)
结果：
[[1, 2], [3, 2], [5, 2]]
[[1 2]
[3 2]
[5 2]]
[[1 2]
[3 2]
[5 2]]
[[1 2]
[3 2]
[5 2]]
[[1 2]
[3 2]
[5 2]]
[[1, 2], [3, 2], [5, 2]]
[[1, 2], [3, 2], [5, 2]]
这里可以发现三者之间的转换是非常简单的，这里需要注意的是，当列表是一维的时候，将它转换成数组和矩阵后，再通过tolist()转换成列表是不相同的，需要做一些小小的修改。如下：
from numpy import *
a1=[1,2,3] #列表
a2=array(a1) #数组
a3=mat(a1)
a4=a2.tolist() #数组转列表
a5=a3.tolist() #矩阵转列表
a6=(a4==a5)
a7=(a4 == a5[0])
print(a1)
print(a2)
print(a3)
print(a4)
print(a5)
print(a6)
print(a7)
矩阵转换成数值，存在以下一种情况：
from numpy import *
dataMat=mat([[1,2,3],[4,5,6]])
val = dataMat[0, 0] # 这个时候获取的就是矩阵的元素的数值，而不再是矩阵的类型
val2 = dataMat[1,2]
print(dataMat)
print(val)
print(val2)
结果：
[[1 2 3]
[4 5 6]]
1
6