Python人工智能数学基础-线性代数

1.直接创建

import numpy as np

A=[[1,2,3,4],[5,6,7,8],[9,10,11,12]]
arr1=np.array(A) #将列表转化为矩阵
print("A=",A)
print("通过列表A创建的矩阵：n",arr1)
B=((1,2,3,4),(5,6,7,8),(9,10,11,12))
arr2=np.array(B) #将元组转化为矩阵
print("B=",B)
print("通过列表B创建的矩阵：n",arr2)

print("A的类型",type(A))
print("arr1的类型",type(arr1))
print("arr1的大小",arr1.shape)

2.随机创建

import numpy as np
arr1=np.random.random((2,3))#默认范围为0~1
print("创建的随机浮点数构成的2×3阶矩阵:n",arr1)
arr2=np.random.randint(3,30,size=[2,3])
print("创建的3～30(不包括30)之间的随机整数构成的2×3阶矩阵:n", arr2)

3.通过reshape函数生成

import numpy as np
A=[1,2,3,4,5,6]
B= np.array(A) #一维数组,共6个元素
C1=B.reshape(2,3) #创建2行3列矩阵
C2=B.reshape(3,2) #创建3行2列矩阵
print("矩阵B:n",B)
print("转换为2行3列矩阵C1:n",C1)
print("转换为3行2列矩阵C2: n",C2)

print("输出C1的第日行元素C1[0]: ",C1[0]) #获取矩阵的某一行
print("输出C1的前2行元素C1[0:2]: n",C1[0:2]) #获取矩阵的前几行
print("输出C2的第0行和第2行元素C2[[0,2]]: n",C2[[0,2]])#获取矩阵的某几行
print("输出C2的第1列元素C2[:,1]: ",C2[:,1]) #获取矩阵的某一列
print("输出C2的前2列元素C2[:,0:2]: n",C2[:,0:2]) #获取矩阵的前几列
print("输出C1的第0列和第2列元素C1[:,[0,2]]:n",C1[:,[0,2]])#获取矩阵的某几列
print("输出C2的第2行第1列元素C2[2,1]: "，C2[2,1]) #获取矩阵的某个元素

1.直接创建

import numpy as np
A=[[1,2,3,4,5]]
B=[[1],[2],[3],[4],[5]]
C=np.array(A) #创建行向量
D=np.array(B) #创建列向量
print("行向量C:n",C)
print("列向量D:n",D)
print("A的类型:%s，C的类型:%s"%(type(A),type(C)))
print("B的类型:%s，D的类型:%s"%(type(B),type(D)))
print("C的大小:%s，D的大小:%s"%(C.shape,D.shape))

2.随机创建

import numpy as np
arr1=np.random.random((1,3)) #默认范围为0~1
arr2=np.random.random((3,1)) #默认范围为0~1
arr3=np.random.randint(3,30,size=[1,3])
arr4=np.random.randint(3,30,size=[3,1])
print("创建的三维行向量(由随机浮点数组成):n", arr1)
print("创建的三维列向量(由随机浮点数组成）:n", arr2)
print("创建的三维行向量(由3~30(不包括30)的随机整数组成):n", arr3)
print("创建的三维列向量（由3～30(不包括30）的随机整数组成):n", arr4)

3.通过reshape函数生成

import numpy as np
A =[1,2,3,4,5]
B=np.array(A) #一维数组,共5个元素
C=B.reshape(1,5) #转换成五维行向量 C=B.reshape(1,-1)可以自动计算列数
D=B.reshape(5,1) #转换成五维列向量 D=B.reshape(-1,1)可以自动计算行数
print("一维数组B:n",B)
print("行向量C:n",C)
print("列向量D:n",D)
print("B的维数:",B.shape)
print("C的维数:",C.shape)
print("D的维数:",D.shape)

1.零矩阵

import numpy as np
arr1=np.zeros(10)
arr2=np.zeros((3,4))
arr3=np.array([np.zeros(10)])
print("通过zeros函数创建的零数组arr1:n",arr1)
print("通过zeros函数创建的零矩阵arr2:n",arr2)
print("通过zeros函数创建的零向量arr3: n",arr3)
print("arr1的形状",np.shape(arr1))
print("arr2的形状", np.shape(arr2))
print("arr3的形状", np.shape(arr3))

