Pythonnumpy中矩阵的基本⽤法汇总
Python矩阵的基本⽤法
mat（）函数将⽬标数据的类型转化成矩阵（matrix）
1，mat()函数和array()函数的区别
Numpy函数库中存在两种不同的数据类型（矩阵matrix和数组array），都可以⽤于处理⾏列表⽰的数字元素，虽然他们看起来很相似，但是在这两个数据类型上执⾏相同的数学运算可能得到不同的结果，其中Numpy函数库中的matrix与MATLAB中matrices等价。
直接看⼀个例⼦：
import numpy as np
a = np.mat('1 3;5 7')
random在python中的意思b = np.mat([[1,2],[3,4]])
print(a)
print(b)
print(type(a))
print(type(b))
c = np.array([[1,3],[4,5]])
print(c)
print(type(c))
结果：
[[1 3]
[5 7]]
[[1 2]
[3 4]]
<class 'numpy.matrixlib.defmatrix.matrix'>
<class 'numpy.matrixlib.defmatrix.matrix'>
[[1 3]
[4 5]]
<class 'numpy.ndarray'>
⾸先，mat() 函数与array()函数⽣成矩阵所需的数据格式有区别，mat()函数中数据可以为字符串以分号（;）分割或者为列表形式以逗号（，）分割，⽽array()函数中数据只能为后者形式。
其次，两者的类型不同，⽤mat函数转换为矩阵后才能进⾏⼀些线性代数的操作。
from numpy import *
# 构建⼀个4*4的随机数组
array_1 = random.rand(4,4)
print(array_1)
print(type(array_1))
'''
[[0.12681561 0.26644355 0.03582107 0.71475804]
[0.01380711 0.85308305 0.37838406 0.83663897]
[0.20034209 0.5736587 0.56692541 0.64008518]
[0.97780979 0.129229 0.37688616 0.55341492]]
<class 'numpy.ndarray'>
'''
# 使⽤mat函数将数组转化为矩阵
matrix_1 = mat(array_1)
print(matrix_1)
print(type(matrix_1))
'''
[[0.32538457 0.60674013 0.68625186 0.58957989]
[0.26465813 0.93378939 0.12944934 0.95064032]
[0.65683256 0.01352025 0.11932895 0.9361348 ]
[0.11667241 0.16077876 0.50904118 0.44128675]]
<class 'numpy.matrixlib.defmatrix.matrix'>
'''
2，mat()函数创建常见的矩阵
import numpy as np
# 创建⼀个3*3的零矩阵，矩阵这⾥zeros函数的参数是⼀个tuple类型（3,3）data1 = np.s((3,3)))
print(data1)
'''
[[0. 0. 0.]
[0. 0. 0.]
[0. 0. 0.]]
'''
# 创建⼀个2*4的1矩阵，默认是浮点型的数据，如果需要时int，可以使⽤dtype=int data2 = np.s((2,4)))
print(data2)
'''
[[1. 1. 1. 1.]
[1. 1. 1. 1.]]
'''
# 这⾥使⽤numpy的random模块
# random.rand(2,2)创建的是⼀个⼆维数组，但是需要将其转化为matrix
data3 = np.mat(np.random.rand(2,2))
print(data3)
'''
[[0.62002668 0.55292404]
[0.53018371 0.1548954 ]]
'''
# ⽣成⼀个3*3的0-10之间的随机整数矩阵，如果需要指定下界可以多加⼀个参数data4 = np.mat(np.random.randint(10,size=(3,3)))
print(data4)
'''
[[0 4 1]
[7 9 9]
[9 0 4]]
'''
# 产⽣⼀个2-8之间的随机整数矩阵
data5 = np.mat(np.random.randint(2,8,size=(2,5)))
print(data5)
'''
[[4 6 3 3 4]
[4 3 3 3 6]]
'''
# 产⽣⼀个2*2的对⾓矩阵
data6 = np.(2,2,dtype=int))
print(data6)
'''
[[1 0]
[0 1]]
'''
# ⽣成⼀个对⾓线为1,2,3的对⾓矩阵
a1 = [1,2,3]
a2 = np.mat(np.diag(a1))
print(a2)
'''
[[1 0 0]
[0 2 0]
[0 0 3]]
'''
2.1，zeros
zeros函数是⽣成指定维数的全0数组
>>s(3) ###⽣成⼀个⼀维的全0数组
>>print(myMat)
>>array([0.,0.,0.])
>>s((3,2)) ####⽣成⼀个3*2的全0数组
>>print(myMat)
>>array([[0.,0.],
[0.,0.]
[0.,0.]])
2.2，ones
ones函数是⽤于⽣成⼀个全1的数组
>>s(3) ###1*3的全1数组
>>print(onesMat)
>>array([1.,1.,1.])
>>s((2,3)) ###2*3的全1数组
>>print(onesMat1)
>>array([[1.,1.,1.],[1.,1.,1.]])
2.3，eye
eye函数⽤户⽣成指定⾏数的单位矩阵
>>(4)
>>print(eyeMat)
>>array([[1.,0.,0.,0.],
[0.,1.,0.,0.],
[0.,0.,1.,0.,],
[0.,0.,0.,1.]])
2.4，full
numpy.full(shape,fill_value=num)⽤于创建⼀个⾃定义形状的数组，可以⾃⼰指定⼀个值,⽤它填满整个数组。
fill_value ⽤来填充的值，可以是数字，也可以是字符串
nd_test = np.full(shape=(2,3,4),fill_value='ai')
print(nd_test)
array([[['ai', 'ai', 'ai', 'ai'],
['ai', 'ai', 'ai', 'ai'],
['ai', 'ai', 'ai', 'ai']],
[['ai', 'ai', 'ai', 'ai'],
['ai', 'ai', 'ai', 'ai'],
['ai', 'ai', 'ai', 'ai']]], dtype='<U2')
2.5 nonzero()
nonzero函数是numpy中⽤于得到数组array中⾮零元素的位置（数组索引）函数。它的返回值是⼀个长度为a.ndim（数组a的轴数）的元组，元组的每个元素都是⼀个整数数组，其值为⾮零元素的下标在对应轴上的值。
只有a中⾮零元素才会有索引值，那些零值元素没有索引值，通过a[nonzero(a)]得到所有a中的⾮零值。
import numpy as np
SS = [0,0,0,0]
re = np.array(SS)
print(SS)
o(re))
'''
[0, 0, 0, 0]
(array([], dtype=int64),)
'''
a是⼀维数组（索引1和索引2的位置上元素的值⾮零）
>>> import numpy as np
>>> a = [0,2,3]
>>> b = np.nonzero(a)
>>> b
(array([1, 2], dtype=int64),)
>>> np.array(b).ndim
2
a是多维数组
b = array([[1,1,1,0,1,1],[1,1,1,0,1,0],[1,1,1,0,1,1]])
print(b)
c = nonzero(b)
print(c)
'''
[[1 1 1 0 1 1]
[1 1 1 0 1 0]
[1 1 1 0 1 1]]
(array([0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 2], dtype=int64),
array([0, 1, 2, 4, 5, 0, 1, 2, 4, 0, 1, 2, 4, 5], dtype=int64))
'''
解释⼀下：矩阵 b中，b[0,0] b[0,1],b[0,2],b[0,4],b[0,5]，b[1,0],b[1,1],b[1,2],b[1,4],b[2,0],b[2,1],b[2,2],b[2,4],b[2,5]元素的值⾮零。
当使⽤布尔数组直接作为下标对象护着元组下标对象中有布尔数组时，都相当于⽤nonzero()将布尔数组转换成⼀组整数数组，然后使⽤整数数组进⾏下标计算。
nonzero(a)返回数组a中值不为零的元素的下标，它的返回值是⼀个长度为a.ndim（数组a的轴数）的元组，元组的每个元素都是⼀个整数数组，其值为⾮零元素的下标在对应轴上的值。例如对于1维布尔数组b1，nonzero(b1)所得到的是⼀个长度为1的元组，它表⽰b1[0]和b1[2]的值不为0（FALSE）。
import numpy as np
b1 = np.array([True,False,True,False])
res1 = np.nonzero(b1)
print(res1)
# (array([0, 2], dtype=int64),)
对于⼆维数组b2，nonzero（b2）所得到的是⼀个长度为2的元组，它的第0个元素是数组a中值不为0的元素的第0个轴的下标，第⼀个元素则是第1轴的下标，因此从下⾯得到的结果可知b2[0,0] , n2[0,2]和b2[1,0]的值不为0：
b2 = np.array([[True,False,True],[True,False,False]])
res2 = np.nonzero(b2)
print(res2)
# (array([0, 0, 1], dtype=int64), array([0, 2, 0], dtype=int64))
当布尔数组直接做维下标时，相当于使⽤由nonzero()转换之后的元组作为下标对象：
b3 = np.arange(3*4*5).reshape(3,4,5)
res3 = o(b2)]
print(res3)
'''
[[ 0 1 2 3 4]
[10 11 12 13 14]
[20 21 22 23 24]]
'''
3，常见的矩阵运算
3.1，矩阵相乘（*）
就是矩阵的乘法操作，要求左边矩阵的列和右边矩阵的⾏数要⼀致
from numpy import *
''' 1*2 的矩阵乘以2*1 的矩阵得到1*1 的矩阵'''
a1 = mat([1,2])
print(a1)
a2 = mat([[1],[2]])
print(a2)
a3 = a1*a2
print(a3)
'''
[[1 2]]
[[1]
[2]]
[[5]]
'''
3.2，矩阵点乘（multiply）
矩阵点乘则要求矩阵必须维数相等，即M*N维矩阵乘以M*N维矩阵
''' 矩阵点乘为对应矩阵元素相乘'''
a1 = mat([1,1])
print(a1)
a2 = mat([2,2])
print(a2)
a3 = multiply(a1,a2)
print(a3)
'''
[[1 1]]
[[2 2]]
[[2 2]]
'''
a1 = mat([2,2])
a2 = a1*2
print(a2)
# [[4 4]]
3.3，矩阵求逆变换（.I）
from numpy import *
''' 矩阵求逆变换：求矩阵matrix([[0.5,0],[0,0.5]])的逆矩阵''' a1 = mat(eye(2,2)*0.5)
print(a1)
a2 = a1.I
print(a2)
'''
[[0.5 0. ]
[0. 0.5]]
[[2. 0.]
[0. 2.]]
'''
3.4，矩阵求转置（.T）
from numpy import *
'''矩阵的转置'''
a1 = mat([[1,1],[0,0]])
print(a1)
a2 = a1.T
print(a2)
'''
[[1 1]
[0 0]]
[[1 0]
[1 0]]
'''
3.5，求矩阵对应列⾏的最⼤值，最⼩值，和。计算每⼀列，⾏的和
from numpy import *
'''计算每⼀列，⾏的和'''
a1 = mat([[1,1],[2,3],[4,5]])
print(a1)
# 列和，这⾥得到的是1*2的矩阵
a2=a1.sum(axis=0)
print(a2)
'''
[[7 9]]
'''
# ⾏和，这⾥得到的是3*1的矩阵
a3=a1.sum(axis=1)
print(a3)
'''
[[2]
[5]
[9]]
'''

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。