Numpy杂记

基础操作

#创建多维数组
m=np.array([np.arange(2),np.arange(2)])
out:[[0 1]
     [0 1]]
m=np.array([[1,2],[3,4]])
out:[[1 2]
     [3 4]]
#选取数组元素
m=np.array([[1,2],[3,4]])
m[0,1]
out:2
#数组的形式
m=np.array([[1,2],[3,4]])
out:(2, 2) 4    #2X2的  总共4个数
#改变数组的维度
m=np.arange(24).reshape(2,3,4)
out:[[[ 0  1  2  3]
      [ 4  5  6  7]
      [ 8  9 10 11]]

      [[12 13 14 15]
       [16 17 18 19]
       [20 21 22 23]]]  #这是一个2X3X4的三维数组
#多维数组的切片（返回的都是数组或多维数组）
m[:,0,0]       #全取的用冒号代替
out:[ 0 12]    
m[0,:,:]
m[0,...]       #二者等价，省略号可以代替多个冒号
out:[[ 0  1  2  3]
     [ 4  5  6  7]
     [ 8  9 10 11]]
m[0,0,::2]     #数组切片中可以再次嵌入切片
out:[0 2]
m[:,1,]      #二者等价，不写等于全选。（但m[:,,1]和m[,1,1]不行，必须依次按顺序）
m[:,1]      
out:[[ 4  5  6  7]
     [16 17 18 19]]
m[0,:,-1]   #反选同样可以
out:[ 3  7 11]
m[::-1]      #理解成对第一维度进行了处理。
out:[[[12 13 14 15]
     [16 17 18 19]
     [20 21 22 23]]

    [[ 0  1  2  3]
     [ 4  5  6  7]
     [ 8  9 10 11]]]
#铺平操作
m.ravel()
m.flatten()  #二者效果等价。不同的是faltten函数会请求分配内存来保存结果。
out:[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]
#改变数组维度
m=np.arange(24).reshape(2,3,4)
m.shape=(4,6)
print(m)
out:[[ 0  1  2  3  4  5]
     [ 6  7  8  9 10 11]
     [12 13 14 15 16 17]
     [18 19 20 21 22 23]]
#转置
m=np.arange(24).reshape(4,6)
m.transpose()
m.T      #二者效果等价
out:[[ 0  6 12 18]
     [ 1  7 13 19]
     [ 2  8 14 20]
     [ 3  9 15 21]
     [ 4 10 16 22]
     [ 5 11 17 23]]
#resize和reshape功能一样，但resize会直接修改所操作的数组
m.resize((2,12)) 
print(m)     
out:[[ 0  1  2  3  4  5  6  7  8  9 10 11]
     [12 13 14 15 16 17 18 19 20 21 22 23]]
#数组的合并
m=np.arange(9).reshape(3,3)
n=2*m
print(m,'\n',n)
out:[[0 1 2]
     [3 4 5]
     [6 7 8]] 
    [[ 0  2  4]
     [ 6  8 10]
     [12 14 16]]
#水平组合
np.hstack((m,n))    
np.concatenate((m,n),axis=1)
out:[[ 0  1  2  0  2  4] 
     [ 3  4  5  6  8 10]
     [ 6  7  8 12 14 16]]
#垂直组合
np.vstack((m,n))
np.concatenate((m,n),axis=0)
out:[[ 0  1  2]
     [ 3  4  5]
     [ 6  7  8]
     [ 0  2  4]
     [ 6  8 10]
     [12 14 16]]
#深度组合
dstack((m,n))
out:[[[ 0  0]
      [ 1  2]
      [ 2  4]]

     [[ 3  6]
      [ 4  8]
      [ 5 10]]

     [[ 6 12]
      [ 7 14]
      [ 8 16]]]
#列组合
m=np.arange(2)    #对于一维数组安列组合
n=2*m
out:[[0 0]
     [1 2]]
m=np.arange(9).reshape(3,3)
n=2*m
np.column_stack((m,n))   #对于二维数组来说效果和hstack相同
out:[[ 0  1  2  0  2  4]
     [ 3  4  5  6  8 10]
     [ 6  7  8 12 14 16]]
