NumPy入门指南(二) | Day2

缺乏、安全感 2023-02-13 03:27 91阅读 0赞

## 数组的操作 ##

### 数组的索引和切片 ###

数组的索引就是列表中的下标，来表明数组中元素的顺序位置;通过查询索引可以获取到想要的元素， 切片是截取到需要元素的集合。

#### 一维数组的操作方法 ####

import numpy as np
    a = np.arange(10) #生成数组的索引是从0-9
    # 冒号分隔切片参数 start:stop:step 来进行切片操作
    print(a[2:7:2])# 从索引3开始到索引8停止，索引8不包含，step为2
    '''
    [2 4 6]
    '''
    
    # 取其中的一个元素，只放置一个参数，如 [2]，将返回与该索引相对应的单个元素
    print(a[2])
    '''
    2
    '''
    
    #  如果为 [2:]，表示从该[2]索引开始以后的所有项都将被提取
    print(a[2:])
    '''
    [2 3 4 5 6 7 8 9]
    '''

#### 多维数组的操作方法 ####

多维数组的操作方法比较复杂，按照行和列的方式分别获取。

print(array\[x,y\]), 输出x行和y列的数组，逗号前面的x表示列，逗号后面y表示要取出的列。

import numpy as np
    t1 = np.arange(24).reshape(4,6)
    print(t1)
    '''
    [[ 0  1  2  3  4  5]
     [ 6  7  8  9 10 11]
     [12 13 14 15 16 17]
     [18 19 20 21 22 23]]
    '''
    
    # 取一行数组(一行代表是一条数据，索引也是从0开始的)
    print(t1[0])  # [0 1 2 3 4 5]
    ## 取一行数组元素的第二种表示方法，写全行和列
    # '0'的位置代表取的行，','后面是截取的列，'：'冒号代表从这个位置起后的所有元素被获取
    print(t1[0,:])  # [0 1 2 3 4 5]
    # t1中括号里的参数可以理解为行的索引为0，取第一行；’,’ 后面是取的列数，不写默认索引为0是第一列，冒号是从索引为0的列开始取到最后，就是第一列到最后一列。整体理解就是取第一行中的所有列
    
    
    # 取连续的多行数组
    print(t1[0:])
    # 取连续的多行数组，
    print(t1[0:2,:]) # 行的索引为0到2，2不取，列取所有
    '''
    运行结果：
    [[ 0  1  2  3  4  5]
     [ 6  7  8  9 10 11]
     [12 13 14 15 16 17]
     [18 19 20 21 22 23]]
    
    [[ 0  1  2  3  4  5]
     [ 6  7  8  9 10 11]]
    '''
    
    print(t1[[0,2,3]]) # 取不连续的多行
    print(t1[[0,1,3],:]) # 取不连续的多行的第二种表示方法，写全行和列
    '''
    运行结果：
    [[ 0  1  2  3  4  5]
     [12 13 14 15 16 17]
     [18 19 20 21 22 23]]
    
    [[ 0  1  2  3  4  5]
     [ 6  7  8  9 10 11]
     [18 19 20 21 22 23]]
    '''
    
    print(t1[:,0])# 取一列
    print(t1[:,0:])# 连续的多列
    print(t1[:,[0,1,3]])# 取不连续的多列
    '''
    运行结果：
    [ 0  6 12 18]
    
    [[ 0  1  2  3  4  5]
     [ 6  7  8  9 10 11]
     [12 13 14 15 16 17]
     [18 19 20 21 22 23]]
    
    [[ 0  1  3]
     [ 6  7  9]
     [12 13 15]
     [18 19 21]]
    
    '''
    # 取某一个值,如二行三列
    print(t1[1,2])  # 8
    # 取多个不连续的值，[[行，行。。。],[列，列。。。]]
    print(t1[[0,1,1],[0,1,3]]) # [0 7 9]

### 修改数组中的数值 ###

修改数组和查询索引、截取的方式相同，都是按照行和列。

