Python Numpy数据分析中常用方法

野性酷女 2021-06-24 14:37 513阅读 0赞

## **一、多维的表示** ##

Numpy用列表表示多维矩阵：  
第一维，维数大小为4：  
% = \[ & & & &\] //&为标量，%表示一个维数大小为4的一维向量  
第二维，维数大小为3：  
@ = \[% % %\] //@表示由三个一维向量%组成的3\*4的二维矩阵  
上述二者添加变成：  
@ = \[\[& & & &\] \[& & & &\] \[& & & &\]\]

三维列表如下：
    >>>  b = numpy.arange(24).reshape(2,3,4)
    >>>print b
    [[[ 0  1  2  3]
      [ 4  5  6  7]
      [ 8  9 10 11]]
    
     [[12 13 14 15]
      [16 17 18 19]
      [20 21 22 23]]]
    >>> b[1,2,1]
    21

通过索引查值可以理解为：从外往里找，  
索引为1找到值：

[[12 13 14 15]
      [16 17 18 19]
      [20 21 22 23]]

索引为2找到值：

[20 21 22 23]

索引为1找到值：

**索引理解：**

:表示当前维的所有索引值都取
    import numpy as np
    t = np.array(
      [
          [
              [
               [1,2,3],  
               [4,5,6]
              ],  
              [
               [7,8,9],  
               [10,11,12]
              ],  
              [
               [13,14,15],  
               [16,17,18]
              ]
          ],  
          [
              [
               [19,20,21],  
               [22,23,24]
              ],  
              [
               [25,26,27],  
               [28,29,30]
              ],  
              [
               [31,32,33],
               [34,35,36]
              ]
          ]
      ])

print(t[0,:,:,:])
    [[[ 1  2  3]
      [ 4  5  6]]
    
     [[ 7  8  9]
      [10 11 12]]
    
     [[13 14 15]
      [16 17 18]]]

print(t[:,0,:,:])
    [[[ 1  2  3]
      [ 4  5  6]]
    
     [[19 20 21]
      [22 23 24]]]

print(t[:,:,0,:])
    [[[ 1  2  3]
      [ 7  8  9]
      [13 14 15]]
    
     [[19 20 21]
      [25 26 27]
      [31 32 33]]]

print(t[:,:,:,0])
    [[[ 1  4]
      [ 7 10]
      [13 16]]
    
     [[19 22]
      [25 28]
      [31 34]]]

## **二、生成数组** ##

基本数据类型：  
bool 用一个字节存储的布尔类型（True或False）  
inti 由所在平台决定其大小的整数（一般为int32或int64）  
int8　　一个字节大小，-128 至 127  
int16　　整数，-32768 至 32767  
int32　　 整数，-2 ＾31 至 2 ＾3１ -1  
int64　　整数，-2 ＾ 63 至 2 ＾ 63 - 1  
uint8　　无符号整数，0 至 255  
uint16 　　无符号整数，0 至 65535  
uint32　　无符号整数，0 至 2＾ 32 - 1  
uint64 　　无符号整数，0 至 2 ＾ 64 - 1  
float16　　半精度浮点数：16位，正负号1位，指数5位，精度10位  
float32 　　单精度浮点数：32位，正负号1位，指数8位，精度23位  
float64或float　　双精度浮点数：64位，正负号1位，指数11位，精度52位  
complex64　　复数，分别用两个32位浮点数表示实部和虚部  
complex128或complex　　 复数，分别用两个64位浮点数表示实部和虚部

**array方法：**

通过列表：
    >>> print numpy.array([[1,2],[3,4]], dtype=int16)   //显示定义数组元素类型
    [[1 2]
     [3 4]]
    通过元组
    >>> print numpy.array((1.0,2,3,4))
    [ 1.0  2.   3.   4. ]

**arrange方法：**

>>> print numpy.arange(11)
    [ 0  1  2  3  4  5  6  7  8  9 10]

**linspace方法（1-3分成9份）：**

>>> print numpy.linspace(1,3,9)
    [ 1.    1.25  1.5   1.75  2.    2.25  2.5   2.75  3.  ]

**zeros(0)，ones(1)，eye(对角)：**

>>> print numpy.zeros((3,4))
    [[ 0.  0.  0.  0.]
     [ 0.  0.  0.  0.]
     [ 0.  0.  0.  0.]]
    >>> print numpy.ones((3,4))
    [[ 1.  1.  1.  1.]
     [ 1.  1.  1.  1.]
     [ 1.  1.  1.  1.]]
    >>> print numpy.eye(3)
    [[ 1.  0.  0.]
     [ 0.  1.  0.]
     [ 0.  0.  1.]]