2.方阵

import numpy as np
arr=np.random.randint(1,16,size=[3,3])
print("元素值为1~16随机整数的三阶方阵:n",arr)

3.单位矩阵

import numpy as np
E1= np.eye(3)
E2= np.identity(3)
print("通过 eye()创建的三阶单位矩阵E1:n",E1)
print("通过identity （()创建的三阶单位矩阵E2: n",E2)

4.对角矩阵

import numpy as np
a=[1,2,3] #对角线元素
arr1=np.diag(a) #创建对角矩阵
print("创建主对角线为1,2,3的对角矩阵arr1:n", arr1)
arr2=np.diag(arr1)
print("获取矩阵arr1的对角线元素:n", arr2)
print("arr2的类型" , arr2.shape)

5.三角矩阵

import numpy as np
A=np. array([[1,2,3,2],[4,5,6,3],[7,8,9,4],[3,5,6,8]])
upper_A=np.triu(A,0)
low_A=np.tril(A,0)
print("A矩阵:(n",A)
print("A的上三角矩阵:n", upper_A)
print("A的下三角矩阵:n", low_A)

6.同型矩阵

import numpy as np
A=[3,4]
B=[4,3]
arr1=np.random.randint(3,9,size=A) #arr1为3×4阶矩阵
arr2=np.random.randint(10,30,size=A) #arr2为3×4阶矩阵
arr3=np.random.randint(50,100,size=B) #arr3为4×3阶矩阵
print("arr1=n", arr1)
print("arr2=n", arr2)
print("arr3=n", arr3)
print("arr1与arr2是否同型:",np.shape(arr1)==np.shape(arr2))
print("arr1与arr3是否同型:",np.shape(arr1)==np.shape(arr3))

7.矩阵相等

import numpy as np
A=np.array([[1,1,1],[1,2,4],[1,3,9]])
B=np.array([2,3,5])
C=np.array([[1,1,1],[1,2,4],[1,3,9]])
#利用allclose()检验矩阵是否相等,True代表相等,False代表不等
print("A和B是否相等:",np.allclose(A,B))
print("A和C是否相等:",np.allclose(A,C))

1.矩阵的加减法

import numpy as np
A=[[1,2,3],[3,2,1]]
B=[[6,8,12],[10,5,12]]
C=np.array(A)
D=np.array(B)
print("C+D=n",C+D)
print("C-D=n",C-D)

2.矩阵的数乘

import numpy as np
A=[[1,2,3],[4,5,6]]
C=np.array(A)
print("矩阵的数乘2C=n", 2*C)

3.矩阵的乘法

import numpy as np
#矩阵乘法:
A=np.array([[1,2,3],[4,5,6]])
B=np.array([[1,2],[3,4],[5,6]])
C=np.dot(A,B) #或者C=A.dot(B)
print("矩阵的乘法:n",C)
#一维数组乘法
one_vec1 = np.array([1,2,3])
one_vec2 = np.array([4,5,6])
one_multi_result = np.dot(one_vec1,one_vec2)
print("一维数组的乘法:n",one_multi_result)

import numpy as np#A.B为同型矩阵
A = np.array([[1,2,3],[4,5,6]])
B = np.array([[7,8,9],[4,7,1]])
#方法1，使用*实现对应元素的乘积
C1 =A*B
print("方法1,使用*实现对应元素的乘积:n",c1)
#方法2,使用np.multiply)函数实现对应元素的乘积
C2 = np.multiply(A,B)
print("方法2,使用np.multiply()函数实现对应元素的乘积:n",C2)

