python.最大子矩阵 numpy矩阵最大值

一.numpy中常见的数值计算方法

1.sum()函数，矩阵元素求和

import numpy as np
array_test=np.array([[1,2,3],
                     [4,5,6]])
#1.sum()函数求和
np.sum(array_test)  #计算出矩阵中所有元素的和

###指定要操作的是什么轴
np.sum(array_test,axis=0)  #按横轴求和，即将每一列相加，返回每一列的和
np.sum(array_test,axis=1)  #按纵轴求和，即将每一行相加，返回每一行的和
np.sum(array_test,axis=-1)  #按最后一轴进行求和，即按照纵轴求和

###除了可以使用np.sum()之外，还可以直接使用矩阵调用sum()函数
array_test.sum()  #等价于np.sum(array_test)
array_test.sum(axis=0)#等价于np.sum(array_test,axis=0)
array_test.sum(axis=1)#等价于np.sum(array_test,axis=1)

View Code

2.prod()，矩阵元素求积

import numpy as np
array_test=np.array([[1,2,3],
                     [4,5,6]])

#prod()函数，对矩阵元素求积
np.prod(array_test)  #对所有元素求积
np.prod(array_test,axis=0)  #指定求积的维度

##同样，prod()函数除了可以使用np.prod()之外，还可以使用array_test.prod()

3.min()，max()求矩阵的最小值和最大值

##min()函数，求矩阵最小值，max()函数，求矩阵最大值其用法和sum函数一致
import numpy as np
array_test=np.array([[1,2,3],
                     [4,5,6]])

array_test.min()
array_test.min(axis=0)
array_test.min(axis=1)
array_test.max()
array_test.max(axis=0)
array_test.maxi(axis=1)

4.argmin(),argmax()，返回矩阵最小值和最大值的索引

#argmin()，argmax() 返回矩阵最小值最大值的索引，其用法和sum()一致
import numpy as np
array_test=np.array([[100,21,345],
                     [4,5,6]])
array_test.argmin()  #注意多维矩阵是按照行来依次存放的
array_test.argmin(axis=0)#每一列最小元素的索引
array_test.argmin(axis=1)#每一行最小元素的索引
array_test.argmax()
array_test.argmax(axis=0)
array_test.argmax(axis=1)

5.mean(),std(),var() 返回矩阵的均值，标准差和方差

#mean(),平均值，std()，标准差，var()方差,用法和sum()一样
import numpy as np
array_test=np.array([[100,21,345],
                     [4,5,6]])
array_test.mean()
array_test.mean(axis=0)
array_test.mean(axis=1)


array_test.std()
array_test.std(axis=0)
array_test.std(axis=1)


array_test.var()
array_test.var(axis=0)
array_test.var(axis=1)

6.clip(a,b)，将矩阵元素的值限制在a,b之间

##clip(a,b)将矩阵的值限制在a,b之间：所有小于a的值全部变成a，所有大于b的值全部变成b
import numpy as np
array_test=np.array([[1,2,3],
                     [4,5,6]])

array_test.clip(3,4)

7.round(),四舍五入

##round()四舍五入
array_test=np.array([[1.222,0.098,32.343],[4.6543,5.8212,2.22333]])
array_test.round()

##可以通过decimals参数来指定四舍五入的位数
array_test.round(decimals=2)  #保留两位小数

 二.numpy中的排序

array_test=np.array([[9.3,4.5,6.7],
                      [4.2,2.78,9.03]])

#####1.sort()默认按行数进行升序排序，可以通过axis参数指定排序的维度，
array_test.sort()
array_test.sort(axis=0)  #按照列数进行排序

####除了使用array_test.sort()，还可以使用np.sort(array_test,axis=1),用法和sum类型

###2.np.argsort()返回排好序后的索引矩阵，即排好序后，原矩阵的每一个元素应该在什么位置上
np.argsort(array_test)  #等价于array_test.argsort()
#$array_test


###3.searchsorted(array_test,value) 返回将value中的值插入到array_test中应该插入的位置，其中array_test是已经排好序的矩阵
array_test=np.linspace(0,10,10)  #返回一个矩阵，该矩阵的元素在0到10之间，将0到10的距离分成10分，按照顺序赋给矩阵