**随机数：**  
numpy.random.uniform 函数原型： numpy.random.uniform(low,high,size)从一个均匀分布\[low,high)中随机采样，注意定义域是左闭右开，即包含low，不包含high.

randint: 原型：numpy.random.randint(low, high=None, size=None, dtype=‘l’)，产生随机整数；

random\_integers: 原型： numpy.random.random\_integers(low, high=None, size=None)，在闭区间上产生随机整数；

random\_sample: 原型： numpy.random.random\_sample(size=None)，在\[0.0,1.0)上随机采样；

random: 原型： numpy.random.random(size=None)，和random\_sample一样，是random\_sample的别名；

rand: 原型： numpy.random.rand(d0, d1, …, dn)，产生d0 - d1 - … - dn形状的在\[0,1)上均匀分布的float型数。

randn: 原型：numpy.random.randn（d0,d1,…,dn),产生d0 - d1 - … - dn形状的标准正态分布的float型数。

## **三、数组属性** ##

>>> a = numpy.ones((3,4))
    >>> print a.ndim   #维数
    2
    >>> print a.shape  #每一维的大小
    (3, 4)
    >>> print a.size   #元素数
    12
    >>> print a.dtype  #元素类型
    float64
    >>> print a.itemsize  #每个元素所占的字节数
    8

## **四、数组索引，切片** ##

**索引：**

>>>  b = numpy.arange(24).reshape(2,3,4)
    >>>print b
    [[[ 0  1  2  3]
      [ 4  5  6  7]
      [ 8  9 10 11]]
    
     [[12 13 14 15]
      [16 17 18 19]
      [20 21 22 23]]]
    >>> b[1,2,1]
    21

**切片：**

>>> b = numpy.arange(12).reshape(4,3) 
    >>> print b  
        [[ 0  1  2]  
        [ 3  4  5]  
        [ 6  7  8]  
        [ 9 10 11]]

# -1表示我懒得计算该填什么数字，由python通过数组a和其他的值3推测出来
    np.reshape(a, (3,-1))

**改变维数大小：**

将切片对象按列转换为连接。
    np.c_[np.array([1,2,3]), np.array([4,5,6])]  
    Out[96]:   
    array([[1, 4],  
           [2, 5],  
           [3, 6]])  
      
    np.c_[np.array([[1,2,3]]), 0, 0, np.array([[4,5,6]])]  
    Out[97]: array([[1, 2, 3, 0, 0, 4, 5, 6]])

从数组的形状中删除单维条目
    x = np.array([[[0], [1], [2]]])
    print(x)
    """
    x=
    [[[0]
      [1]
      [2]]]
    """
    print(x.shape)  # (1, 3, 1)
    
    x1 = np.squeeze(x) 
    print(x1)  # [0 1 2]
    print(x1.shape)  # (3,)

## **五、运算** ##

**±\*/**  
运算符±\*/都是对每个元素进行计算

>>> print a
    [[ 1.  1.]
     [ 1.  1.]]
    >>> print b
    [[ 1.  0.]
     [ 0.  1.]]
    
    >>> print a+b
    [[ 2.  1.]
     [ 1.  2.]]
    >>> print a-b
    [[ 0.  1.]
     [ 1.  0.]]
    >>> print b*2
    [[ 2.  0.]
     [ 0.  2.]]
    >>> print (a*2)*(b*2)
    [[ 4.  0.]
     [ 0.  4.]]
    >>> print b/(a*2)
    [[ 0.5  0. ]
     [ 0.   0.5]]
    >>> print (a*2)**4
    [[ 16.  16.]
     [ 16.  16.]]

**其他方法：**  
**sum min max**

>>> a = numpy.ones((3,4))
    >>> a.sum()
    12
    >>> a.sum(axis=0)   #计算每一列的和
    array([ 4,  4, 4])
    >>> a.min()
    1
    >>> a.max()
    1

