数组的操作
数组的索引和切片
数组的索引就是列表中的下标,来表明数组中元素的顺序位置;通过查询索引可以获取到想要的元素, 切片是截取到需要元素的集合。
一维数组的操作方法
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中数学计算的函数,本块内容了解即可,需要用的时候进行搜索即可。代码讲解中,挑选部分常用函数进行讲解。
常用的算术运算函数:
函数
说明
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和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替换为均值的方法复习一遍,记住逻辑不看代码,动手实现一遍。
写在后面:
学完今天的课程,是不是对NumPy更加精进了呢?
完成今天的学习,评论区留言打卡~
记得在群里分享你的完成情况哦~
好文章,我在看❤