Numpy基础篇二
数组中的轴
123456789# 轴的理解
import numpy as np
a = np.array([[1,2,3],[4,5,6]])
print(a)
print(np.sum(a,axis=0))
print(np.sum(a,axis=1))
print(np.sum(a))
[[1 2 3]
[4 5 6]]
[5 7 9]
[ 6 15]
21
1234567891011121314151617181920# 轴的理解之三维数组
a = np.arange(27).reshape((3,3,3))
print('原三维数组')
print(a)
print('-----------')
b = np.sum(a,axis=0)
print('0轴')
print(b)
print('-----------')
c = np.sum(a,axis=1)
print('1轴')
print(c)
print('-----------')
d= np.sum(a,axis=2)
print('2轴')
print(d)
print('-----------')
运行结果：
原三维数组
[[[ 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]]]
0轴
[[27 30 33]
[36 39 42]
[45 48 51]]
1轴
[[ 9 12 15]
[36 39 42]
[63 66 69]]
2轴
[[ 3 12 21]
[30 39 48]
[57 66 75]]
数组中的索引和切片
123456789101112# 数组的索引和切片
# 一维数组
a = np.arange(10)
print(a)
# 冒号分隔切片参数 start:stop:step 来进行切片操作
print(a[2:7:2]) # 从索引 2 开始索引 到 7 停止（不包括7） 间隔为 2
# 如果只放置一个参数 如[2] 将返回与该索引相对应的单个元素
print(a[2],a)
# 如果为 [2:],表示从该索引（包括该索引）开始以后的所有项将都被提取
print(a[2:])
运行结果：
[0 1 2 3 4 5 6 7 8 9]
[2 4 6]
2 [0 1 2 3 4 5 6 7 8 9]
[2 3 4 5 6 7 8 9]
1234567891011121314151617181920212223242526272829# 数组的索引之多维数组
t1 = np.arange(24).reshape(4,6)
print('原数组')
print(t1)
print('*'*20)
print('取一行')
print(t1[1]) # 取一行（一行代表一条数据，索引也是从0开始的）
print('取一行')
print(t1[1,:]) # 取一行 （根据行和列进行索取）
print("*"*20)
print('取连续的多行')
print(t1[1:]) #取连续的多行 和所有的列 取第二行以及以后的行数
print('取连续的多行')
print(t1[1:3,:]) #取连续的多行 取第二行，第三行，不取第四行
print('取不连续的多行')
print(t1[[1,3],:]) # 取不连续的多行
print("*"*20)
print('原数组')
print(t1)
print('取出一列')
print(t1[:,1]) # 取出一列 索引为1 即第二列
print('取出连续的多列')
print(t1[:,1:])# 取出连续的多列
print('取出不连续的多列')
print(t1[:,[0,2,3]]) # 取不连续的多列
print('取出某一个特定的值')
print(t1[3,4]) #取某一个特定的值，第四行第五列
print('取多个不连续的值')
print(t1[[0,1,1],[0,1,3]])
数组中的数值修改
1234567891011121314151617181920212223t = np.arange(24).reshape(4,6)
print(t)
print()
# 修改某一行的值
t[1,:]=0
print(t)
print()
# 修改连续多行
t[1:3,:]=0
print(t)
print()
# 修改连续多列
t[:,1:4]=0
print(t)
print()
# 修改多个不相邻的点
t[[0,3],[5,5]]=0
print(t)
print()
运行结果：
[[ 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]
[ 0 0 0 0 0 0]
[12 13 14 15 16 17]
[18 19 20 21 22 23]]
[[ 0 1 2 3 4 5]
[ 0 0 0 0 0 0]
[ 0 0 0 0 0 0]
[18 19 20 21 22 23]]
[[ 0 0 0 0 4 5]
[ 0 0 0 0 0 0]
[ 0 0 0 0 0 0]
[18 0 0 0 22 23]]
[[ 0 0 0 0 4 0]
[ 0 0 0 0 0 0]
[ 0 0 0 0 0 0]
[18 0 0 0 22 0]]
数组的添加、删除、去重
1234567891011121314151617181920212223# 数组的添加
'''
arr: 输入的数组
values: 要向 arr 中添加的值 ，需要和 arr 形状相同（除了要添加的轴）
axis : 默认为None 不输入时默认以一维数组的形式添加
'''
a = np.array([[1,2,3],[4,5,6]])
print('第一个数组：')
print(a)
print('\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))
print('\n')
运行结果：
第一个数组：
[[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]]
1234567891011121314151617181920# 数组的添加 insert 方法
import numpy as np
a = np.array([[1,2],[3,4],[5,6]])
print('第一个数组：')
print(a)
print('\n')
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,12,13],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 12 4]
[ 5 13 6]]
12345678910111213141516171819202122232425# 数组删除 delete
'''
参数说明：
arr: 输入的数组
obj: 可以被切片，整数或者整数数组 ，表明要从输入数组删除的子数组
axis : 沿着它删除给定子数组的轴 ，如果未提供 ，则输入数组会被展开
'''
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')
print('删除每一列中的第一行：')
print(np.delete(a,0,axis=0))
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]]
删除每一列中的第一行：
[[ 4 5 6 7]
[ 8 9 10 11]]
1234567891011121314151617181920212223242526272829303132333435# 数组去重
'''
参数设置
arr: 输入数组 ，如果不是一维数组 则会展开
return_index: 如果为true ，返回新列表元素在旧的列表中的位置(下标)，并以列表形式储存
return_inverse: 如果为 true ,返回旧列表元素在新列表中的位置，并以列表形式储存
return_counts : 如果为 true ，返回去重数组中的元素在原数组出现次数
'''
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')
print('新列表元素在旧的列表中的位置(下标)：')
u,indices = np.unique(a,return_index=True)
print(indices)
print('\n')
print('旧列表元素对应新列表的位置（下标）')
u,indices = np.unique(a,return_inverse=True)
print(u)
print(indices)
print(a)
print('\n')
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]
新列表元素在旧的列表中的位置(下标)：
[1 0 2 4 7 9]
旧列表元素对应新列表的位置（下标）
[2 5 6 7 8 9]
[1 0 2 0 3 1 2 4 0 5]
[5 2 6 2 7 5 6 8 2 9]
返回去重元素的重复数量：
[2 5 6 7 8 9]
[3 2 2 1 1 1]
numpy的计算
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859# numpy 的 计算
import numpy as np
score = np.array([[80,88],[82,83],[75,81]])
print('原数组：\n',score,'\n')
# 1. 获取所有数据最大值
result = np.max(score)
print('整个数组的最大值',result,'\n')
# 获取某一个轴上的数据最大值
result = np.max(score,axis=0)
print('获取0轴上的数据最大值',result,'\n')
# 获取最小值
result = np.min(score)
print("获取整个数组的最小值：",result,'\n')
# 获取某一个轴上的数据最小值
result = np.min(score,axis=1)
print('1轴上的最小值:',result,'\n')
# 数据的比较
result = np.maximum([-2,-1,0,1,2],0) # 第一个参数中的每一个数与第二个参数比较返回大的
print('数据比较 返回大的',result,'\n')
result = np.minimum([-2,-1,0,1,2],0) # 第一个参数中的每一个数与第二个参数比较返回小的
print('数据比较 返回小的',result,'\n')
result = np.maximum([-2,-1,0,1,2],[1,-2,3,4,5]) # 接受两个参数，可以大小一致 第二个参数只是
# 一个值时 利用维度的广播机制
print('数据比较 返回大的',result,'\n')
# 求取平均值
result = np.mean(score) #获取所有数据的平均值
print('获取所有数据的平均值',result,'\n')
result = np.mean(score,axis=0)
print('获取某一行或某一列的平均值',np.mean(score,axis=0),np.mean(score,axis=1),'\n')
# 返回给定axis上的累计和
#axis=0，代表以行方式扫描，第一次扫描第一行，第二次扫描第二行，以此类推。
#第一行扫描时，没有前几行可累加，所以数值不变。扫描到第二行，累加前几行，以此类推。
arr = np.array([[1,2,3],[4,5,6]])
print('数组：\n',arr,'\n')
print(arr.cumsum(0),'\n')
print(arr.cumsum(1),'\n')
# argmin 求最小值索引
result = np.argmin(score,axis=0)
print(result,'\n')
# 求每列的标准差
result = np.std(score,axis=0)
print('每列的标准差',result,'\n')
# 极值
print('最大值和最小值的差',np.ptp(score,axis=None))
# 扩展: 方差 var , 协方差 cov ,计算平均值 average, 计算中位数 median
数组的拼接
123456789101112131415161718192021222324252627282930# 数组的拼接
# 1. 根据轴连接的数组序列
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),'\n')
# 根据轴进行堆叠
print(a)
print(b)
print('沿 0 轴 连接两个数组:')
print(np.stack((a,b),axis=0))
print('\n')
print('沿 1 轴 连接两个数组:')
print(np.stack((a,b),axis=1))
# 矩阵 垂直拼接
v1 = [[0,1,2,3,4,5],[6,7,8,9,10,11]]
v2 = [[12,13,14,15,16,17],[18,19,20,21,22,23]]
result = np.vstack((v1,v2))
print(result)
# 矩阵水平拼接
print(np.hstack((v1,v2)))
数组的分割
1234567891011121314151617181920212223242526272829# 将一个数组分割成多个子数组
'''
参数说明:
arr: 被分割的数组
indices_or_sections：如果是一个整数，就用该数平均切分，如果是一个数组，为沿轴切分位置（左开右闭）
axis: 沿着哪个维度进行切分，默认是0 ，横向切分。为1时，纵向切分
'''
arr = np.arange(9).reshape(3,3)
print('将数组分成三个大小相等的子数组：')
b = np.split(arr,3)
print(b)
# 2. numpy.hsplit 函数用于水平分割数组，通过指定要返回的相同形状的数组数量来拆分原数组
# floor() 返回数字的下舍整数
harr = np.floor(10 * np.random.random((2,6)))
print('原 array ')
print(harr)
print('拆分后：')
print(np.hsplit(harr,3))
# numpy.vsplit:沿着垂直轴分割
a = np.arange(16).reshape(4,4)
print('第一个数组：')
print(a)
print('\n')
print('沿着垂直轴分割：')
b = np.vsplit(a,2)
print(b)
运行结果：
将数组分成三个大小相等的子数组：
[array([[0, 1, 2]]), array([[3, 4, 5]]), array([[6, 7, 8]])]
原 array
[[4. 2. 2. 2. 8. 6.]
[7. 3. 8. 7. 6. 0.]]
拆分后：
[array([[4., 2.],
[7., 3.]]), array([[2., 2.],
[8., 7.]]), array([[8., 6.],
[6., 0.]])]
第一个数组：
[[ 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]])]
数组中的nan 和 inf
12345678910111213141516171819202122232425262728293031323334353637383940414243444546# nan（缺失的数据） inf(无穷大)
# 创建一个nan 和 inf
a = np.nan # 空值（缺失数据）
b = np.inf # 无穷大
print(a,type(a))
print(b,type(b))
# 判断数组中为nan的个数 （注意：float类型的数据才能赋值 nan）
t = np.arange(24,dtype=float).reshape(4,6)
print(t)
# 可以使用 np.count_nonzero()来判断非零的个数
print(np.count_nonzero(t))
# 将三行四列的数改成 nan
t[3,4] = np.nan
print(t)
# 并且 np.nan != np.nan 结果是True np.nan == np.nan False 结合这个性质进行判断
print(np.count_nonzero(t != t))
print('isnan:',np.isnan(t))
# 注意：nan 和任何数计算都为 nan
print(np.sum(t,axis=0))
# 将 nan 替换成 0
t[np.isnan(t)] = 0
print(t)
print('*' * 30)
# 练习 ：处理数组中的nan
t = np.arange(24).reshape(4,6).astype('float')
# 将数组中的一部分替换成 nan
t[1,3:] = np.nan
print(t)
# 遍历每一列 ,然后判断每一列 是否有nan
# t.shape[1] s数组中的总列数
print(t.shape[1])
for i in range(t.shape[1]):
temp_col = t[:,i]
nan_num = np.count_nonzero(temp_col != temp_col)
if nan_num != 0:
# 取出这一列中不为nan的元素
temp_col_not_nan = temp_col[temp_col==temp_col]
# 将nan替换成这一列的平均值
# np.isnan(temp_col) : 参数：数组 返回nan的索引
temp_col[np.isnan(temp_col)] = np.mean(temp_col_not_nan)
print(t)
运行结果：
nan <class 'float'>
inf <class 'float'>
[[ 0. 1. 2. 3. 4. 5.]
[ 6. 7. 8. 9. 10. 11.]
[12. 13. 14. 15. 16. 17.]
[18. 19. 20. 21. 22. 23.]]
23
[[ 0. 1. 2. 3. 4. 5.]
[ 6. 7. 8. 9. 10. 11.]
[12. 13. 14. 15. 16. 17.]
[18. 19. 20. 21. nan 23.]]
1
isnan: [[False False False False False False]
[False False False False False False]
[False False False False False False]
[False False False False True False]]
[36. 40. 44. 48. nan 56.]
[[ 0. 1. 2. 3. 4. 5.]
[ 6. 7. 8. 9. 10. 11.]
[12. 13. 14. 15. 16. 17.]
[18. 19. 20. 21. 0. 23.]]
[[ 0. 1. 2. 3. 4. 5.]
[ 6. 7. 8. nan nan nan]
[12. 13. 14. 15. 16. 17.]
[18. 19. 20. 21. 22. 23.]]
6
[[ 0. 1. 2. 3. 4. 5.]
[ 6. 7. 8. 13. 14. 15.]
[12. 13. 14. 15. 16. 17.]
[18. 19. 20. 21. 22. 23.]]
二维数组的转置
copy123456789101112131415161718192021222324# 二维数组的转置
a = np.arange(12).reshape(3,4)
print('原数组:')
print(a)
print('\n')
print('对换数组:')
print(np.transpose(a))
# 与 transpose 一致
print('转置数组：')
print(a.T)
print('\n')
# 函数用于交换数组的两个轴
t1 = np.arange(24).reshape(4,6)
re = t1.swapaxes(1,0)
print('原数组：')
print(t1)
print('\n')
print('调用 swapaxes 函数后的数组：')
print(re)
