numpy操作大全

#numpy.array基础模块介绍与使用
import numpy
import numpy as np #导入numpy模块
print(np.__version__)  #输出numpy的版本

# 将列表转换为二维数组mxn数组
L=[[1,2,3],[1,3,1]]  #先定义好list列表，将其转换为numpy.array
L=numpy.array(L)
print(L)

#array是指限定版的列表，元素类型是规定好的
import array
a=array.array("i",[i for i in range(10)])
print(a)
a[5]=100
print(a)

#numpy.array是专门为矩阵和向量设定专门的函数
n1=np.array([i for i in range(10)])
print(n1)
print(n1[5])
n1[5]=100
print(n1)
print(n1.dtype)  #输出数据的类型，默认为64位的整型数据类型
np1=np.array([1,2,3.1415926])  #根据创建隐形的转换定义数据类型，机器学习中一般都是浮点型
print(np1.dtype)

#其他创建numpy.array的方法
#创建元素均为0的数组，默认为浮点型数据
print(np.zeros(10))
print(np.zeros(10).dtype)  #默认为float浮点型数据
print(np.zeros(10,dtype=int))
#创建一个3x5的二维数组
print(np.zeros((3,5),dtype=int))
print(np.zeros(shape=(3,5),dtype=int))
#创建全是1的矩阵
print(np.ones((3,5),dtype=int))
#创建一个全是某一个特定元素的矩阵，默认为输入特定元素的数据类型
print(np.full((3,5),666))  #默认参数输入
print(np.full(fill_value=666,shape=(3,5)))   #规定元素输入

#arange()函数
print([i for i in range(0,20,2)]) #包含0，从0开始，不包含20，第三个参数为步长
print(np.arange(0,20,2))  #从0-20步长为2的数组
print(np.arange(10)) #默认开始为0，步长为1
#linspace函数
print(np.linspace(0,20,10)) #包含0和20,第三个参数的含义是包含数字的个数
print(np.linspace(0,20,11))
#random函数
print(np.random.randint(0,10)) #包含0，不包含10
print(np.random.randint(0,10,10))

#生成随机整数的二维随机矩阵
print(np.random.randint(0,10,size=(3,5))) #生成一个随机矩阵3x5，二维矩阵
print(np.random.randint(0,10,size=(3,5))) #生成一个随机矩阵3x5，二维矩阵
#指定随机种子，可以使得随机矩阵产生是一致的
np.random.seed(666)
print(np.random.randint(0,10,size=(3,5))) #生成一个随机矩阵3x5，二维矩阵
np.random.seed(666)
print(np.random.randint(0,10,size=(3,5))) #生成一个随机矩阵3x5，二维矩阵

#生成随机浮点数的二维矩阵
print(np.random.random(size=(3,5))) #生成一个随机矩阵3x5，二维矩阵,数据我0-1的随机浮点数
#生成一个均值为0，方差为1的正态分布浮点数random.normal(均值,方差,size矩阵形式)
print(np.random.normal())
print(np.random.normal(0,1,size=(3,5)))

#numpy矩阵基本属性操作
x=np.arange(15).reshape(3,5) #重新定义矩阵的形状
print(x)
print(x.ndim)  #ndim是指数组的维数，二维数组
print(x.shape)  #输出元素的形状，行和列数目
print(x.size)  #输出数组的数字数目

#numpy数据访问与切片操作
#向量数据访问，一维数组
x=np.random.random((3,5))
X=np.arange(10)
print(x)
print(x[2][2]) #输出某一行某一列的元素
print(x[2,2])  #直接使用一个方括号进行访问
#一维向量数据的切片操作
print(X[0:5]) #输出前5个元素
print(X[:5])
print(X[5:])   #输出从第5个元素开始的所有元素
print(X[::2]) #间隔2个元素输出
print(X[::-1]) #倒序输出数组

#二维数组的切片操作,一般不可以使用[a][b]双括号索引，一般需要使用[a,b]索引切片
x=np.random.randint(0,100,size=(3,5))
print(x)
print(x[:2][:3])
print(x[:2,:3])  #标准切片
print(x[::-1,::-1]) #行和列倒置
#取出第一行
print(x[0])
print(x[0,:])
print(x[0,:].ndim)
#取出第一列
print(x[:,0])
subx=x[:2,:3] #前2行前3列
print(subx)
#直接切片，修改子矩阵的元素，可以使得原来矩阵的元素改变，子矩阵与原矩阵元素保持改变一致
subx[0,0]=100
print(subx)
print(x)
#使用copy方法可以使得子矩阵与原来矩阵的改变关系脱离，子矩阵改变，原矩阵不变
subx=x[:2,:3].copy()
subx[0,0]=123456
print(subx)
print(x)
print(x.shape)