import numpy as np 
 t1 = np.arange(24).reshape(4,6)
 # 修改某一行的值
 t1[0,:]=0
 print(t)
 # 修改某一列的值
 t1[:,0]=0
 print(t1)
 '''
 [[ 0 0 0 0 0 0]
 [ 0 7 8 9 10 11]
 [ 0 13 14 15 16 17]
 [ 0 19 20 21 22 23]]
 '''
 
 t2 = np.arange(24).reshape(4,6)
 # 修改连续多行
 t2[0:2,:]=0
 # 修改连续多列
 t2[:,1:4]=0
 print(t2)
 '''
 [[ 0 0 0 0 0 0]
 [ 0 0 0 0 0 0]
 [12 0 0 0 16 17]
 [18 0 0 0 22 23]]
 '''
 
 t3 = np.arange(24).reshape(4,6)
 # 修改多行多列，取第二行到第四行，第三列到第五列
 t3[1:4,2:5]=0
 # 修改多个不相邻的点，[[行，行。。。],[列，列。。。]]
 t3[[0,1],[0,1]]=0 # 修改第一行第一列为0，等于不修改；第二行第二列的7为0
 print(t3)
 '''
 [[ 0 1 2 3 4 5]
 [ 6 0 8 9 10 11]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]]
 '''
 
 t4 = np.arange(24).reshape(4,6)
 # 可以根据条件修改，比如讲小于10的值改掉
 t4[t4<10]=0
 print(t4)
 '''
 [[ 0 0 0 0 0 0]
 [ 0 0 0 0 10 11]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]]
 '''
 
 # 使用逻辑判断
 # np.logical_and &
 # np.logical_or   |
 # np.logical_not ~
 t5 = np.arange(24).reshape(4,6)
 t5[(t5>10)&(t5<16)]=0 # 与
 print(t5)
 
 t5[(t5<10)|(t5>16)]=1 # 或
 print(t5)
 
 t5[~(t5>6)]=2 # 非
 print(t5)
 '''
 [[ 0 1 2 3 4 5]
 [ 6 7 8 9 10 0]
 [ 0 0 0 0 16 17]
 [18 19 20 21 22 23]]
 
 [[ 1 1 1 1 1 1]
 [ 1 1 1 1 10 1]
 [ 1 1 1 1 16 1]
 [ 1 1 1 1 1 1]]
 
 [[ 2 2 2 2 2 2]
 [ 2 2 2 2 10 2]
 [ 2 2 2 2 16 2]
 [ 2 2 2 2 2 2]]
 '''
 
 
 # 拓展:三目运算，也叫条件判断( np.where(condition, x, y)，满足条件(condition)，输出x，不满足输出y。
 score = np.array([[70,78],[72,71],[65,71]])
 result = np.where(score>70,True,False)
 print(result)
 '''
 [[False True]
 [ True True]
 [False True]]
 '''

### 数组的添加、删除和去重 ###

#### 数组中添加数据 ####

向数组中添加数据，方法与python中对列表添加数据相同，使用append和insert。

*方法1：append()*

# 1.numpy.append() 函数在数组的末尾添加值。追加操作会分配整个数组，并把原来的数组复制到新数组中。此外， 输入数组的维度必须匹配否则将生成Value Error。注意: 最多两个数组拼接，不能三个及以上进行拼接
    '''
    参数说明:
    arr:输入数组
    values:要向arr添加的值，需要和arr形状相同(除了要添加的轴)
    axis:默认为None。当axis无定义时，是横向加成，返回总是为一维数组!当axis有定义的时候，分别为0和1的时 候。当axis有定义的时候，分别为0的时候(列数要相同)。当axis为1时，数组是加在右边(行数要相同)。
    '''
    import numpy as np
    a = np.array([[1,2,3],[4,5,6]])
    print ('第一个数组:')
    print (a)
    print ('\n') #'\n' 换行的意思
    
    print ('向数组添加元素:')
    print (np.append(a, [7,8,9]))
    print ('\n') # 如果填加时不指定轴，则数组会变成一维数组
    
    print ('沿0轴-行添加元素:')
    print (np.append(a, [[7,8,9]],axis = 0))
    print ('\n') # 末尾添加一行数据，不改变列结构
    
    print ('沿1轴-列添加元素:')
    print (np.append(a, [[5,5,5],[7,8,9]],axis = 1)) # 末尾添加一列数据，不改变行结构

运行结果：

第一个数组:
    [[1 2 3]
     [4 5 6]]
    
    向数组添加元素:
    [1 2 3 4 5 6 7 8 9]
    
    沿轴 0 添加元素:
    [[1 2 3]
     [4 5 6]
     [7 8 9]]
    
    沿轴 1 添加元素:
    [[1 2 3 5 5 5]
     [4 5 6 7 8 9]]

append是在末尾添加元素，insert可以在指定位置添加元素。

方法二: insert()\*

