专栏首页A2DataNumPy入门指南(二) | Day2

NumPy入门指南(二) | Day2

数组的操作

数组的索引和切片

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

一维数组的操作方法

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最重要的功能是对数组进行操作和计算,以下是一些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]]
'''

本文分享自微信公众号 - DataScience(DataScienceTeam),作者:Data君

原文出处及转载信息见文内详细说明,如有侵权,请联系 yunjia_community@tencent.com 删除。

原始发表时间:2020-05-26

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • NumPy入门指南(一) | Day1

    今明两天我们主要学习NumPy,NumPy是用Python做数据分析时不可或缺的一个库,想知道它怎么使用吗?快往下看吧!(ps:课程内容较多,大家坚持住哦!)

    DataScience
  • 【Python基础】整数与浮点数

    Python中,我们除了要跟代码打交道外,还要处理很多的数字,用来做可视化、记录用户信息等等。所以Python会根据数字的用法,以不同的方式处理他们,常见的类型...

    DataScience
  • 三大结构-分支

    DataScience
  • B13_NumPy数学函数(三角函数,舍入函数)

    NumPy 包含大量的各种数学运算的函数,包括三角函数,算术运算的函数,复数处理函数等。

    用户7886150
  • python实现猜数游戏(保存游戏记录)

    ①游戏可以重复进行,每当一个用户结束后,程序会提示是否还要继续,输入y继续,输入其他的字符退出; ②增加玩家姓名,并对该玩家的成绩进行记录,并存储在new.t...

    砸漏
  • 第一章 | 使用python机器学习

    python经常作为机器学习的首选,有一个统计,50%以上的机器学习开发者使用python。在学习机器学习之前需要熟悉以下几个python模块: numpy P...

    用户1332428
  • Numpy学习之数组

    版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。

    村雨遥
  • NumPy入门指南(一) | Day1

    今明两天我们主要学习NumPy,NumPy是用Python做数据分析时不可或缺的一个库,想知道它怎么使用吗?快往下看吧!(ps:课程内容较多,大家坚持住哦!)

    DataScience
  • 【机器学习】Python 快速入门笔记

            在模块内、所有函数外、class外的变量,可以被全局共享,也可以被外部文件共享

    py3study
  • Python数据分析之NumPy(基础篇)

    Numpy 的核心是ndarray对象,这个对象封装了同质数据类型的n维数组。起名 ndarray 的原因就是因为是 n-dimension-array 的简写...

    AI异构

扫码关注云+社区

领取腾讯云代金券