#关于参数axis的含义：首先我们将三维数组想象成许多二维数组平面添加而成。可按倒序记忆：三维最后添加深度0，倒数第二添加列1，第一形成行2。则
    >>> print(X)
    [[[5 2]
      [4 2]]
     [[1 3]
      [2 3]]
     [[1 1]
      [0 1]]]
    
    >>> X.sum(axis=0)       //全部平面上的对应位置
    array([[7, 6],
           [6, 6]])
    
    >>> X.sum(axis=1)      //每一个平面的每一列
    array([[9, 4],
           [3, 6],
           [1, 2]])
    
    >>> X.sum(axis=2)       //每一个平面的每一行
    array([[7, 6],
           [4, 5],
           [2, 1]])
    
    >>> print a
    [[0 1 2]
     [3 4 5]
     [6 7 8]]
    >>> a.sum(axis=0)    //列
    array([ 9, 12, 15])
    >>> a.sum(axis=1)    //行
    array([ 3, 12, 21])

**sin floor exp**

>>> print a
    [[ 1.  1.]
     [ 1.  1.]]
     
    >>> numpy.sin(a)
    array([[ 0.84147098,  0.84147098],
           [ 0.84147098,  0.84147098]])
    >>> numpy.floor(a)
    array([[ 1.,  1.],
           [ 1.,  1.]])
    >>> numpy.exp(a)
    array([[ 2.71828183,  2.71828183],
           [ 2.71828183,  2.71828183]])

> 如果数组太长，Numpy默认只打印两端数据，可设置set\_printoptions(threshold=‘nan’) 强制打印

**sign**

import numpy as np
    np.sign([-5., 0, 4.5])
    # 大于0等于1，小于0等于-1 array([-1.,  0.,  1.])

## **六、合并** ##

属于深拷贝

>>> a = numpy.ones((2,2))
    >>> b = numpy.eye(2)
    //垂直组合
    >>> print np.vstack((a,b))    //与row_stack()行组合类似
    [[ 1.  1.]
     [ 1.  1.]
     [ 1.  0.]
     [ 0.  1.]]
    //水平组合
    >>> print numpy.hstack((a,b))      //与column_stack()行组合类似
    [[ 1.  1.  1.  0.]
     [ 1.  1.  0.  1.]]
    //深度组合
    >>> print a
    [[0 1 2]
     [3 4 5]
     [6 7 8]]
    >>> b = a*2
    >>> print b
    [[ 0  2  4]
     [ 6  8 10]
     [12 14 16]]
    >>> print numpy.dstack((a,b))    //a与b在相同位置的元素进行组合
    [[[ 0  0]
      [ 1  2]
      [ 2  4]]
    
     [[ 3  6]
      [ 4  8]
      [ 5 10]]
    
     [[ 6 12]
      [ 7 14]
      [ 8 16]]]

>>> a = numpy.ones((1,1))
    >>> b = a         #浅拷贝，作为函数参数时属于浅拷贝
    >>> b is a
    True
    >>> c = a.copy()  #深拷贝
    >>> c is a
    False

**拼接：**  
原始python：

y1 = [[1,0],[0,0]]
    y2 = [[0,0],[0,1]]
    y1.append(y2)  #将y2作为一个元素并进y1
    # [[1, 0], [0, 0], [[0, 0], [0, 1]]]

y1 = [[1,0],[0,0]]
    y2 = [[0,0],[0,1]]
    y1.extend(y2) #将y2中元素逐个取出放入y1
    # [[1, 0], [0, 0], [0, 0], [0, 1]]

numpy方法：

import numpy as np
    a=np.array([[1,2,3],[4,5,6]])
    b=np.array([[11,21,31],[7,8,9]])
    np.append(a,b)  # 将a和b中元素拼成一维
    # array([ 1,  2,  3,  4,  5,  6, 11, 21, 31,  7,  8,  9])

import numpy as np
    a=np.array([[1,2,3],[4,5,6]])
    b=np.array([[11,21,31],[7,8,9]])
    np.concatenate((a,b)) #将a和b默认按axis=0拼
    
    array([[ 1,  2,  3],
           [ 4,  5,  6],
           [11, 21, 31],
           [ 7,  8,  9]])

y1 = np.array([ [[1,0],[1,0]] , [[0,0],[0,0]] ])
    y2 = np.array([ [[0,0],[0,0]] , [[0,1],[0,1]] ])
    np.concatenate((y1,y2),axis=1)  #按轴=1拼
     array([[[1, 0],
            [1, 0],
            [0, 0],
            [0, 0]],
    
           [[0, 0],
            [0, 0],
            [0, 1],
            [0, 1]]])

针对不同shape时，list和numpy混用：