# 2. numpy.insert 函数在给定索引之前，沿给定轴在输入数组中插入值。
    import numpy as pd
    a = np.array([[1,2],[3,4],[5,6]])
    print ('第一个数组:')
    print (a)
    print ('\n')
    
    # insert(arr,obj,values，axis) arr:添加的数组,obj:索引,values:添加的数据,axis:指定的轴
    print ('未传递 Axis 参数。在插入之前输入数组会被展开。')
    print (np.insert(a,3,[11,12]))
    print ('\n')
    
    print ('传递了 Axis 参数。会广播值数组来配输入数组。')
    print ('沿轴 0 广播:')
    print (np.insert(a,1,[11],axis = 0))
    print ('\n')
    print ('沿轴 1 广播:')
    print (np.insert(a,1,11,axis = 1))

运行结果：

第一个数组:
    [[1 2]
     [3 4]
     [5 6]]
    
    
    未传递 Axis 参数。 在插入之前输入数组会被展开。
    [ 1  2  3 11 12  4  5  6]
    
    
    传递了 Axis 参数。 会广播值数组来配输入数组。
    沿轴 0 广播:
    [[ 1  2]
     [11 11]
     [ 3  4]
     [ 5  6]]
    
    
    沿轴 1 广播:
    [[ 1 11  2]
     [ 3 11  4]
     [ 5 11  6]]

#### 数组删除 ####

#numpy.delete 函数返回从输入数组中删除指定子数组的新数组。如果未提供轴参数，则输入数组将展开，与 insert()函数相同。
    '''
    numpy.delete(arr, obj, axis=None)
    参数说明:
    arr:输入数组
    obj:可以被切片，整数或者整数数组，表明要从输入数组删除的子数组
    axis:沿着它删除给定子数组的轴，如果未提供，则输入数组会被展开
    '''
    import numpy as np
    a = np.arange(12).reshape(3,4)
    
    print ('第一个数组:')
    print (a)
    print ('\n')
    
    print ('未传递 Axis 参数。在删除之前输入数组会被展开。')
    print (np.delete(a,5))
    print ('\n')
    print ('删除每一行中的第二列:')
    print (np.delete(a,1,axis = 1))
    print ('\n')
    
    # 运行结果：
    '''
    第一个数组:
    [[ 0  1  2  3]
     [ 4  5  6  7]
     [ 8  9 10 11]]
    
    
    未传递 Axis 参数。在删除之前输入数组会被展开。
    [ 0  1  2  3  4  6  7  8  9 10 11]
    
    
    删除每一行中的第二列:
    [[ 0  2  3]
     [ 4  6  7]
     [ 8 10 11]]
    '''

#### 数组去重 ####

数组去重numpy.unqiue()函数不仅可以去重复值，还可以统计重复值的次数，根据重复的次数可以画饼图，得知每部分的占比。

# numpy.unique(arr, return_index=False, return_inverse=False, return_counts=False, axis=None) 用于去除数组中的重复元素。
    '''
    arr:输入数组，如果不是一维数组则会展开
    return_index:如果为true，返回新列表元素在旧列表中的位置(下标)，并以列表形式储
    return_inverse:如果为true，返回旧列表元素在新列表中的位置(下标)，并以列表形式储
    return_counts:如果为true，返回去重数组中的元素在原数组中的出现次数
    '''
    import numpy as np
    a = np.array([5,2,6,2,7,5,6,8,2,9])
    print ('第一个数组:')
    print (a)
    print ('\n')
    
    print ('第一个数组的去重值:')
    u = np.unique(a)
    print (u)
    print ('\n')
    
    # return_index = True 会有两个返回值，一个是返回的去重后数组u，还有一个是数组indices（缩影），表示去重后的元素在去重前列表中的位置。
    print ('去重数组的索引数组:')
    u,indices = np.unique(a, return_index = True)
    print (u)
    print (indices)
    
    print ('我们可以看到每个和原数组下标对应的数值:')
    print (a)
    
    print ('去重数组的下标:')
    u,indices = np.unique(a,return_inverse = True)
    print (u)
    print (indices)
    
    print ('返回去重元素的重复数量:')
    u,indices = np.unique(a,return_counts = True)
    print (u)
    print (indices)

运行结果：

第一个数组:
    [5 2 6 2 7 5 6 8 2 9]
    
    第一个数组的去重值:
    [2 5 6 7 8 9]
    # 元素’2‘出现三次排在最前面，索引为0
    
    去重数组的索引数组:
    [2 5 6 7 8 9]
    [1 0 2 4 7 9]
    # 返回新列表元素在旧列表中的位置
    
    我们可以看到每个和原数组下标对应的数值:
    [5 2 6 2 7 5 6 8 2 9]
    
    去重数组的下标:
    [2 5 6 7 8 9]
    [1 0 2 0 3 1 2 4 0 5]
    # return_inverse:如果为true，返回旧列表元素在新列表中的位置(下标)，并以列表形式储
    
    返回去重元素的重复数量:
    [2 5 6 7 8 9]
    [3 2 2 1 1 1]

