#读/写文件
#numpy的文件读写主要有二进制的文件读写和文件列表形式的数据读/写俩种方式
#save函数以二进制的格式保存数据
#load函数从二进制的文件中读取数据
#save函数的语法格式如下：
"""
np.save(file,arr,allow_pickle=True,fix_imports=True)
file:为要保存的文件名称，需要指定文件保存的路径
arr：为需要保存的数组，拓展名.npy为自动添加
"""
'\nnp.save(file,arr,allow_pickle=True,fix_imports=True)\n file:为要保存的文件名称，需要指定文件保存的路径\n arr：为需要保存的数组，拓展名.npy为自动添加\n'
#二进制数据存储
import numpy as np
arr = np.arange(100).reshape(10,10) #创建一个数组
np.save('../tmp/save_arr',arr)
print('保存的数组为：\n',arr)
保存的数组为：
[[ 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]]
#如果将多个数组保存到一个文件中，可以使用savez函数，其文件的拓展名为.npz
#多个数组存储
arr1 = np.array([[1,2,3],[4,5,6]])
arr2 = np.arange(0,1.0,0.1)
np.savez('../tmp/savez_arr',arr1,arr2)
print('保存的数组1为：\n',arr1)
print('保存的数组2为：\n',arr2)
保存的数组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('../tmp/save_arr.npy')
print('读取到的数组为：\n',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]]
#读取含有多个数组的文件
loaded_data1 = np.load('../tmp/savez_arr.npz')
print('读取的数组为1为：\n',loaded_data1['arr_0'])
print('读取的数组为2为：\n',loaded_data1['arr_1'])
读取的数组为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]
#注意：存储时可以省略扩展名，但读取时不能省略扩展名
在实际的数据分析中，更多的使用文本格式的数据，如txt或CSV格式，因此经常使用savetxt函数，loadtxt函数，genfromtxt函数 执行文本格式数据的读取任务
"""
savetxt函数可以将数组写到某种分隔符隔开的文本文件中，语法如下：
np.savetxt(fname,X,fmt='%.18e',delimiter=' ',newline='\n',header='',footer='',comments='# ')
fname：为文件名
X：为数组数据
fmt:代表数据存储类型，%d代表整数
delimiter:数据分隔符
loadtxt函数执行的是相反的操作，即把文件加载到一个二维数组中
genfromtxt函数和loadtxt函数相似，不过他面向的是结构化数组和缺失数组，通常使用三个参数：
1：存放数据的文件名fname
2：用于分割字符参数‘delimiter’
3:是否含有列标题参数‘names’
"""
"\nsavetxt函数可以将数组写到某种分隔符隔开的文本文件中，语法如下：\nnp.savetxt(fname,X,fmt='%.18e',delimiter=' ',newline='\n',header='',footer='',comments='# ')\n fname：为文件名\n X：为数组数据\n delimiter:数据分隔符\nloadtxt函数执行的是相反的操作，即把文件加载到一个二维数组中\ngenfromtxt函数和loadtxt函数相似，不过他面向的是结构化数组和缺失数组，通常使用三个参数：\n 1：存放数据的文件名fname\n 2：用于分割字符参数‘delimiter’\n 3:是否含有列标题参数‘names’\n"
#文件存储与读取
arr = np.arange(0,12,0.5).reshape(4,-1)
np.savetxt('../tmp/arr.txt',arr,fmt="%d",delimiter=",")
#注意：读入的时候也需要指定分隔符
loaded_data = np.loadtxt('../tmp/arr.txt',delimiter=",")
print('读取的数组为：\n',loaded_data)
#使用genfromtxt函数读取数组
loaded_data = np.genfromtxt('../tmp/arr.txt',delimiter=",")
print('读取的数组为：\n',loaded_data)
读取的数组为：
[[ 0. 0. 1. 1. 2. 2.]
[ 3. 3. 4. 4. 5. 5.]
[ 6. 6. 7. 7. 8. 8.]
[ 9. 9. 10. 10. 11. 11.]]
读取的数组为：
[[ 0. 0. 1. 1. 2. 2.]
[ 3. 3. 4. 4. 5. 5.]
[ 6. 6. 7. 7. 8. 8.]
[ 9. 9. 10. 10. 11. 11.]]
#使用函数进行简单的统计分析
"""
numpy的排序方式主要可以概括为直接排序和间接排序俩种
直接排序指对数值直接进行排序
间接排序是指根据一个或多个键对数据集进行排序
在numpy中，直接排序经常使用sort函数，间接排序经常使用argsort函数和lexsort函数
"""
# 使用sort函数进行排序
?
arr = np.random.randint(1,10,size=10) #生成随机数组
?
print('创建的数组为：\n',arr)
?
#直接排序
?
arr.sort()
?
print('排序后的数组为：\n',arr)
创建的数组为：
[3 2 8 2 9 9 6 6 9 4]
排序后的数组为：
[2 2 3 4 6 6 8 9 9 9]
#生成3行3列的随机数组
arr = np.random.randint(1,10,size=(3,3))
print('创建的数组为：\n',arr)
arr.sort(axis=1) #沿着横轴排序
print('排序后的数组为：\n',arr)
#沿着纵轴排序
arr.sort(axis=0)
print('排序后数组为：\n',arr)
创建的数组为：
[[2 8 6]
[9 5 2]
[2 2 6]]
排序后的数组为：
[[2 6 8]
[2 5 9]
[2 2 6]]
排序后数组为：
[[2 2 6]
[2 5 8]
[2 6 9]]
#使用argsort函数和lexsort函数，可以在给定的一个或者多个键时，
#得到一个由整数构成的索引数组，索引值表示数据在新的序列中的位置
#使用argsort函数进行排序
arr = np.array([2,3,6,8,0,7,1])
print('创建的数组为：\n',arr)
print('排序后数组为：\n',arr.argsort()) #返回值为重新排序值的下标
创建的数组为：
[2 3 6 8 0 7 1]
排序后数组为：
[4 6 0 1 2 5 3]
#lexsort函数可以一次性对满足多个键的数组执行间接排序
#使用lexsort函数进行排序
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('排序后数组为：\n',list(zip(a[d],b[d],c[d])))
排序后数组为：
[(4, 20, 100), (5, 10, 200), (2, 30, 300), (3, 50, 400), (6, 40, 600)]
#去重和重复数据
"""
在统计分析的工作中，难免会出现“脏”数据的情况，重复数据就是脏数据的情况之一
在numpy中可以使用unique函数找出数组中的唯一值并返回已排序的结果
"""
'\n在统计分析的工作中，难免会出现“脏”数据的情况，重复数据就是脏数据的情况之一\n在numpy中可以使用unique函数找出数组中的唯一值并返回已排序的结果\n'
#数组内数据去重
names = np.array(['小明','小黄','小花','小明','小花','小兰','小白'])
print('创建的数组为：\n',names)
print('去重后的数组为：\n',np.unique(names))
创建的数组为：
['小明' '小黄' '小花' '小明' '小花' '小兰' '小白']
去重后的数组为：
['小兰' '小明' '小白' '小花' '小黄']
#创建数值型数据
inits = np.array([1,2,3,3,4,3,5,6,5,6,7,8,9])
print('创建的数组为：\n',inits)
print('去重后的数组为：',np.unique(inits))
创建的数组为：
[1 2 3 3 4 3 5 6 5 6 7 8 9]
去重后的数组为： [1 2 3 4 5 6 7 8 9]
"""
另一种情况，在统计分析中也经常遇到，及需要把一个数据重复若干次
在numpy中主要使用tile函数和repeat函数实现数据重复
numpy.tile(A,reps)
A:指定重复的数组
reps：指定重复的次数
repeat函数格式如下：
numpy.repeat(a,repeats,axis=None)
a:指定需要重复的数组元素
repeats：指定重复次数
axis：指定沿着哪个轴进行重复
#这俩个函数的主要区别在于tile函数是对数组进行重复操作，repeat函数是对数组中的每个元素进行重复操作
"""
#使用tile函数实现数据重复
arr = np.arange(5)
print('创建的数组为：\n',arr)
print('重复后的数组为：\n',np.tile(arr,3)) #对数组进行重复
创建的数组为：
[0 1 2 3 4]
重复后的数组为：
[0 1 2 3 4 0 1 2 3 4 0 1 2 3 4]
#使用repeat函数实现数据重复
arr = np.random.randint(0,10,size=(3,3))
print('创建的数组为：\n',arr)
print('重复后数组为：\n',arr.repeat(2,axis=0)) #按行进行元素重复
print('重复后数组为：\n',arr.repeat(2,axis=1)) #按列进行元素重复
创建的数组为：
[[5 3 1]
[2 8 0]
[4 2 7]]
重复后数组为：
[[5 3 1]
[5 3 1]
[2 8 0]
[2 8 0]
[4 2 7]
[4 2 7]]
重复后数组为：
[[5 5 3 3 1 1]
[2 2 8 8 0 0]
[4 4 2 2 7 7]]
#常用的统计函数
arr = np.arange(20).reshape(4,5)
print('创建的数组为：\n',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)) #返回数组最大元素的索引
创建的数组为：
[[ 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
以上函数的计算均为聚合计算，直接显示计算的最终结果
在numpy中cumsum和cumprod函数采用不聚合计算
产生一个由中间结果组成的数组
arr= np.arange(2,10)
print('创建的数组为：',arr)
print('数组元素的累计和为：\n',np.cumsum(arr)) #计算所有元素的累计和
print('数组元素的累计积为：\n',np.cumprod(arr)) #计算所有元素的累积积
创建的数组为： [2 3 4 5 6 7 8 9]
数组元素的累计和为：
[ 2 5 9 14 20 27 35 44]
数组元素的累计积为：
[ 2 6 24 120 720 5040 40320 362880]