数组的索引就是列表中的下标,来表明数组中元素的顺序位置;通过查询索引可以获取到想要的元素, 切片是截取到需要元素的集合。
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_sections, axis=0) 参数说明: ary:被分割的数组 indices_or_sections:如果是一个整数,就用该数平均切分,如果是一个数组,为沿轴切分的位置 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中数学计算的函数,本块内容了解即可,需要用的时候进行搜索即可。代码讲解中,挑选部分常用函数进行讲解。
常用的算术运算函数:
函数
说明
np.pi | 常数p:圆周率3.1415926... |
np.e | 常数e :2.71828... |
np.fabs(arr) | 计算各元素浮点型绝对值;例如:np.fabs(-3) 输出:3.0 |
np.ceil(arr) | 对各元素向上取整;例如:np.ceil(3.2) 输出:4.0 并非四舍五入操作 |
np.floor(arr) | 对各元素向下取整; |
np.round(arr) | 对各元素四舍五入 例如:np.round(3.4) 输入:3.0 输出的还是浮点型数据,并非整型 |
np.fmod(arr1,arr2) | 计算arr1/arr2的余数;对arr1,arr2没有要求为整数,如np.fmod(3.9,3.8) 结果是:0.1000000 |
np.modf(arrj) | 返回数组元素的小数部分和整数部分 如:arr1 = np.array([3.21,4.1,5.2]) print(np.modf(arr1)) 输出如下:[0.31, 0.1 , 0.2 ]), array([2., 4., 5.] |
np.sqrt(arr) | 计算各元素的算数平方根 |
np.square(arr) | 计算各元素的平方值 |
np.exp(arr) | 计算各元素的e的幂次方 |
p. | 计算各元素的指数 |
np.log2(arr) | 计算以2为底各元素的对数 |
np.log10(arr) | 计算以10为底各元素的对数 |
np.log(arr) | 计算以e为底各元素的对数 |
常用统计函数:
函数的参数中一般要求指定轴,如果不指定将把数组按行展开,转换成一维数组
函数
说明
np.min(arr,axis) | 按照轴的方向计算最小值 |
np.max(arr,axis) | 按照轴的方向计算最大值 |
np.ptp(arr,axis) | 按照轴的方向计算统计最大值与最小值之差 |
np.mean(arr,axis) | 按照轴的方向计算平均值 |
np.median(arr,axis) | 按照轴的方向计算中位数 |
np.percentile(arr,p,axis) | 按照轴的方向统计数组的百分位数;p的取值0-100 |
np.average(arr,weights=wts,axis) | 统计数组中的加权平均值;***默认每个元素的权重相同,可以通过赋值数组wts来设定元素的权重 |
np.sum(arr,axis) | 按照轴的方向计算和 |
np.std(arr,axis) | 按照轴的方向计算标准差 |
np.var(arr,axis) | 按照轴的方向计算方差 |
np.cumsum(arr,axis) | 按照轴的方向计算累计和 |
np.cumpord(arr,axis) | 按照轴的方向计算累计乘积 |
np.argmin(arr,axis) | 按照轴的方向返回最小值所在的位置 |
np.agmax(arr,axis) | 按照轴的方向返回最大值所在的位置 |
np.corrcoef(arr) | 计算皮尔逊相关系数 |
np.cov(arr) | 计算协方差矩阵 |
注:axis = 0时,计算数组各列的统计值; | |
axis = 1,计算数组各行的统计值 |
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(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]] '''
本文分享自微信公众号 - DataScience(DataScienceTeam),作者:Data君
原文出处及转载信息见文内详细说明,如有侵权,请联系 yunjia_community@tencent.com 删除。
原始发表时间:2020-05-26
本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。
我来说两句