### 数组的拼接 ###

有的时候我们需要将两个数据加起来一起研究分析，比如今年和去年的数据加在一起进行分析，我们就可以将其进行拼接然后分析。

import numpy as np
    # 1. 根据轴连接的数组序列
    # np.concatenate((a1, a2,...),axis=0)函数，能够一次完成多个数组拼接
    a = np.array([[1,2],[3,4]])
    b = np.array([[5,6],[7,8]])
    
    # 要求a,b两个数组的维度相同
    print ('沿轴 0 连接两个数组:')
    print (np.concatenate((a,b),axis= 0))
    print ('\n')
    print ('沿轴 1 连接两个数组:')
    print (np.concatenate((a,b),axis = 1))
    '''
    沿轴 0 连接两个数组:
    [[1 2]
     [3 4]
     [5 6]
     [7 8]]
    
    沿轴 1 连接两个数组:
    [[1 2 5 6]
     [3 4 7 8]]
    '''
    
    # 2. 根据轴进行堆叠
    print ('沿轴 0 堆叠连接两个数组:')
    print (np.stack((a,b),axis= 0))
    print ('\n')
    print ('沿轴 1 堆叠连接两个数组:')
    print (np.stack((a,b),axis = 1))
    '''
    沿轴 0 堆叠连接两个数组:
    [[[1 2]
      [3 4]]
    
     [[5 6]
      [7 8]]]
    
    沿轴 1 堆叠连接两个数组:
    [[[1 2]
      [5 6]]
    
     [[3 4]
      [7 8]]]
    '''
    
    # 3. 矩阵垂直拼接
    a1 = [[0,1,2,3,4,5],
    [6,7,8,9,10,11]]
    a2 = [[12,13,14,15,16,17],
    [18,19,20,21,22,23]]
    va1a2= np.vstack((a1,a2))
    print(va1a2)
    '''
    [[ 0  1  2  3  4  5]
     [ 6  7  8  9 10 11]
     [12 13 14 15 16 17]
     [18 19 20 21 22 23]]
    '''
    
    
    # 4. 矩阵水平拼接
    b1 = [[0,1,2,3,4,5],
    [6,7,8,9,10,11]]
    b2 = [[12,13,14,15,16,17],
          [18,19,20,21,22,23]]
    hb1b2 = np.hstack((b1,b2))
    print(hb1b2)
    '''
    [[ 0  1  2  3  4  5 12 13 14 15 16 17]
     [ 6  7  8  9 10 11 18 19 20 21 22 23]]
    '''

### 数组的分割 ###

import numpy as np
    # 1. 将一个数组分割为多个子数组
    '''
    numpy.split(ary, indices_or_ps, axis=0)
    参数说明:
    ary:被分割的数组
    indices_or_ps:如果是一个整数，就用该数平均切分，如果是一个数组，为沿轴切分的位置
    axis:沿着哪个维度进行切向，默认为0，横向切分。为1时，纵向切分
    '''
    
    arr = np.arange(9).reshape(3,3)
    print(arr)
    print ('将数组分为三个大小相等的子数组:')
    b = np.split(arr,3)
    print (b)
    print('\n')
    
    # 2.numpy.hsplit 函数用于水平分割数组，通过指定要返回的相同形状的数组数量来拆分原数组。
    # floor() 向下取整数，如：3.6，向下取整是3.0，浮点型
    harr = np.floor(10 * np.random.random((2, 6)))
    print ('原array:')
    print(harr)
    print ('水平分割:')
    print(np.hsplit(harr, 3))
    print('\n')
    
    # 3.numpy.vsplit 沿着垂直轴的方向分割
    varr = np.arange(16).reshape(4,4)
    print ('原array:')
    print (varr)
    print ('竖直分割:')
    print (np.vsplit(varr,2))

运行结果：

[[0 1 2]
     [3 4 5]
     [6 7 8]]
    将数组分为三个大小相等的子数组:
    [array([[0, 1, 2]]), array([[3, 4, 5]]), array([[6, 7, 8]])]
    
    原array:
    [[4. 3. 7. 0. 8. 2.]
     [8. 2. 7. 5. 6. 7.]]
    水平分割:
    [array([[4., 3.],[8., 2.]]),
    array([[7., 0.],[7., 5.]]),
    array([[8., 2.],[6., 7.]])]
    
    原array:
    [[ 0  1  2  3]
     [ 4  5  6  7]
     [ 8  9 10 11]
     [12 13 14 15]]
    竖直分割:
    [array([[0, 1, 2, 3],[4, 5, 6, 7]]),
    array([[ 8,  9, 10, 11],[12, 13, 14, 15]])]