y1 = [ np.array([[1,0,0],[1,0,0]]) , np.array([[0,0],[0,0]]) ]
    y2 = [ np.array([[0,0,0],[0,0,0]]) , np.array([[0,1],[0,1]]) ]
    np.concatenate((y1[0],y2[0]))
    
    array([[1, 0, 0],
           [1, 0, 0],
           [0, 0, 0],
           [0, 0, 0]])

## **七、分割** ##

垂直和水平分割：

>>> print a
    [[0 1 2]
     [3 4 5]
     [6 7 8]]
    >>> numpy.hsplit(a,3)
    [array([[0],
           [3],
           [6]]), array([[1],
           [4],
           [7]]), array([[2],
           [5],
           [8]])]
    >>> print numpy.hsplit(a,3)
    [array([[0],
           [3],
           [6]]), array([[1],
           [4],
           [7]]), array([[2],
           [5],
           [8]])]
    >>> print a
    [[0 1 2]
     [3 4 5]
     [6 7 8]]
    >>> numpy.hsplit(a,3)
    [array([[0],
           [3],
           [6]]), array([[1],
           [4],
           [7]]), array([[2],
           [5],
           [8]])]
    >>> numpy.vsplit(a,3)
    [array([[0, 1, 2]]), array([[3, 4, 5]]), array([[6, 7, 8]])]

深度分割：

>>> a = numpy.arange(27).reshape(3,3,3)
    >>> print a
    [[[ 0  1  2]
      [ 3  4  5]
      [ 6  7  8]]
    
     [[ 9 10 11]
      [12 13 14]
      [15 16 17]]
    
     [[18 19 20]
      [21 22 23]
      [24 25 26]]]
    >>> numpy.dsplit(a,3)
    [array([[[ 0],
            [ 3],
            [ 6]],
    
           [[ 9],
            [12],
            [15]],
    
           [[18],
            [21],
            [24]]]), array([[[ 1],
            [ 4],
            [ 7]],
    
           [[10],
            [13],
            [16]],
    
           [[19],
            [22],
            [25]]]), array([[[ 2],
            [ 5],
            [ 8]],
    
           [[11],
            [14],
            [17]],
    
           [[20],
            [23],
            [26]]])]

## **八、矩阵算法** ##

>>> print a
    [[1 0]
     [2 3]]
    >>> numpy.dot(a,a)   #运用矩阵乘法，对于一位数组做的是内积运算
    array([[ 1,  0],
           [ 8,  9]])
    >>> print a.transpose()  #运用矩阵转置
    [[1 2]
     [0 3]]
    >>> print numpy.trace(a)   #运用矩阵的迹
    4

## **九、其他** ##

numpy.where函数是三元表达式x if condition else y的矢量化版本

plt.plot(xx, np.where(xx < 1, 1 - xx, 0), 'g-',label="Hinge loss")
    # if xx<1 则1-xx否则0

维度转置：

# 其中 0 1 2 3分别表示张量的四个轴，转置后原来轴序变成 3 0 1 2
    b = np.transpose(np.float32(a[:,:,:,np.newaxis]), (3,0,1,2))

判断是否有空值：

import numpy as np
     
    data = np.array([1,2,3,np.nan,4,np.nan])
    # 获得一个bool数组
    np.isnan(data)
    # array([False, False, False,  True, False,  True], dtype=bool)
     
    # 获得nan的数量
    np.isnan(data).sum()
    # 2

**删除行列：**

删列：
    np.delete(arr, [1,2], axis=1)  # 对象，列数，指定轴
    删行：
    np.delete(arr, -1, axis=0)

**读写文件：**

np.savetxt('a.csv',a,fmt='%d',delimiter=',')#以逗号，分隔
    b = loadtxt('a.csv',dtype=int,delimiter=',',usecols=(1,3,4))

Save an array to a binary file in NumPy .npy format.
    np.save(outfile, x)
    np.load(outfile)

**排序：**

np.sort(a,axis=1)

**直方图：**

np.histogram(num_count,bins=20)

**去重：**

label_u = np.unique(label)

**numpy与list转换：**

np.array(a)
    a.tolist()

**生成索引打乱数据：**

np.random.seed(7)
    index = np.arange(train_num)
    np.random.shuffle(index)
    print(index[:10])
    part = int(0.90*train_num)
    X_train = X[:part]
    X_val = X[part:]

**计算分位点：**

for i in range(8):
        print(i,":",np.percentile(continues[i],95)) #95%分位点