values=np.array([2.4,8.7,6,4])
np.searchsorted(array_test,values)

###4.lexsort()指定按照某一行或某一列进行排序
array_test=[[3,2,5],[56,32,89],[34,12,42]]
#index = np.lexsort([-1*array_test[:,0],array_test[:,2]])
index=np.lexsort([-1*array_test[:,0],array_test[:,2]])# 第一列降序，第三列升序

View Code

三.矩阵形状操作

###矩阵形状操作
import numpy as np
array_test=np.array([1,2,3,4,5,6,7,8])
#1.shape查看矩阵的形状
array_test.shape
#2.改变矩阵的形状，注意，改变矩阵的形状时必须要保持矩阵元素总数相等，否则会报错
###2.1可以通过shape=a,b来将原矩阵变成指定维度的矩阵
array_test.shape=2,4  #将原来的一维矩阵变成2行四列的二维矩阵。
####2.2reshape()函数改变形状
array_test.reshape(1,8)   ##将矩阵变为一行8列矩阵

#3.给矩阵增加维度newwaxis
array_test=array_test[:,np.newaxis]  #通过定位来决定新的维度增加在什么位置
array_test=array_test[:,:,np.newaxis] 
array_test=array_test[:,np.newaxis,:,np.newaxis]  #可以增加多个维度


#4.将矩阵没有用的维度去掉，压缩维度squeeze()
array_test=array_test.squeeze()

#5.矩阵的转置transpose()和T
array_test.transpose() 
array_test.T   #两种操作等价


#6.矩阵的连接
a=np.array([[123,54,63,32],[4233,1345,78,56]])
b=np.array([[34,12,89,567],[80,78,31,45]])
###6.1 concatenate()默认将一个矩阵按行依次拼接到另外一个矩阵，可以通过axis参数指定拼接的维度
c=np.concatenate((a,b))  #将b矩阵按行拼接到矩阵a的末尾
c=np.concatenate((a,b),axis=1)  #将矩阵按列拼接

###6.2vstack(),hsatck()拼接，vstack()等价于按行拼接，hsatck()等价于按列拼接
c=np.vstack((a,b))
c=np.hstack((a,b))

#7.矩阵的拉伸，即将多维矩阵拉伸成为一维矩阵 flatten()和ravel(),这两个函数效果相同
a.flatten()
a.ravel()

View Code

 四.生成矩阵的常用方法

####生成ndarray矩阵的常用方法
import numpy as np

#1.np.array()方法将列表转为矩阵
list=[[1,2,3],[4,5,6]]
array_test=np.array(list)

#2.使用arange()函数构造矩阵，用法和range()函数相同，区别在于range()函数构造一个list，arange()构造一个矩阵
array_test=np.arange(10)  #构造一个0-9的矩阵
array_test=np.arange(20,50)#构造一个值从20到49的矩阵
array_test=np.arange(20,50,2)#以2作为步长
array_test=np.arange(20,50,2,dtype=np.float32)  #指定数据类型


#3linspace(a,b,c)生成一个有c个元素的矩阵，矩阵元素按照等差数列产生，第一个元素是a,最后一个元素是b
array_test=np.linspace(1,10,20)

#4 logspace(a,b,c,base=e)生成有c个元素的等比数列，公比是e,第一个元素是e^a,最后一个元素是e^b次方,默认e=10
array_test=np.logspace(1,10,10,base=2)  #生成2,4,8,16,32,64,128,256,512

#5.meshgrid(X,Y)生成X*Y的网格X作为横轴，Y作为纵轴
x=np.arange(10)
y=np.arange(10)
x,y=np.meshgrid(x,y)   #x是一个10x10的矩阵，每一行即为原来x的值，y是一个10x10的矩阵，每一列即为原来y的值

#6.r_[]生成行向量
array_test=np.r_[0:10:1]  #生成一个行向量，其值从0开始到9，步长为1

#7.c_[]生成列向量 
array_test=np.c_[0:10:1]  #生成一个列向量，其值从0到9，步长为1

#8.zeros()生成0矩阵
array_test=np.zeros(3)  #生成一维0向量，有3个值
array_test=np.zeros((3,3))  #生成3x3的零矩阵

