Python常用库Numpy进行矩阵运算详解

2023-07-20 11:27:14 79

Numpy支持大量的维度数组和矩阵运算，对数组运算提供了大量的数学函数库！

Numpy比Python列表更具优势，其中一个优势便是速度。在对大型数组执行操作时，Numpy的速度比Python列表的速度快了好几百。因为Numpy数组本身能节省内存，并且Numpy在执行算术、统计和线性代数运算时采用了优化算法。

Numpy的另一个强大功能是具有可以表示向量和矩阵的多维数组数据结构。Numpy对矩阵运算进行了优化，使我们能够高效地执行线性代数运算，使其非常适合解决机器学习问题。

与Python列表相比，Numpy具有的另一个强大优势是具有大量优化的内置数学函数。这些函数使你能够非常快速地进行各种复杂的数学计算，并且用到很少代码（无需使用复杂的循环），使程序更容易读懂和理解。

注：在ndarray结构中，里面元素必须是同一类型的，如果不是，会自动的向下进行。

Numpy简单创建数组

a=[1,2,3]
b=np.array(a)
c=np.array([[0,1,2,10],
[12,13,100,101],
[102,110,112,113]],int)
print(c)
print(b)

创建数值为1的数组

Numpy.ones(参数1：shape，数组的形状；参数2：dtype，数值类型)

array_one=np.ones([10,10],dtype=np.int)
print(array_one)

创建数值为0的数组

Numpy.zeros(参数1：shape，数组的形状；参数2：dtype，数值类型)

array_zero=np.zeros([10,9],dtype=np.float)
print(array_zero)

创建指定数值的数组

Numpy.full(参数1：shape，数组的形状；参数2：constantvalue，数组填充的常数值；参数3：dtype，数值类型)

array_full=np.full((2,3),5)
print(array_full)

创建单位矩阵

Numpy.eye(参数1：N，方阵的维度)

array_eye=np.eye(5)
print(array_eye)

创建对角矩阵

Numpy.diag(参数1：v，主对角线数值，参数2：k，对角线元素)：K=0表示主对角线，k>0的值选择在主对角线之上的对角线中的元素，k<0的值选择在主对角线之下的对角线中的元素

array_diag=np.diag([10,20,30,40])
print(array_diag)

Numpy查看数组属性

数组元素个数：b.size或np.size()

数组形状：b.shape或np.shape()

数组维度：b.ndim

数组元素类型：b.dtype

#数组元素个数：3
print(b.size)
#数组形状:(3,)
print(b.shape)
#数组维度:1
print(b.ndim)
#数组元素类型:int32
print(b.dtype)

矩阵第一维的长度：shape[0]#行

矩阵第二维的长度：shape[1]#列

.......

array_rand=np.random.rand(10,10,4)
print(array_rand)
print(array_rand.ndim)
print(array_rand.shape[0])
print(array_rand.shape[1])
print(array_rand.shape[2])

Numpy创建随机数组（np.random）

均匀分布

创建指定形状的数组，数值范围在0~1之间

array_rand=np.random.rand(10,10,4)
print(array_rand)
print(array_rand.ndim)

创建指定范围内的一个数：Numpy.random.uniform(low,high,size=None)

array_uniform=np.random.uniform(0,100,size=5)
print(array_uniform)

创建指定范围的一个整数：Numpy.random.randint(low,high,size=None)

array_int=np.random.randint(0,100,size=3)
print(array_int)
print(array_int.size)

Numpy.arange()和Numpy.linspace()函数也可以均匀分布

Numpy.arange(start,stop,step)：创建一个秩为1的array，其中包含位于半开区间[start,stop)内并均匀分布的值，step表示两个相邻值之间的差。

Numpy.linspace(start,stop,N)：创建N个在闭区间[start,stop]内均匀分布的值。

X=np.arange(1,5,2,dtype=np.int)
print(X)
y=np.linspace(1,5,3)
print(y)

正态分布

创建给定均值、标准差、维度的正态分布：Numpy.random.normal(loc,scale,size)

#正态生成4行5列的二位数组
array_normal=np.random.normal(loc=1.75,scale=0.1,size=[4,5])
print(array_normal)
print(array_normal.ndim)

Numpy数组操作

数组的索引

array[start:end]

array[start:]

array[:end]

布尔型索引：array[array>10&array<20]

#截取第0至第3行，第2至第4列（从第0行第0列算起）
after_array=array_normal[:3,2:4]
print(after_array)