import numpy as np
#矩阵乘法:
A= np.mat([[1,2,3],[4,5,6]])
B= np.mat([[1,2],[3,4],[5,6]])
C= np.mat([[3,2,3],[5,4,6]])
#方法1,使用np.dot()函数实现矩阵相乘
D1= np.dot(A,B)
#方法2,使用*实现矩阵相乘
D2=A*B
E=np.multiply(A,C)
print("方法1,用np.dot()函数实现矩阵乘法:n",D1)
print("方法2,用*实现矩阵乘法:n",D2)
print("用np.multiply()函数实现矩阵A和C对应元素的乘积:n",E)

4.矩阵和向量的乘法

import numpy as np
#矩阵与向量的乘法;
two_matrix = np.array([[1,2,3],[4,5,6]])
vector = np.array([[7],[8],[9]])
result = np.dot(two_matrix,vector)
print("矩阵与列向量的乘法:n", result)

import numpy as np 
#矩阵与向量的乘法:
vector = np.array([[7,8]])
two_matrix =np.array([[1,2,3],[4,5,6]])
result = np.dot(vector, two_matrix)
print("行向量与矩阵的乘法:n" , result)

5.矩阵的乘方

import numpy as np
#矩阵的乘方:
A=[[1,2,3],[4,5,6],[7,8,9]]
A_array=np.array(A)
A_matrix=np.mat(A)
B=A_array.dot(A_array).dot(A_array)
C=A_matrix**3
D=A_array**3
print("array的三次方:n",B)
print("matrix的三次方:n",C)
print("array元素的三次方:n",D)

import numpy as np
A=[[2,6,10],[1,-2,9]]
B=np.array(A)
print("采用np.transpose()函数求B的转置矩阵:n",np.transpose(B))
print("采用T属性求B的转置矩阵:n",B.T)

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)

A=[1,2,3,4,5]
B=np.array(A)
C=B.T
print("B=n",B) #原一维数组 [1,2,3,4,5]
print("C=n",C) #原一维数组 [1,2,3,4,5]

import numpy as np
A =[[1,2], [2,5]]
C1=np.array(A)                 #C1= np.mat(A)结果一样
C2=np.mat(A)
C1_inverse=p.linalg.inv(C1)    #求C1的逆矩阵,不能使用I方法
C2_inverse=C2.I                #求C2的逆矩阵
print("通过inv()求出C1的逆矩阵：n",C1_inverse)
print("通过I属性求出C2的逆矩阵：n",C2_inverse)
print("C1与C1的逆相乘的结果：n",np.dot(C1, C1_inverse))

import numpy as np
B=[[1, -2, 3], [-1, 2, 1], [-3, -4, -2]]
A=np.array(B)
C=np.linalg.det(A)
print("A的行列式的值：n",C)
print("C的-1次方：n",C**(-1))
print("1/C：n",1/C)

import numpy as np
E=np.eye(4)
print("单位矩阵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("B的秩:",np.linalg.matrix_rank(B))

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("向量C1和C2的内积:n",D1)
print("向量C2和C1的内积:n",D2)

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("向量C1和C2的内积:n",D1)
print("向量C2和C1的内积:n",D2)

import numpy as np
A= np.array([1,2,3])
#A为一维数组
B= np.array([4,5,6])
#B为一维数组
print("使用dot实现A和B的内积:n",np.dot(A,B))
print("使用inner实现A和B的内积:n", np.inner(A,B))

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

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

import numpy as np
A= np.array([[1,2,1],[2,-1,3],[3,1,2]]) #系数矩阵A
B= np.array([7,7,18]).reshape(3,1) #常数项矩阵B
X= np. linalg.solve(A,B) #未知数矩阵X
#np.linalg.solve()函数要求系数矩阵A必须是非奇异矩阵。
print("利用solve()函数求出X的值:n",X)

"""
利用SymPy的solve()函数求解的结果与NumPy的solve()函数求解结果一样。
但是SymPy的solve()函数可以求解的方程组更多，
如齐次方程或者系数矩阵为奇异矩阵。
    x+2y+z-2w=0
    2x+3y-w=0
    x-y-5z+7w=0
"""
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)

以表格形式显示矩阵：

import numpy as np
import pandas as pd
A=np.array([[1,2,3,1],[4,5,6,0],[7,8,9,1]])
print(pd.DataFrame(A))