## NumPy的计算 ##

numpy最重要的功能是对数组进行操作和计算，以下是一些NumPy中数学计算的函数,本块内容了解即可，需要用的时候进行搜索即可。代码讲解中，挑选部分常用函数进行讲解。

**常用的算术运算函数：**

函数

说明

<table> 
 <thead> 
 <tr> 
 <td> </td> 
 <td> </td> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td>np.pi</td> 
 <td>常数p:圆周率3.1415926...</td> 
 </tr> 
 <tr> 
 <td>np.e</td> 
 <td>常数e ：2.71828...</td> 
 </tr> 
 <tr> 
 <td>np.fabs(arr)</td> 
 <td>计算各元素浮点型绝对值；例如：np.fabs(-3) &nbsp;输出：3.0</td> 
 </tr> 
 <tr> 
 <td>np.ceil(arr)</td> 
 <td>对各元素向上取整；例如：np.ceil(3.2) &nbsp;输出：4.0 &nbsp;并非四舍五入操作</td> 
 </tr> 
 <tr> 
 <td>np.floor(arr)</td> 
 <td>对各元素向下取整；</td> 
 </tr> 
 <tr> 
 <td>np.round(arr)</td> 
 <td>对各元素四舍五入 例如：np.round(3.4) 输入：3.0 &nbsp;输出的还是浮点型数据，并非整型</td> 
 </tr> 
 <tr> 
 <td>np.fmod(arr1,arr2)</td> 
 <td>计算arr1/arr2的余数；对arr1，arr2没有要求为整数,如np.fmod(3.9,3.8) 结果是：0.1000000</td> 
 </tr> 
 <tr> 
 <td>np.modf(arrj)</td> 
 <td>返回数组元素的小数部分和整数部分 如：arr1 = np.array([3.21,4.1,5.2]) &nbsp;print(np.modf(arr1)) &nbsp;输出如下：[0.31, 0.1 , 0.2 ]), array([2., 4., 5.]</td> 
 </tr> 
 <tr> 
 <td>np.sqrt(arr)</td> 
 <td>计算各元素的算数平方根</td> 
 </tr> 
 <tr> 
 <td>np.square(arr)</td> 
 <td>计算各元素的平方值</td> 
 </tr> 
 <tr> 
 <td>np.exp(arr)</td> 
 <td>计算各元素的e的幂次方</td> 
 </tr> 
 <tr> 
 <td>p.</td> 
 <td>计算各元素的指数</td> 
 </tr> 
 <tr> 
 <td>np.log2(arr)</td> 
 <td>计算以2为底各元素的对数</td> 
 </tr> 
 <tr> 
 <td>np.log10(arr)</td> 
 <td>计算以10为底各元素的对数</td> 
 </tr> 
 <tr> 
 <td>np.log(arr)</td> 
 <td>计算以e为底各元素的对数</td> 
 </tr> 
 </tbody> 
</table>

**常用统计函数：**

函数的参数中一般要求指定轴，如果不指定将把数组按行展开，转换成一维数组

函数

说明

<table> 
 <thead> 
 <tr> 
 <td> </td> 
 <td> </td> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td>np.min(arr,axis)</td> 
 <td>按照轴的方向计算最小值</td> 
 </tr> 
 <tr> 
 <td>np.max(arr,axis)</td> 
 <td>按照轴的方向计算最大值</td> 
 </tr> 
 <tr> 
 <td>np.ptp(arr,axis)</td> 
 <td>按照轴的方向计算统计最大值与最小值之差</td> 
 </tr> 
 <tr> 
 <td>np.mean(arr,axis)</td> 
 <td>按照轴的方向计算平均值</td> 
 </tr> 
 <tr> 
 <td>np.median(arr,axis)</td> 
 <td>按照轴的方向计算中位数</td> 
 </tr> 
 <tr> 
 <td>np.percentile(arr,p,axis)</td> 
 <td>按照轴的方向统计数组的百分位数;p的取值0-100</td> 
 </tr> 
 <tr> 
 <td>np.average(arr,weights=wts,axis)</td> 
 <td>统计数组中的加权平均值;***默认每个元素的权重相同，可以通过赋值数组wts来设定元素的权重</td> 
 </tr> 
 <tr> 
 <td>np.sum(arr,axis)</td> 
 <td>按照轴的方向计算和</td> 
 </tr> 
 <tr> 
 <td>np.std(arr,axis)</td> 
 <td>按照轴的方向计算标准差</td> 
 </tr> 
 <tr> 
 <td>np.var(arr,axis)</td> 
 <td>按照轴的方向计算方差</td> 
 </tr> 
 <tr> 
 <td>np.cumsum(arr,axis)</td> 
 <td>按照轴的方向计算累计和</td> 
 </tr> 
 <tr> 
 <td>np.cumpord(arr,axis)</td> 
 <td>按照轴的方向计算累计乘积</td> 
 </tr> 
 <tr> 
 <td>np.argmin(arr,axis)</td> 
 <td>按照轴的方向返回最小值所在的位置</td> 
 </tr> 
 <tr> 
 <td>np.agmax(arr,axis)</td> 
 <td>按照轴的方向返回最大值所在的位置</td> 
 </tr> 
 <tr> 
 <td>np.corrcoef(arr)</td> 
 <td>计算皮尔逊相关系数</td> 
 </tr> 
 <tr> 
 <td>np.cov(arr)</td> 
 <td>计算协方差矩阵</td> 
 </tr> 
 <tr> 
 <td>注：axis = 0时，计算数组各列的统计值；</td> 
 <td> </td> 
 </tr> 
 <tr> 
 <td>axis = 1，计算数组各行的统计值</td> 
 <td> </td> 
 </tr> 
 </tbody> 
</table>

import numpy as np
    score = np.array([[80,88],[82,81],[75,81]])
    print(score)
    '''
    [[80 88]
     [82 81]
     [75 81]]
    '''
    
    # 1. 获取所有数据最大值
    ans01 = np.max(score)
    print(ans01) # 88
    
    # 2. 获取某一个轴上的数据最大值
    ans02 = np.max(score,axis=0)
    print(ans02)  #[82 88]
    
    # 3. 获取最小值
    ans03 = np.min(score)
    print(ans03) # 75
    
    # 4. 数据的比较
    ans04 = np.maximum([-2, -1, 0, 1, 2], 0) # 第一个参数中的每一个数与第二个参数比较返回大的
    ans05 = np.minimum([-2, -1, 0, 1, 2], 0) # 第一个参数中的每一个数与第二个参数比较返回小的
    ans06 = np.maximum([-2, -1, 0, 1, 2], [1,2,3,4,5]) # 接受的两个参数，也可以大小一致;第二个参数只是一个单独的值时，其实是用到了维度的广播机制;
    print(ans04,ans05,ans06)
    # [0 0 0 1 2]  [-2 -1  0  0  0]   [1 2 3 4 5]
    
    # 5. 求平均值
    ans07 = np.mean(score) # 获取所有数据的平均值
    ans08 = np.mean(score,axis=0) # 获取一个轴上的平均值
    print(ans07,ans08)
    # 81.16666666666667 [79.         83.33333333] 轴上有两列，[]中放有两列的均值
    
    # 6. 返回给定axis上的累计和
    ans09 = np.array([[1,2,3], [4,5,6]])
    print(ans09)
    '''
    [[1 2 3]
     [4 5 6]]
    '''
    print(np.cumsum(ans09,0))
    '''
    [[1 2 3]
     [5 7 9]] # 5=1+4; 7=2+5; 9=3+6
    '''
    print(np.cumsum(ans09,1))
    '''
    [[ 1  3  6]   # 1  3=2+1 6=3+2+1
     [ 4  9 15]]  # 4  9=4+5 15=4+5+6
    '''
    
    # 7. argmin求最小值索引
    ans10 = np.argmin(score,axis=0)
    print(score)
    '''
    [[80 88]
     [82 81]
     [75 81]]
    '''
    print(ans10)
    # [2 1] 最小值在第三行第一列

## 数组中的nan和inf(无穷) ##

我们在获取到数据时，经常会面临数据缺失的问题,表示缺失的数据，用 nan(not a number) 来表示,任何与其做运算结果都是 nan，nan也可以看做sql中的null值。需要注意的是，numpy中的多个nan是不相等的，也就是说nan表示不知道是什么。两个nan比较大小的时候并不知道谁大谁小，判断两个nan是否相等时，结果是false。

当一个数除以0的时候，Python会报错，但是numpy中会是一个inf(infinite)无穷或者-inf，这种写法在 pandans 中也很常见。

下面我们来介绍如何判断数组中的nan的个数：

import numpy as np
 # 创建一个nan和inf
 a = np.nan
 b = np.inf 
 print(a,type(a))
 # nan <class 'float'>
 print(b,type(b))
 # inf <class 'float'> nan和inf都是float浮点型数据
 
 
 ## 判断数组中为nan的个数: print(np.count_nonzero(t != t))
 # 1.创建数组(注意:float类型的数据才能赋值nan)
 t = np.arange(24,dtype=float).reshape(4,6)
 print(t)
 '''
 [[ 0. 1. 2. 3. 4. 5.]
 [ 6. 7. 8. 9. 10. 11.]
 [12. 13. 14. 15. 16. 17.]
 [18. 19. 20. 21. 22. 23.]]
 '''
 
 # 2.增加nan：将数组中的第四行第五列的元素改成nan
 t[3,4] = np.nan
 print(t)
 '''
 [[ 0. 1. 2. 3. 4. 5.]
 [ 6. 7. 8. 9. 10. 11.]
 [12. 13. 14. 15. 16. 17.]
 [18. 19. 20. 21. nan 23.]]
 '''
 # nan和任何数计算都为nan
 print(np.sum(t,axis=0)) # 结果 [36. 40. 44. 48. nan 56.]
 
 #3.方法：np.count_nonzero() 求得非零值的个数
 print(np.count_nonzero(t)) # 23个，只有第一个元素是0
 
 # 4.numpy特性：nan不等于nan ；符号’!=‘ ：不等于
 # 判断修改过的含有一个nan的数组t是否不等于t
 print(t != t)
 '''
 [[False False False False False False]
 [False False False False False False]
 [False False False False False False]
 [False False False False True False]]
 
 只有倒数第二个为nan的元素不相等，其他的元素都相等；验证numpy中的nan和nan是不相等的
 '''
 
 # 5.结合判断非零个数的方法和 nan的特性来判断nan的个数
 # False=0；True = 1；因而数组（t != t) 只有1个1：true，其他23个元素全是0：false
 print(np.count_nonzero(t != t)) # 结果：1
 # count_nonzero统计非零数，数组(t != t)只有一个1，其他全是0，结果是1；数组中有一个nan存在 ；

处理数组中的nan：一般是将nan替换成0

import numpy as np
    t = np.arange(24).reshape(4,6).astype('float')
    
    # 将数组中的一部分替换nan 准备含有nan的数据
    t[1,3:] = np.nan
    print(t)
    '''
    [[ 0.  1.  2.  3.  4.  5.]
     [ 6.  7.  8. nan nan nan]
     [12. 13. 14. 15. 16. 17.]
    '''
    
    
    # 将数组中的nan替换为0
    t[np.isnan(t)] = 0 # 方法:np.isnan(arr) 找出nan 赋值为0
    print(t)
    '''
    [[ 0.  1.  2.  3.  4.  5.]
     [ 6.  7.  8.  0.  0.  0.]
     [12. 13. 14. 15. 16. 17.]
     [18. 19. 20. 21. 22. 23.]]
    
    '''

如果处理数据的量较小时，也可以考虑将nan替换为均值

import numpy as np
    t = np.arange(24).reshape(4,6).astype('float')
    
    # 将数组中的一部分替换nan 准备含有nan的数据
    t[1,3:] = np.nan
    print(t)
    '''
    [[ 0.  1.  2.  3.  4.  5.]
     [ 6.  7.  8. nan nan nan]
     [12. 13. 14. 15. 16. 17.]
    '''
    
    # ----- 将数组中的nan替换为每一列的平均值 ------
    
    for i in range(t.shape[1]):# 循环遍历每一列
         # t.shape[1]:是为了获取列数; print(t2.shape) 返回 (4,6)：四行六列,(4,6)是一个元祖类型的数据，t.shape[1] 通过下标取得列数；shape()中不直接写6因为，实际用的数据的列数是很大的，不可能一下数的出来
        
        temp_col = t[:,i] # 获取当前的列数据
        # 循环6次可以取到6列数组，前三行不含有nan；因此需要判断含列是否有nan，含有nan的列才需要替换
        # [ 0.  6. 12. 18.]
        # [ 1.  7. 13. 19.]
        # [ 2.  8. 14. 20.]
        # [ 3. nan 15. 21.]
        # [ 4. nan 16. 22.]
        # [ 5. nan 17. 23.]
        
        nan_num = np.count_nonzero(temp_col != temp_col) # 求得当前列数据含有nan的个数
        
        if nan_num != 0: # nan的个数不等于0则为True 含有nan
          
                temp_col_not_nan = temp_col[temp_col==temp_col] #去掉一列中的nan，形成不含nan的列
            
                temp_col[np.isnan(temp_col)] = np.mean(temp_col_not_nan)#将nan替换成这一列不含nan元素的均值
            
    print(t)
    '''
    [[ 0.  1.  2.  3.  4.  5.]
     [ 6.  7.  8. 13. 14. 15.]
     [12. 13. 14. 15. 16. 17.]
     [18. 19. 20. 21. 22. 23.]]
    
    '''

替换成均值的操作，比较复杂，请仔细阅读理解每一行的含义。用均值不用0代替nan的好处是，如果将某列的某个值替换成0，将会影响一整列的均值。使用列中不是nan的其他元素的均值代替，可以提高准确性。对于inf的处理类似，可以替换成0。

## 二维数组的转置 ##

二维数组的转置和二阶矩阵转置概念相同;对数组进行转置有三种方法，arr.T用的最多，其他方法了解即可。

对数组进行转置将在今后运行算法时需要用到。

import numpy as np
    
    #对换数组的维度:transpose()
    a = np.arange(12).reshape(3,4)
    print ('原数组:')
    print (a )
    print ('\n')
    print ('对换数组:')
    print (np.transpose(a))
    
    '''
    原数组:
    [[ 0  1  2  3]
     [ 4  5  6  7]
     [ 8  9 10 11]]
    
    对换数组:
    [[ 0  4  8]
     [ 1  5  9]
     [ 2  6 10]
     [ 3  7 11]]
    '''
    
    # arr.T 与transpose()相同
    a = np.arange(12).reshape(3,4)
    print ('原数组:')
    print (a)
    print ('\n')
    print ('转置数组:')
    print (a.T)
    '''
    原数组:
    [[ 0  1  2  3]
     [ 4  5  6  7]
     [ 8  9 10 11]]
    
    转置数组:
    [[ 0  4  8]
     [ 1  5  9]
     [ 2  6 10]
     [ 3  7 11]]
    '''
    
    # swapaxes()函数用于交换数组的两个轴
    t1 = np.arange(24).reshape(4,6)
    re = t1.swapaxes(1,0)
    print ('原数组:')
    print (t1)
    print ('\n')
    print ('调用 swapaxes 函数后的数组:')
    print (re)
    
    '''
    原数组:
    [[ 0  1  2  3  4  5]
     [ 6  7  8  9 10 11]
     [12 13 14 15 16 17]
     [18 19 20 21 22 23]]
    
    调用 swapaxes 函数后的数组:
    [[ 0  6 12 18]
     [ 1  7 13 19]
     [ 2  8 14 20]
     [ 3  9 15 21]
     [ 4 10 16 22]
     [ 5 11 17 23]]
    '''

### 作业 ###

1.练习数组索引和切片

2.请将NaN替换为均值的方法复习一遍，记住逻辑不看代码，动手实现一遍。

![format_png][]

[![format_png 1][]][format_png 1 1]

**写在后面：**

学完今天的课程，是不是对NumPy更加精进了呢？

完成今天的学习，评论区留言打卡~

记得在群里分享你的完成情况哦~

![format_png 2][]

好文章，我在看❤

[format_png]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X2dpZi9iOTZDaWJDdDcwaWFaVldMcUtXWXFUb0JCb0xUZU5jMk5tbHk0REJnbmoyb21Vcm5XdWtHZm1DQ1F0VmlhTGlhaktIcDRjQ1VNOUZXZzhzMTRVT1JoY2NVQmcvNjQw?x-oss-process=image/format,png
[format_png 1]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9xaWFTbDNSVDFSYzFZRmMyckF4ZVFFcFZxcmVpY2liV0dJaFZjcDBzZnFtclFac3hEalVtaFQzUEdaMnpOeVFsSjM0d0VJaWNjTEVnRGhJUnJwU2xkMEhYTHcvNjQw?x-oss-process=image/format,png
[format_png 1 1]: https://mp.weixin.qq.com/mp/appmsgalbum?__biz=MzIwMTMxMTQxNQ%3D%3D&action=getalbum&album_id=1339196544410796033#wechat_redirect
[format_png 2]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X2pwZy9xaWFTbDNSVDFSYzFlTFVkYjVjenlFcU5kckttRE9pYmxFd2U3OVdOc1ZmNFVpY05LTEJ4TGZpYWFqaEdoNzZEWkV2OWxxdDUySkt4Vm5mUDJZTGliRWliRnJiUS82NDA?x-oss-process=image/format,png