数组的复制

Numpy.copy(参数1：数组)：创建给定array的一个副本，还可当做方法用。

after_array=array_normal[:3,2:4].copy()
copy_array=np.copy(array_normal[:,2:4])

Numpy.sort(参数1：a，数组；参数2：axis=0/1，0表示行1表示列)：np.sort()作为函数使用时，不更改被排序的原始array；array.sort()作为方法使用时，会对原始array修改为排序后数组array

#整体排序
np.sort(array_normal)
#仅行排序
np.sort(array_normal,axis=0)
#仅列排序
np.sort(array_normal,axis=1)

数组唯一元素

Numpy.unique(参数1：a，数组；参数2：return_index=True/False，新列表元素在旧列表中的位置；参数3：return_inverse=True/False，旧列表元素在新列表中的位置；参数4：return_counts，元素的数量；参数5：axis=0/1，0表示行1表示列)：查找array中的唯一元素。

print("提取唯一元素",np.unique(array_normal))
print("提取唯一元素",np.unique(array_normal,return_index=True))
print("提取唯一元素",np.unique(array_normal,return_counts=True))
print("提取唯一元素",np.unique(array_normal,return_index=True,return_inverse=True,axis=0))

数组的改变

数组转置

array_normal.T

reshape()：把指定的数组改变形状，但是元素个数不变；有返回值，即不对原始多维数组进行修改

c=np.array([[[0,1,2],
[10,12,13]],
[[100,101,102],
[110,112,113]]])
"""
[[[01]
[210]]

[[1213]
[100101]]

[[102110]
[112113]]]
"""
print(c.reshape(3,2,2))
"""
[[01210]
[1213100101]
[102110112113]]
"""
#某一维指定为-1时，自动计算维度
print(c.reshape(3,-1))
"""[[[01]
[210]
[1213]]

[[100101]
[102110]
[112113]]]"""
print(c.reshape(2,-1,2))

resize()：把指定的数组改变形状，但是元素个数可变，不足补0；无返回值，即对原始多维数组进行修改

a=np.array([[[0,1,2],
[10,12,13]],
[[100,101,102],
[110,112,113]]])
b=np.array([[[0,1,2],
[10,12,13]],
[[100,101,102],
[110,112,113]]])
'''[[0]
[1]
[2]]'''
a.resize((3,1))
'''[[0121012]
[13100101102110]
[112113000]]'''
b.resize((3,5))
print(a)
print(b)

*Numpy计算

条件运算

Numpy.where(condition,x,y)：三目运算满足condition，为x；不满足condition，则为y

score=np.array([[80,88],[82,81],[84,75],[86,83],[75,81]])
#如果数值小于80，替换为0，如果大于等于80，替换为90
re_score=np.where(score<80,0,90)
print(re_score)

]统计运算

指定轴最大值：amax(参数1：数组；参数2：axis=0/1，0表示行1表示列)

#求整个矩阵的最大值
result=np.amax(score)
print(result)
#求每一列的最大值（0表示行）
result=np.amax(score,axis=0)
print(result)
#求每一行的最大值（1表示列）
result=np.amax(score,axis=1)
print(result)

指定轴最小值：amin(参数1：数组；参数2：axis=0/1，0表示行1表示列)

#求整个矩阵的最小值
result=np.amin(score)
print(result)
#求每一列的最小值（0表示行）
result=np.amin(score,axis=0)
print(result)
#求每一行的最小值（1表示列）
result=np.amin(score,axis=1)
print(result)

指定轴平均值：mean(参数1：数组；参数2：axis=0/1，0表示行1表示列；参数3：dtype，输出数据类型)

#求整个矩阵的平均值
result=np.mean(score,dtype=np.int)
print(result)
#求每一列的平均值（0表示行）
result=np.mean(score,axis=0)
print(result)
#求每一行的平均值（1表示列）
result=np.mean(score,axis=1)
print(result)

指定轴方差：std(参数1：数组；参数2：axis=0/1，0表示行1表示列；参数3：dtype，输出数据类型)

#求整个矩阵的方差
result=np.std(score)
print(result)
#求每一列的方差（0表示列）
result=np.std(score,axis=0)
print(result)
#求每一行的方差（1表示行）
result=np.std(score,axis=1)
print(result)

类似的，求和：Numpy.sum()，求中值：Numpy.median

数组运算

数组与数的运算（加、减、乘、除、取整、取模）