#9.ones()生成1矩阵
array_test=np.ones(3) #生成一维1向量，有3个值
array_test=np.ones((3,3))  #生成3x3的1矩阵
array_test=np.ones((3,3))*8 #生成3x3的8矩阵
array_test=np.ones((3,3),dtype=np.float32)  #指定数据类型

#10.empty()生成空矩阵
array_test=np.empty(6)

#11.fill()用某一特定的值填充矩阵
array_test.fill(1)
#12.zeros_like()生成一个与已知矩阵有相同结构的0矩阵,ones_like()生成一个与已知矩阵有相同结构的1矩阵
array_test1=np.array([[1,2,3],
                     [4,5,6],
                     [7,8,9]])
array_test=np.zeros_like(array_test1)
array_test=np.ones_like(array_test1)

#13identity()生成单位矩阵
array_test=np.identity(6)
array_test

View Code

五.矩阵的常用运算操作

####矩阵运算操作
import numpy as np
#1.multiply()点乘，即对应位置的元素相乘
x=np.array([5,5])
y=np.array([2,3])
np.multiply(x,y)
#2.dot()矩阵相乘
x=np.array([[2,3],[4,5]])
y=np.array([[6,7],[8,9]])
np.dot(x,y)

#3.* 对应行的对应位置相乘，点乘
print(x*y)

#4.== 判断两个矩阵对应位置上的元素是否相等，返回bool矩阵
x==y

#logical_and()逻辑或，logical_or()逻辑与，logical_not()逻辑非,矩阵对应位置进行逻辑运算，返回bool矩阵
np.logical_and(x,y) 
np.logical_or(x,y)
np.logical_not(x)

View Code

六.numpy随机模块

#1.random.rand()生成0-1之间的随机数
np.random.rand(3)
np.random.rand(3,3)

#2.random.randint(a=0,b,size=())生成的矩阵是取值在[a,b)之间的随机整数，矩阵的形状由size参数指定 a参数默认是0，一维时size可以简写
np.random.randint(10,size=(4,5))
np.random.randint(2,45,size=(4,5))
np.random.randint(0,10,3)  #生成三个数，注意，这时参数a不可省略

#3.random.random_sample()生成一个随机数,与random.random()等价
np.random.random_sample()

#4. random.normal(mu,sigma,n)按照正态分布生成随机数,其中mu是正态分布的均值，sigma是标准差，n是要生成的随机数的个数
mu=0.1
sigmal=2
np.random.normal(mu,sigmal,10)

#set_printoptions(precision=n)设置小数的精度，保留n位小数
np.set_printoptions(precision=2)
np.random.normal(mu,sigmal,10)

#5.random.shuffle()洗牌，即打乱数组的顺序,会改变原数组的值
array_test=np.arange(10)
np.random.shuffle(array_test)

#random.seed()设置随机种子，设置随机种子后，就会生成固定的随机数
np.random.seed(100)
np.random.normal(0.1,0.01,10)

View Code

七numpy读取操作

###读写txt操作
import numpy as np
#1.loadtxt() 读取txt文件的数据,结果会转为为矩阵 
#data=np.loadtxt('test.txt')
#data = np.loadtxt('test.txt',delimiter = ',',skiprows = 1，usecols=(0,2,3)) #其中delimiter指定分隔符，skiprows跳过几行,usecols指定使用哪些列

#2.savetxt()将文件保存为txt格式
#np.savetxt('test.txt',array_test,fmt='%.2f',delimiter = ',') #fmt指定保存数据的格式，delimiter指定分隔符

###读写array结构数据
#1.save()将数组保存为ndarry结构的文件
array_test=np.array([[1,2,3],[4,5,6]])
np.save('array_test.npy',array_test)
#2.load()加载ndarry结构数据
test=np.load('array_test.npy')

array_test=np.array([1,2,3,4])
test=np.array([3,4,5,6])
#3.将多个array数据打包成一个压缩包
np.savez('array_test.npz',a=array_test,b=test)#将生成一个压缩包，压缩包里面有a,b两个文件，分别是这两个矩阵的数据
#加载压缩包
data=np.load('array_test.npz')  #data是一个字典，key值即为a,b,value值是对应的矩阵数据
data.keys()  #即a,b
data['a']
data['b']

View Code