#行组合
m=np.arange(2)    #对于一维数组安行组合
n=2*m
np.row_stack((m,n))
out:[[0 1]
     [0 2]]
m=np.arange(9).reshape(3,3)
n=2*m
np.column_stack((m,n))   #对于二维数组来说效果和vstack相同
out:[[ 0  1  2]
     [ 3  4  5]
     [ 6  7  8]
     [ 0  2  4]
     [ 6  8 10]
     [12 14 16]]

#数组的分割
a=np.array([[0,1,2],
            [3,4,5],
            [6,7,8]])
a=np.hsplit(a,3) #沿水平方向分割成3个大小相同的子数组
print(a) 
out：[array([[0],
            [3],
            [6]]), 
      array([[1],
             [4],
             [7]]),
      array([[2],
            [5],
            [8]])]
#split(a,3,axis=1)可以达到相同的效果
#np.vsplit(a,3)的效果是沿着垂直方向分割
#np.dsplit()将会沿深度方向进行分割

#数组的属性
ndim  #数组的维数
size  #数组元素的个数
itemsize #数组中元素在内存中占的字节数
nbytes #整个数组所占用的储存空间。
       #值是itemsize和size的乘积。
T   #转置，和transpose函数效果一样
real  #给出复数的实部，若只有实部，就输出原数组
imag  #给出复数的虚部
flat #返回一个np.flatiter对象，这是获得flatiter对象的唯一方式。
#我们无法访问flatiter对象的构造函数，这个“扁平迭代器“可以让我们像遍历一维数组一样去遍历任意多维数组。

b=np.arange(4).reshape(2,2)
f=b.flat
for i in f:
    print(i)
out: 0
     1
     2
     3
#还可以直接获取数组元素
b.flat[2]   #获取第二个
out: 2
#同样的道理获取多个
b.flat[1,3] #获取第一个和第三个
out: array([1,3])
#对flat赋值会导致整个数组被覆盖
b.flat=7
b
out: array([[7,7],
		   [7,7]])
b.flat[1,3]=1 #把第一个和第三个就赋成1了
#这个属性理解成把多维数组铺平成一个list就好

#数组转换成list
b.tolist()
#转换数据类型
b.astype(int)

常用函数

a=np.eye(2) #创建二维单位数组
np.savetxt('x.txt',a) #将数组a存储到文件中
np.mean(c) #求均值
np.average(c,weights=t) #加权平均。t为一个array表权重
np.max(h) #最大值
np.min(l) #最小值
np.ptp(h) #返回取值范围，即最大值与最小值的差
np.median(c) #中位数（若是偶数个，就是中间两个的均值）
np.msort(c)  #返回排序后的array，每列从小到大排。
np.sort(c)  #按行排序
np.var(c)  #方差
np.diff(c) #后一个与前一个元素之差构成的array
b=np.array([[7,8,9],
            [3,4,6],
            [1,1,9]])
a=np.diff(b)
out:   [[1 1]
        [1 2]
        [0 8]]
np.log(c)  #获得对数
np.where() #根据条件返回索引
np.take() #根据索引返回值
np.split(a,2) #将a分割，没两个数组一分
np.zeros() #创建零矩阵
np.argmin() #返回最小元素的索引
np.argmax() #返回最大元素的索引
np.maximum(a,b) #对比a、b两个数组的每个值，返回由较大值组成的新数组
np.minimum() #功能与上一个对照
np.convol(weights,c) #计算数组c与指定权重的卷积
np.exp() #以数组为指数，计算e的次方值
np.linspace(-1,0,5) #返回位于-1到0的5个均匀分布的数值的数组
b.fill(0) #用0填充整个数组b
numpy.linalg.inv(a) #求逆
numpy.linalg.lstsq() #最小二乘法
np.intersectld(a,b) #返回a、b公共元素组成的数组
a.clip(x,y) #a数组中所有比x小的变成x，比y大的变成y
a.compress(a>2) #返回a中满足条件的元素组成的数组
b.prod() #计算b中所有元素的乘积
b.cumprod() #计算b中元素的累积乘积（第一个、前俩乘、前仨乘。。。）