#循环数组行和列，每一个数值都加5
score[:,:]=score[:,:]+5
print(score)
#循环数组行和列，每一个数值都减5
score[:,:]=score[:,:]-5
print(score)
#循环数组行和列，每一个数值都乘以5
score[:,:]=score[:,:]*5
print(score)
#循环数组行和列，每一个数值都除以5
score[:,:]=score[:,:]/5
print(score)
#循环数组行和列，每一个数值除以5取整
score[:,:]=score[:,:]//5
print(score)
#循环数组行和列，每一个数值除以5取模
score[:,:]=score[:,:]%5
print(score)

数组间运算（加、减、乘、除），前提是两个数组的shape一样

加：“+”或者np.add(a,b)减：“-”或者np.subtract(a,b)

乘：“*”或者np.multiply(a,b)除：“/”或者np.divide(a,b)

c=score+score
d=score-score
e=score*score
#分母数组保证每个数值不能为0
b=score/score

Numpy.intersect1d(参数1：数组a；参数2：数组b)：查找两个数组中的相同元素

Numpy.setdiff1d(参数1：数组a；参数2：数组b)：查找在数组a中不在数组b中的元素

Numpy.union1d(参数1：数组a；参数2：数组b)：查找两个数组的并集元素

矩阵运算（一种特殊的二维数组）

计算规则

（M行，N列）*（N行，Z列）=（M行，Z列）

st_score=np.array([[80,88],[82,81],[84,75],[86,83],[75,81]])
#平时成绩占40%期末成绩占60%,计算结果
q=np.array([[0.4],[0.6]])
result=np.dot(st_score,q)
print(result)

矩阵拼接

矩阵垂直拼接（前提两个两个矩阵列数相同，行数随意）：vstack(参数：tuple)

v1=[[0,1,2,3,4,5],
[6,7,8,9,10,11]]
v2=[[12,13,14,15,16,17],
[18,19,20,21,22,23],
[18,19,20,21,22,23]]
result=np.vstack((v1,v2))
print(result)

矩阵水平拼接（前提两个两个矩阵行数相同，列数随意）：hstack(参数：tuple)

v1=[[0,1,2,3,4,5],
[6,7,8,9,10,11]]
v2=[[12,13,14,15,16,17],
[18,19,20,21,22,23]]
result=np.hstack((v1,v2))
print(result)

矩阵删除：Numpy.delete(参数1：a，数组；参数2：elements，删除的对象；参数3：axis=0/1)

OriginalY=np.array([[1,2,3],
[4,5,6],
[7,8,9]])
print(np.delete(OriginalY,[0,2]))
print(np.delete(OriginalY,[0,2],axis=0))
print(np.delete(OriginalY,[0,2],axis=1))

矩阵添加：Numpy.append(参数1：array，数组；参数2：elements，添加元素；参数3：axis=0/1)

OriginalY=np.array([[1,2,3],
[4,5,6],
[7,8,9]])
#末尾添加元素
print(np.append(OriginalY,[0,2]))
#最后一行添加一行
print(np.append(OriginalY,[[0,2,11]],axis=0))
#最后一列添加一列（注意添加元素格式）
print(np.append(OriginalY,[[0],[2],[11]],axis=1))

矩阵插入：Numpy.insert(参数1：array，数组；参数2：index，插入位置索引；参数3：elements，添加元素；参数4：axis=0/1)

OriginalY=np.array([[1,2,3],
[4,5,6],
[7,8,9]])
print(np.insert(OriginalY,1,[11,12,10]))
print(np.insert(OriginalY,1,[[11,12,10]],axis=0))
#在列索引1的位置插入（注意元素格式，跟添加格式不同）
print(np.insert(OriginalY,1,[[11,12,10]],axis=1))

文件加载

np.loadtxt(fname,dtype,comments='#',delimiter=None,skiprows=0,usecols=None)

fname:读取的文件、文件名

dtype：数据类型

comments：注释

delimiter：分隔符，默认是空格

skiprows：跳过前几行读取，默认是0

usecols：读取哪些列，usecols=（1，2，5）读取第1,2,5列，默认所有列

到此这篇关于Python常用库Numpy进行矩阵运算详解的文章就介绍到这了,更多相关PythonNumpy矩阵运算内容请搜索毛票票以前的文章或继续浏览下面的相关文章希望大家以后多多支持毛票票！

Python常用库Numpy进行矩阵运算详解

热门推荐

随机推荐