使用arange()函数创建数组:
调用形式为 arange(start, stop,step, dtype=None)，根据start 与 stop指定的范围以及step设定的步长，生成一个等差数列的一维数组。注意不包括终值。

import numpy as np
A=np.arange(0,10,1).reshape(1,-1)
print("行向量A=",A)
print("A.shape=",A.shape)
B=np.arange(0,10,1).reshape(2,-1)
print("矩阵B=n",B)
print("B.shape=",B.shape)

利用linspace()函数创建数组:
调用形式为linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)，
根据start与stop指定的范围以及数组长度num（默认是50个)，生成一个等差数列的一维数组。
endpoint用于指定数组中是否包括结束点，retstep用于返回间隔的大小，默认值是False则不返回步长。

import numpy as np
A=np.linspace(1,10,10)
B=np.linspace(1,10,10,endpoint=False)
C=np.linspace(1,10,10,endpoint=False,retstep=True)
print("A=",A)
print("B=",B)
print("C=",C)

利用logspace()函数生成等比序列:
调用形式为np.logspace(start, stop, num=50, endpoint=True, base=10, dtype=None)，根据start与stop指定的范围以及数组长度num（默认是50个)，生成一个等比数列的数组。endpoint用于指定数组中是否包括结束点。base代表指数，默认为10。

import numpy as np
A= np.logspace(0,2,5) #从10的0次方到10的二次方,有5个元素的等比数列
print("A=",A)
B= np.logspace(0,6,3,base=2)
print("B=",B) #从2的零次方到2的六次方,有3个元素的等比数列

计算数组的最大值、最小值、和、平均值、中值:
axis=0代表列方向的计算,axis=1代表行方向的计算。
中值指的是将序列按大小顺序排列后，排在中间的值，若有偶数个数，则是排在中间的两个数的平均值。

import numpy as np
A=np.array([[1,2,3],[4,5,6]])
print("矩阵A:n",A) #获取整个矩阵的最大值,结果:6
print("整个矩阵的最大值:",A.max()) #获取整个矩阵的最大值,结果:6
print("整个矩阵的最小值:",A.min()) #结果:1
print("每列的最大值:",A.max(axis=0)) #结果:[4 5 6]
print("每行的最大值:",A.max(axis=1)) #结果:[3 6]
#要想获得最大最小值元素所在的位置,可以通过argmax()函数获得
print("每行的最大值的位置:",A.argmax(axis=1)) #结果:[2 2]
print("矩阵求和:",A.sum()) #对整个矩阵求和,结果:21
print("按列求和:",A.sum(axis=0)) #对列方向求和,结果:[5 7 9]
print("按行求和:",A.sum(axis=1)) #对行方向求和,结果:[6 15]
print("整个矩阵的平均值:",A.mean()) #结果:3.5
print("每列的平均值:",A.mean(axis=0)) #结果:[2.5 3.5 4.5]
print("每行的平均值:",A.mean(axis=1)) #结果:[2. 5.]
print("所有数取中值:",np.median(A)) #对所有数取中值,结果:3.5
print("按列取中值:",np.median(A,axis=0)) #结果:[2.5 3.5 4.5]
print("按行取中值:",np.median(A,axis=1)) #结果:[2．5.]

import numpy as np
A= np. array([[4,2],[1,51]])
eig_val,eig_vex=np. linalg.eig(A)
print("A的特征值为n",eig_val)
print("A的特征向量为n",eig_vex)

import numpy as np
from numpy import linalg as la
#简化下面的写法
A=[[1,5,7,6,1],[2,1,10,4,4],[3,6,7,5,2]]
A=np.array(A)
U,s,VT = la.svd(A)
#创建一个与A大小一样的零矩阵
Sigma=np.zeros(np.shape(A))
#生成奇异值矩阵,该矩阵的对角元素为奇异值
Sigma[ :len(s), : len(s)]=np.diag(s)
print("左奇异值矩阵:n",U)
print("奇异值:",s)
print("奇异值矩阵:n",Sigma)
print("右奇异矩阵的转置:n",VT)