本节主要介绍内容有：如何利用numpy创建、保存、加载数据，如何利用numpy基础函数进行排序和计算均值、方差等。
创建并保存数组
import numpy as np #导入NumPy库
arr = np.arange(100).reshape(10,10) #
np.save("save_arr",arr) #保存数组
print('保存的数组为：\n',arr)
arr1 = np.array([[1,2,3],[4,5,6]])
arr2 = np.arange(0,1.0,0.1)
np.savez('savez_arr',arr1,arr2)
print('保存的数组1为：',arr1)
print('保存的数组2为：',arr2)
保存的数组为：
[[ 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 27 28 29]
[30 31 32 33 34 35 36 37 38 39]
[40 41 42 43 44 45 46 47 48 49]
[50 51 52 53 54 55 56 57 58 59]
[60 61 62 63 64 65 66 67 68 69]
[70 71 72 73 74 75 76 77 78 79]
[80 81 82 83 84 85 86 87 88 89]
[90 91 92 93 94 95 96 97 98 99]]
保存的数组1为： [[1 2 3]
[4 5 6]]
保存的数组2为： [0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]
加载数组
loaded_data = np.load("save_arr.npy") #读取含有单个数组的文件
print('读取的数组为：\n',loaded_data)
loaded_data1 = np.load("savez_arr.npz") #读取含有多个数组的文件
print('读取的数组1为：',loaded_data1['arr_0'])
print('读取的数组2为：',loaded_data1['arr_1'])
读取的数组为：
[[ 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 27 28 29]
[30 31 32 33 34 35 36 37 38 39]
[40 41 42 43 44 45 46 47 48 49]
[50 51 52 53 54 55 56 57 58 59]
[60 61 62 63 64 65 66 67 68 69]
[70 71 72 73 74 75 76 77 78 79]
[80 81 82 83 84 85 86 87 88 89]
[90 91 92 93 94 95 96 97 98 99]]
读取的数组1为： [[1 2 3]
[4 5 6]]
读取的数组2为： [0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]
arr = np.arange(0,12,0.5).reshape(4,-1)
print('创建的数组为：',arr)
指定保存为整数
np.savetxt("arr.txt", arr, fmt="%d", delimiter=",")
loaded_data = np.loadtxt("arr.txt",delimiter=",")
print('读取的数组为：',loaded_data)
loaded_data = np.genfromtxt("arr.txt", delimiter = ",")
print('读取的数组为：',loaded_data)
读取的数组为： [[ 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. 27. 28. 29.]
[30. 31. 32. 33. 34. 35. 36. 37. 38. 39.]
[40. 41. 42. 43. 44. 45. 46. 47. 48. 49.]
[50. 51. 52. 53. 54. 55. 56. 57. 58. 59.]
[60. 61. 62. 63. 64. 65. 66. 67. 68. 69.]
[70. 71. 72. 73. 74. 75. 76. 77. 78. 79.]
[80. 81. 82. 83. 84. 85. 86. 87. 88. 89.]
[90. 91. 92. 93. 94. 95. 96. 97. 98. 99.]]
读取的数组为： [[ 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. 27. 28. 29.]
[30. 31. 32. 33. 34. 35. 36. 37. 38. 39.]
[40. 41. 42. 43. 44. 45. 46. 47. 48. 49.]
[50. 51. 52. 53. 54. 55. 56. 57. 58. 59.]
[60. 61. 62. 63. 64. 65. 66. 67. 68. 69.]
[70. 71. 72. 73. 74. 75. 76. 77. 78. 79.]
[80. 81. 82. 83. 84. 85. 86. 87. 88. 89.]
[90. 91. 92. 93. 94. 95. 96. 97. 98. 99.]]
排序，axis = 1为横轴，0为纵轴
np.random.seed(42) #设置随机种子
arr = np.random.randint(1,10,size = 10) #生成随机数
print('创建的数组为：',arr)
arr.sort() #直接排序
print('排序后数组为：',arr)
arr = np.random.randint(1,10,size = (3,3)) #生成3行3列的随机数
print('创建的数组为：',arr)
arr.sort(axis = 1) #沿着横轴排序
print('排序后数组为：',arr)
arr.sort(axis = 0) #沿着纵轴排序
print('排序后数组为：',arr)
arr = np.array([2,3,6,8,0,7])
print('创建的数组为：',arr)
print('排序后数组下标为：',arr.argsort()) #返回值为重新排序值的下标
a = np.array([3,2,6,4,5])
b = np.array([50,30,40,20,10])
c = np.array([400,300,600,100,200])
d = np.lexsort((a,b,c)) #lexsort函数只接受一个参数，即（a,b,c）
#多个键值排序是按照最后一个传入数据计算的
print('排序后数组为：',list(zip(a[d],b[d],c[d])))
创建的数组为： [7 4 8 5 7 3 7 8 5 4]
排序后数组为： [3 4 4 5 5 7 7 7 8 8]
创建的数组为： [[8 8 3]
[6 5 2]
[8 6 2]]
排序后数组为： [[3 8 8]
[2 5 6]
[2 6 8]]
排序后数组为： [[2 5 6]
[2 6 8]
[3 8 8]]
创建的数组为： [2 3 6 8 0 7]
排序后数组下标为： [4 0 1 2 5 3]
排序后数组为： [(4, 20, 100), (5, 10, 200), (2, 30, 300), (3, 50, 400), (6, 40, 600)]
arr = np.array([2,3,6,8,0,7])
print('创建的数组为：',arr)
print('排序后数组下标为：',arr.argsort()) #返回值为重新排序值的下标
a = np.array([3,2,6,4,5])
b = np.array([50,30,40,20,10])
c = np.array([400,300,600,100,200])
d = np.lexsort((a,b,c)) #lexsort函数只接受一个参数，即（a,b,c）
#多个键值排序是按照最后一个传入数据计算的
print('排序后数组为：',list(zip(a[d],b[d],c[d])))
去重
names = np.array(['小明', '小黄', '小花', '小明',
'小花', '小兰', '小白'])
print('创建的数组为：',names)
print('去重后的数组为：',np.unique(names))
#跟np.unique等价的Python代码实现过程
print('去重后的数组为：',sorted(set(names)))
ints = np.array([1,2,3,4,4,5,6,6,7,8,8,9,10]) #创建数值型数据
print('创建的数组为：',ints)
print('去重后的数组为：',np.unique(ints))
创建的数组为： ['小明' '小黄' '小花' '小明' '小花' '小兰' '小白']
去重后的数组为： ['小兰' '小明' '小白' '小花' '小黄']
去重后的数组为： ['小兰', '小明', '小白', '小花', '小黄']
创建的数组为： [ 1 2 3 4 4 5 6 6 7 8 8 9 10]
去重后的数组为： [ 1 2 3 4 5 6 7 8 9 10]
重复
arr = np.arange(5)
print('创建的数组为：',arr)
print('重复后数组为：',np.tile(arr,3)) #对数组进行重复
np.random.seed(42) #设置随机种子
arr = np.random.randint(0,10,size = (3,3))
print('创建的数组为：',arr)
print('重复后数组为：',arr.repeat(2, axis = 0)) #按行进行元素重复
print('重复后数组为：',arr.repeat(2, axis = 1)) #按列进行元素重复
创建的数组为： [0 1 2 3 4]
重复后数组为： [0 1 2 3 4 0 1 2 3 4 0 1 2 3 4]
创建的数组为： [[6 3 7]
[4 6 9]
[2 6 7]]
重复后数组为： [[6 3 7]
[6 3 7]
[4 6 9]
[4 6 9]
[2 6 7]
[2 6 7]]
重复后数组为： [[6 6 3 3 7 7]
[4 4 6 6 9 9]
[2 2 6 6 7 7]]
数值特征，和、标准差、均值、最大、最小
arr = np.arange(20).reshape(4,5)
print('创建的数组为：',arr)
print('数组的和为：',np.sum(arr)) #计算数组的和
print('数组横轴的和为：',arr.sum(axis = 0)) #沿着纵轴计算求和
print('数组纵轴的和为：',arr.sum(axis = 1)) #沿着横轴计算求和
print('数组的均值为：',np.mean(arr)) #计算数组均值
print('数组横轴的均值为：',arr.mean(axis = 0)) #沿着纵轴计算数组均值
print('数组纵轴的均值为：',arr.mean(axis = 1)) #沿着横轴计算数组均值
print('数组的标准差为：',np.std(arr)) #计算数组标准差
print('数组的方差为：',np.var(arr)) #计算数组方差
print('数组的最小值为：',np.min(arr)) #计算数组最小值
print('数组的最大值为：',np.max(arr)) #计算数组最大值
print('数组的最小元素为：',np.argmin(arr)) #返回数组最小元素的索引
print('数组的最大元素为：',np.argmax(arr)) #返回数组最大元素的索引
arr = np.arange(2,10)
print('创建的数组为：',arr)
print('数组元素的累计和为：',np.cumsum(arr)) #计算所有元素的累计和
print('数组元素的累计积为：',np.cumprod(arr)) #计算所有元素的累计积
创建的数组为： [[ 0 1 2 3 4]
[ 5 6 7 8 9]
[10 11 12 13 14]
[15 16 17 18 19]]
数组的和为： 190
数组横轴的和为： [30 34 38 42 46]
数组纵轴的和为： [10 35 60 85]
数组的均值为： 9.5
数组横轴的均值为： [ 7.5 8.5 9.5 10.5 11.5]
数组纵轴的均值为： [ 2. 7. 12. 17.]
数组的标准差为： 5.766281297335398
数组的方差为： 33.25
数组的最小值为： 0
数组的最大值为： 19
数组的最小元素为： 0
数组的最大元素为： 19
创建的数组为： [2 3 4 5 6 7 8 9]
数组元素的累计和为： [ 2 5 9 14 20 27 35 44]
数组元素的累计积为： [ 2 6 24 120 720 5040 40320 362880]
读取文件，实现数值计算
import os
os.getcwd()#查看当前工作目录
os.chdir("D:\\数据分析与应用\\第2章\\01-任务程序\\data")#改变工作目录
# 代码 2-52
iris_sepal_length = np.loadtxt("iris_sepal_length.txt") #读取文件
print('花萼长度为：',iris_sepal_length)
iris_sepal_length.sort() #对数据进行排序
print('排序后的花萼长度为：',iris_sepal_length)
#去除重复值
print('去重后的花萼长度为：',np.unique(iris_sepal_length))
print('花萼长度的总和为：',np.sum(iris_sepal_length)) #计算数组总和
#计算所有元素的累计和
print('花萼长度的累计和为：',np.cumsum(iris_sepal_length))
print('花萼长度的均值为：',np.mean(iris_sepal_length)) #计算数组均值
#计算数组标准差
print('花萼长度的标准差为：',np.std(iris_sepal_length))
print('花萼长度的方差为：',np.var(iris_sepal_length)) #计算数组方差
print('花萼长度的最小值为：',np.min(iris_sepal_length)) #计算最小值
print('花萼长度的最大值为：',np.max(iris_sepal_length)) #计算最大值