#reshape函数用来直接重新定义形状
X1=X.reshape(2,5)
print(X1)
B=X.reshape(1,10)  #一行十列的二维数组,X是一维向量
print(B.shape)
print(B)
#只想指定元素的行数reshape(行数,-1)
C=X.reshape(10,-1)  #只想指定元素的行数reshape(10,-1),则可以得到10行1列的二维数组
print(C)
#只需要指定元素的列数reshape(-1,列数)
D=X.reshape(-1,5)
print(D)

#numpy的合并和分割操作函数
#1-1合并操作函数np.concatenate([x,y]))
x=np.array([1,2,3])
y=np.array([3,2,1])
print(x)
print(y)
#列合并操作
print(np.concatenate([x,y]))
z=np.array([666,666,666])
print(np.concatenate([x,y,z]))
#特征不变，列不变，合并行即样本数目
A=np.array([[1,2,3],[4,5,6]])
B=np.array([[1,2,3],[1,2,3],[1,2,3]])
print(np.concatenate([A,B]))
#行不变，样本数目不变，特征增加，列变化
print(np.concatenate([A,A],axis=1))
#z=z.reshape(1,-1)  #将一维向量进行二维转化
print(np.concatenate([A,z.reshape(1,-1)]))
#1-2 np.vstack/hstack函数，更加方便
print(np.vstack([A,z]))#垂直方向上叠加
print(np.hstack([A,A]))#水平方向上叠加
#分割操作
#2-1一维数据分割，指定分割起始的索引号即可np.split(A,[a,b,c...])
x=np.arange(10)
print(x)
print(np.split(x,[3,7])) #将向量分割为三段，传入两位
print(np.split(x,[5]))  #分割为两段
#二维分割，矩阵分割操作np.split(A,[x]))默认是基于行维度上分割
A=np.arange(16).reshape([4,4])
print(np.split(A,[3]))  #3是指在第三行上分割
#在列的方向上进行分割需要指定axis=1，即np.split(A,[x]，axis=1))
print(np.split(A,[2],axis=1))  #在列的方向上进行分割
#2-2分割函数np.hsplit水平左右分割和np.vsplit函数垂直上下分割
left,right=np.hsplit(A,[2])
print(left,right)
print(np.vsplit(A,[3]))  #获取数据的特征值前n-1的行
X,y=np.hsplit(A,[-1])   #分割取得最后一行的目标值
print(X)
print(y)

#numpy矩阵运算
#矩阵的各种混合函数运算
n=10
L=[i for i in range(n)]
print(L)
A=[]
for i in L:
    A.append(2*i)
print(A)
#A=np.array(2*e for e in L)
L=np.array(L)  #转换为矩阵，直接可以运算
print(2*L)
X=np.arange(1,16).reshape(3,5)
print(X)
print(X+1)
print(X-1)
print(X*2)
print(X/2)
print(np.sin(X))
print(np.power(3,X))
print(np.log(X))
print(np.exp(X))
print(np.log2(X))
#矩阵之间的运算
A=np.arange(4).reshape(2,2)
B=np.full((2,2),10)
#矩阵各个位置元素之间加减乘除
print(A+B)
print(A-B)
print(A*B)
print(A/B)

#3-1 矩阵真实乘法，转置
print(A.dot(B))  #矩阵相乘
print(A.T) #矩阵转置

#3-2 向量和矩阵之间的运算
v=np.array([1,2])
print(v+A)
print(np.tile(v,(2,2)))#将v向量进行堆叠，行方向上堆叠2次，列方向堆叠2次
print(np.tile(v,(2,1))+A) #将v向量进行堆叠，行方向上堆叠2次，列方向堆叠1次,之后与A相加
print(v)
print(v*A)  #元素相乘
print(v.dot(A))  #矩阵相乘
print(A.dot(v))  #将v自动当做列向量进行使用

#3-3矩阵的逆矩阵np.linalg.inv(A)，矩阵必须为方针
print(np.linalg.inv(A))
invA=np.linalg.inv(A)
print(A.dot(invA)) #矩阵与逆矩阵的乘积为单元矩阵
#对于不是方阵的矩阵，一般求得伪逆矩阵np.linalg.pinv(x)
x=np.arange(16).reshape(2,8)
print(np.linalg.pinv(x))
print(x.dot(np.linalg.pinv(x)))

#矩阵的聚合运算与统计学参数输出，最大，最小，求和，中位数，平均值等操作
x=np.random.random(100)
print(x)
print(sum(x))
print(np.sum(x)) #效率更高，时间更短,np.max方法比较广泛更全
print(np.max(x))
print(np.min(x))
print(x.max())
print(x.min())
print(x.sum())
x=x.reshape(25,-1)
print(x)
print(np.sum(x,axis=0)) #矩阵每一列求和
print(np.sum(x,axis=1)) #矩阵每一行求和
print(np.prod(x))  #矩阵所有元素乘积
print(np.mean(x,axis=0)) #求取平均值
print(np.median(x,axis=0)) #求取中位数
X=np.array([1,1,2,2,10])
#np.percentile(X,q=50)百分占比函数输出
print(np.percentile(X,q=50)) #输出50%的元素都是小于等于的值，与中位数等效
print(np.median(X))
print(np.max(X))
print(np.percentile(X,q=100)) #与最大值等效
x=np.random.normal(0,1,100000)  #正态分布，均值为0，标准差为1的正态分布数据
print(np.mean(x)) #输出均值
print(np.std(x))  #输出标准差

#numpy输出向量或者矩阵对应的索引运算
print(np.argmin(x))  #输出最小值的索引号
print(np.min(x))
print(x[np.argmin(x)])
print(np.argmax(x)) #输出最大值的索引
#排序使用索引
x=np.arange(16)
np.random.shuffle(x)
print(x)
print(np.sort(x)) #排序之后x不变
print(x)
print(np.argsort(x)) #输出排序之后的索引
x.sort()  #排序之后x发生改变
print(x)
print((np.partition(x,3))) #5左边的数比5小，右边的数比5大
print(np.argpartition(x,3))  #输出比3小的数的索引分布，左边为小于3的索引，右边为大于3的索引
#二维矩阵的排序操作与索引操作
x=np.random.randint(1,10,size=(3,4))
print(x)
print(np.argmax(x,axis=0)) #二维矩阵最大索引输出列索引号
print(np.argsort(x,axis=1)) #按照行排序的索引
print(np.sort(x,axis=0))  #按照列排序
print(np.argsort(x,axis=0)) #按照列排序的索引
print(np.argpartition(x,2,axis=0))  #列方向上看，行方向上压缩

#numpy中fancy indexing
#一维向量索引数据
x=np.arange(16)
print(x)
print(x[3])
print(x[3:9:2]) #等步长索引
ind=[3,5,8]  #建立索引列表即可访问
print(x[ind])  #直接访问不等步长的索引号数据
ind=np.array([[0,2],[2,4]])
print(x[ind])
#二维矩阵索引
print(x.reshape(4,-1))
x=x.reshape(4,-1)
row=np.array([0,1,2])
col=np.array([1,2,2]) #行和列的索引组合，便可以直接访问元素
print(x[row,col])
print(x[:2,col])  #前2行的数据，输出感兴趣的列索引数据
print(x[0,col])
col=[True,False,True,True]
print(x[1:3,col])
print(x>3)
print(x<3)
print(x>=5) #比较运算符输出对应的false or true
print(x)
print(np.sum(x<=3))   #输出大于3的元素的个数，即将True作为1来看
print(np.count_nonzero(x<=3))  #输出小于等于3的数据个数
print(np.any(x==0))  #判断是否存在0
print(np.any(x<0))
print(np.all(x>0))  #是否都大于0
print(np.sum(x%2==0)) #求取偶数的个数
print(np.sum(x%2==0,axis=0))#看列
print(np.sum(x%2==0,axis=1))#看行
print(np.all(x>0,axis=1))
print(np.any(x>0,axis=1))
print(np.sum((x>3) & (x<6)))  #并且条件，使用位运算符可以输出，不可以使用条件语句
print(np.sum((x%2==0) | (x>10))) #或条件
print(np.sum(~(x==0)))  #非条件，统计非0的数据数目
print(x[x<5])
print(x[x%2==0])
#条件判断语句，可以输出想要输出的任何数据
print(x[x[:,3] % 3==0,:])  #输出第三索引列数据可以被3整除的所有行和列数据
#pandas模块可以方便实现表格数据的预处理操作