NumPy库常见操作
一、安装与导入NumPy库
1. 安装NumPy库
pip install numpy
2. 导入NumPy库
import numpy as np
二、创建数组（np.array）
1. 创建一维数组
arr1 = np.array([1, 2, 3, 4]) #创建一维数组
print(' 创建的数组为： ',arr1)
# 创建的数组为： [1 2 3 4]
2. 创建二维数组
arr2 = np.array([[1, 2, 3, 4],[4, 5, 6, 7], [7, 8, 9, 10]])
print('创建的数组为：\n',arr2)
print('数组类型为：',arr2.dtype)
print('数组元素个数为：',arr2.size)
print('数组每个元素大小为：',arr2.itemsize)
# 创建的数组为：
# [[ 1 2 3 4]
# [ 4 5 6 7]
# [ 7 8 9 10]]
# 数组类型为： int32
# 数组元素个数为： 12
# 数组每个元素大小为： 4
3. 生成一个指定起止与步长的等差数列（arange函数和linspace函数）
print('使用arange函数创建的数组为：\n',np.arange(0,1,0.1))
# 使用arange函数创建的数组为：
# [0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]
print('使用linspace函数创建的数组为：\n',np.linspace(0, 1, 11))
# 使用linspace函数创建的数组为：
# [0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1. ]
二者的区别：
arange()类似于内置函数range()，通过指定开始值、终值和步长创建表示等差数列的一维数组，得到的结果数组不包含终值。
linspace()通过指定开始值、终值和元素个数创建表示等差数列的一维数组，可以通过endpoint参数指定是否包含终值，默认值为True，即包含终值。
4. 生成对数间隔的数组（logspace函数）
np.logspace(start=开始值，stop=结束值，num=元素个数，base=指定对数的底, endpoint=是否包含结束值)
默认以10为底
print('使用logspace函数创建的数组为：\n',np.logspace(0, 3, 4))
# 使用logspace函数创建的数组为：
# [ 1. 10. 100. 1000.]
5. 生成全0/全1数组（zeros、ones函数）
（1）全0数组
print('使用zeros函数创建的数组为：\n',np.zeros((2,3)))
# 使用zeros函数创建的数组为：
# [[0. 0. 0.]
# [0. 0. 0.]]
（2）全1数组
print('使用ones函数的数组为：\n',np.ones((2,3)))
# 使用ones函数的数组为：
# [[1. 1. 1.]
# [1. 1. 1.]]
6. 生成随机数组（random类）
（1）np.random.random
默认为生成一个随机的浮点数，范围是(0,1)，也可以通过参数size设置返回数据的个数
print('生成的随机数组为：\n',np.random.random(10))
# 生成的随机数组为：
# [0.24710873 0.25913565 0.12110844 0.67591216 0.45363741 0.38376963 0.69034393 0.24827717 0.30153083 0.35914316]
（2）np.random.rand
返回一个或一组服从“0~1”均匀分布的随机样本值。随机样本取值范围是[0,1)，不包括1。
print('生成的随机数组为：\n',np.random.rand(2,5))
# 生成的随机数组为：
# [[0.18514936 0.54823137 0.4486657 0.67603573 0.661473 ]
# [0.85339296 0.41840348 0.4622521 0.1459996 0.03022868]]
（3）np.random.randn
返回服从均值为0，方差为1的标准正态分布的取值
print('生成的随机数组为：\n',np.random.randn(2,5))
# 生成的随机数组为：
# [[ 0.18487309 -0.89845606 -0.3353127 -0.55799953 1.16279982]
# [-0.07851519 0.04149048 1.1096261 0.18613152 1.22188382]]
（4）np.random.randint
返回一个随机整型数，范围从低（包括）到高（不包括），即[low, high)。
如果没有写参数high的值，则返回[0,low)的值。
print('生成的随机数组为：\n',np.random.randint(1,100,size = [2,5]))
# 生成的随机数组为：
# [[88 79 27 62 97]
# [28 82 31 63 89]]
7. 生成单位矩阵（eye函数）
print('使用eye函数创建的数组为：\n',np.eye(3))
# 使用eye函数创建的数组为：
# [[1. 0. 0.]
# [0. 1. 0.]
# [0. 0. 1.]]
8. 矩阵对角线递增（diag函数）
print('使用diag函数创建的数组为：\n',np.diag([1,2,3,4]))
# 使用diag函数创建的数组为：
# [[1 0 0 0]
# [0 2 0 0]
# [0 0 3 0]
# [0 0 0 4]]
三、改变数组的shape
1. 一维数组转二维数组
arr2.shape = 4,3 # 重新设置shape
print('重新设置shape 后的arr2 为：\n',arr2)
arr = np.arange(12) # 创建一维数组
print('创建的一维数组为：\n',arr)
arr = arr.reshape(3,4)
print('新的一维数组为：\n',arr) # 设置数组的形状
print('数组维度为：',arr.ndim) # 查看数组维度
# 重新设置shape 后的arr2 为：
# [[ 1 2 3]
# [ 4 4 5]
# [ 6 7 7]
# [ 8 9 10]]
# 创建的一维数组为：
# [ 0 1 2 3 4 5 6 7 8 9 10 11]
# 新的一维数组为：
# [[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]
# 数组维度为： 2
2. 将二维数组展平为一维数组
print('数组展平后为：',arr.ravel())
# 数组展平后为： [ 0 1 2 3 4 5 6 7 8 9 10 11]
print('数组展平为：',arr.flatten()) # 默认横向展平，或者a或A
print('数组展平为：',arr.flatten(order='F')) # f或F是纵向展平
# 数组展平为： [ 0 1 2 3 4 5 6 7 8 9 10 11]
# 数组展平为： [ 0 4 8 1 5 9 2 6 10 3 7 11]
四、数组的切片操作
1. 一维数组切片
arr = np.arange(10)
print('索引结果为：',arr[5]) # 用整数作为下标可以获取数组中的某个元素
print('索引结果为：',arr[3:5]) # 用范围作为下标获取数组的一个切片，包括arr[3]不包括arr[5]
print('索引结果为：',arr[:5]) # 省略开始下标，表示从arr[0]开始
print('索引结果为：',arr[-1]) #下标可以使用负数，-1表示从数组后往前数的第一个元素
arr[2:4] = 100,101
print('索引结果为：',arr) # 下标还可以用来修改元素的值
print('索引结果为：',arr[1:-1:2]) # 范围中的第三个参数表示步长，2表示隔一个元素取一个元素
print('索引结果为：',arr[5:1:-2]) # 步长为负数时，开始下标必须大于结束下标
# 索引结果为： 5
# 索引结果为： [3 4]
# 索引结果为： [0 1 2 3 4]
# 索引结果为： 9
# 索引结果为： [ 0 1 100 101 4 5 6 7 8 9]
# 索引结果为： [ 1 101 5 7]
# 索引结果为： [ 5 101]
2. 二维数组切片
arr = np.array([[1, 2, 3, 4, 5],[4, 5, 6, 7, 8], [7, 8, 9, 10, 11]])
print('创建的二维数组为：\n',arr)
print('索引结果为：',arr[0,3:5]) # 索引第0行中第3和第4列的元素
print('索引结果为：\n',arr[1:,2:]) # 索引第2和第3行中第3列、第4列和第5列的元素
print('索引结果为：',arr[:,2]) # 索引第2列的元素
print('索引结果为：',arr[[(0,1,2),(1,2,3)]]) # 从两个序列的对应位置取出两个整数组成下标：arr[0,1], arr[1,2], arr[2,3]
print('索引结果为：\n',arr[1:,(0,2,3)]) # 索引第2、3行中第0、2、3列的元素
mask = np.array([1,0,1],dtype = np.bool) # mask是一个布尔数组，它索引第1、3行中第3列的元素
print('索引结果为：',arr[mask,2])
# 创建的二维数组为：
# [[ 1 2 3 4 5]
# [ 4 5 6 7 8]
# [ 7 8 9 10 11]]
# 索引结果为： [4 5]
# 索引结果为：
# [[ 6 7 8]
# [ 9 10 11]]
# 索引结果为： [3 6 9]
# 索引结果为： [ 2 6 10]
# 索引结果为：
# [[ 4 6 7]
# [ 7 9 10]]
# 索引结果为： [3 9]
五、数组的拼接与分割
1. 数组的拼接
arr1 = np.arange(12).reshape(3,4)
print('创建的数组1为：\n',arr1)
arr2 = arr1*3
print('创建的数组2为：\n',arr2)
print('横向组合为：\n',np.hstack((arr1,arr2))) # hstack函数，横向组合
print('纵向组合为：\n',np.vstack((arr1,arr2))) # vstack函数，纵向组合
print('横向组合为：\n',np.concatenate((arr1,arr2),axis = 1)) # concatenate函数横向组合
print('纵向组合为：\n',np.concatenate((arr1,arr2),axis = 0)) # concatenate函数纵向组合
# 创建的数组1为：
# [[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]
# 创建的数组2为：
# [[ 0 3 6 9]
# [12 15 18 21]
# [24 27 30 33]]
# 横向组合为：
# [[ 0 1 2 3 0 3 6 9]
# [ 4 5 6 7 12 15 18 21]
# [ 8 9 10 11 24 27 30 33]]
# 纵向组合为：
# [[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]
# [ 0 3 6 9]
# [12 15 18 21]
# [24 27 30 33]]
# 横向组合为：
# [[ 0 1 2 3 0 3 6 9]
# [ 4 5 6 7 12 15 18 21]
# [ 8 9 10 11 24 27 30 33]]
# 纵向组合为：
# [[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]
# [ 0 3 6 9]
# [12 15 18 21]
# [24 27 30 33]]
2. 数组的分割
arr = np.arange(16).reshape(4,4)
print('创建的二维数组为：\n',arr)
print('横向分割为：\n',np.hsplit(arr, 2)) # hsplit函数横向分割
print('纵向分割为：\n',np.vsplit(arr, 2)) # vsplit函数纵向分割
print('横向分割为：\n',np.split(arr, 2, axis=1)) # split函数横向分割
print('纵向分割为：\n',np.split(arr, 2, axis=0)) # split函数纵向分割
# 创建的二维数组为：
# [[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]
# [12 13 14 15]]
# 横向分割为：
# [array([[ 0, 1],
# [ 4, 5],
# [ 8, 9],
# [12, 13]]), array([[ 2, 3],
# [ 6, 7],
# [10, 11],
# [14, 15]])]
# 纵向分割为：
# [array([[0, 1, 2, 3],
# [4, 5, 6, 7]]), array([[ 8, 9, 10, 11],
# [12, 13, 14, 15]])]
# 横向分割为：
# [array([[ 0, 1],
# [ 4, 5],
# [ 8, 9],
# [12, 13]]), array([[ 2, 3],
# [ 6, 7],
# [10, 11],
# [14, 15]])]
# 纵向分割为：
# [array([[0, 1, 2, 3],
# [4, 5, 6, 7]]), array([[ 8, 9, 10, 11],
# [12, 13, 14, 15]])]
六、NumPy数值计算基础
1. 数组的计算
（1）数组的基本计算
arr1 = np.array([[0,0,0],[1,1,1],[2,2,2],[3,3,3]])
print('创建的数组1为：\n',arr1)
arr2 = np.array([1,2,3])
print('创建的数组2为：',arr2)
print('数组相加结果为：\n',arr1 + arr2)
print('数组相乘结果为：\n',arr1 * arr2)
print('数组相除结果为：\n',arr1 / arr2)
# 创建的数组1为：
# [[0 0 0]
# [1 1 1]
# [2 2 2]
# [3 3 3]]
# 创建的数组2为： [1 2 3]
# 数组相加结果为：
#[[1 2 3]
# [2 3 4]
# [3 4 5]
# [4 5 6]]
# 数组相乘结果为：
# [[0 0 0]
# [1 2 3]
# [2 4 6]
# [3 6 9]]
# 数组相除结果为：
# [[0. 0. 0. ]
# [1. 0.5 0.33333333]
# [2. 1. 0.66666667]
# [3. 1.5 1. ]]
（2）数组的比较
x = np.array([1,3,5])
y = np.array([2,3,4])
print('数组比较结果为：',x < y)
print('数组比较结果为：',x > y)
print('数组比较结果为：',x == y)
print('数组比较结果为：',x >= y)
print('数组比较结果为：',x <= y)
print('数组比较结果为：',x != y)
# 数组比较结果为： [ True False False]
# 数组比较结果为： [False False True]
# 数组比较结果为： [False True False]
# 数组比较结果为： [False True True]
# 数组比较结果为： [ True True False]
# 数组比较结果为： [ True False True]
（3）数组的逻辑运算
print('数组逻辑运算结果为：',np.all(x == y)) # np.all()表示逻辑and
print('数组逻辑运算结果为：',np.any(x == y)) # np.any()表示逻辑or
# 数组逻辑运算结果为： False
# 数组逻辑运算结果为： True
2. 数组的排序
np.random.seed(42) # 设置随机种子
arr = np.random.randint(1,10,size = 10) # 生成随机数
print('创建的数组为：\n',arr)
arr.sort() #直接排序
print('排序后数组为：\n',arr)
arr = np.random.randint(1,10,size = (3,3)) # 生成3行3列的随机数
print('创建的数组为：\n',arr)
arr.sort(axis = 1) # 沿着横轴排序
print('排序后数组为：\n',arr)
arr.sort(axis = 0) # 沿着纵轴排序
print('排序后数组为：\n',arr)
# 创建的数组为：
# [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]]
arr = np.array([2,3,6,8,0,7])
print('创建的数组为：',arr)
print('排序后数组为：',arr.argsort()) # 返回值为重新排序值的下标
# 创建的数组为： [2 3 6 8 0 7]
# 排序后数组下标为： [4 0 1 2 5 3]
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])))
# 排序后数组为： [(4, 20, 100), (5, 10, 200), (2, 30, 300), (3, 50, 400), (6, 40, 600)]
3. 数组的重复和去重
（1）数组的重复
arr = np.arange(5)
print('创建的数组为：',arr)
print('重复后数组为：',np.tile(arr,3)) # 对数组进行重复
# 创建的数组为： [0 1 2 3 4]
# 重复后数组为： [0 1 2 3 4 0 1 2 3 4 0 1 2 3 4]
np.random.seed(42) # 设置随机种子
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)) # 按列进行元素重复
# 创建的数组为：
# [[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]]
（2）数组的去重
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]
5. 数组的基本信息
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)) # 返回数组最大元素的索引
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
# 数组元素的累计和为： [ 0 1 3 6 10 15 21 28 36 45 55 66 78 91 105 120 136 153 171 190]
# 数组元素的累计积为： [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
七、NumPy矩阵与通用函数（np.matrix）
1. 矩阵的创建
matr1 = np.mat("1 2 3;4 5 6;7 8 9") # 使用分号隔开数据
print('创建的矩阵为：\n',matr1)
matr2 = np.matrix([[123],[456],[789]])
print('创建的矩阵为：\n',matr2)
# 创建的矩阵为：
# [[1 2 3]
# [4 5 6]
# [7 8 9]]
# 创建的矩阵为：
# [[123]
# [456]
# [789]]
arr1 = np.eye(3)
print('创建的数组1为：\n', arr1)
arr2 = 3*arr1
print('创建的数组2为：\n',arr2)
print('创建的矩阵为：\n',np.bmat("arr1 arr2; arr1 arr2"))
# 创建的数组1为：
# [[1. 0. 0.]
# [0. 1. 0.]
# [0. 0. 1.]]
# 创建的数组2为：
# [[3. 0. 0.]
# [0. 3. 0.]
# [0. 0. 3.]]
# 创建的矩阵为：
# [[1. 0. 0. 3. 0. 0.]
# [0. 1. 0. 0. 3. 0.]
# [0. 0. 1. 0. 0. 3.]
# [1. 0. 0. 3. 0. 0.]
# [0. 1. 0. 0. 3. 0.]
# [0. 0. 1. 0. 0. 3.]]
2. 矩阵的计算
（1）矩阵的基本计算
matr1 = np.mat("1 2 3;4 5 6;7 8 9") #创建矩阵
print('创建的矩阵为：\n',matr1)
matr2 = matr1*3 # 矩阵与数相乘
print('创建的矩阵为：\n',matr2)
print('矩阵相加结果为：\n',matr1+matr2) # 矩阵相加
print('矩阵相减结果为：\n',matr1-matr2) # 矩阵相减
print('矩阵相乘结果为：\n',matr1*matr2) # 矩阵相乘
print('矩阵对应元素相乘结果为：\n',np.multiply(matr1,matr2))
# 创建的矩阵为：
# [[1 2 3]
# [4 5 6]
# [7 8 9]]
# 创建的矩阵为：
# [[ 3 6 9]
# [12 15 18]
# [21 24 27]]
# 矩阵相加结果为：
# [[ 4 8 12]
# [16 20 24]
# [28 32 36]]
# 矩阵相减结果为：
# [[ -2 -4 -6]
# [ -8 -10 -12]
# [-14 -16 -18]]
# 矩阵相乘结果为：
# [[ 90 108 126]
# [198 243 288]
# [306 378 450]]
# 矩阵对应元素相乘结果为：
# [[ 3 12 27]
# [ 48 75 108]
# [147 192 243]]
x = np.array([1,2,3])
y = np.array([4,5,6])
print('数组相加结果为：',x + y) # 数组相加
print('数组相减结果为：',x - y) # 数组相减
print('数组相乘结果为：',x * y) # 数组相乘
print('数组相除结果为：',x / y) # 数组相除
print('数组幂运算结果为：',x ** y) # 数组幂运算
# 数组相加结果为： [5 7 9]
# 数组相减结果为： [-3 -3 -3]
# 数组相乘结果为： [ 4 10 18]
# 数组相除结果为： [0.25 0.4 0.5 ]
# 数组幂运算结果为： [ 1 32 729]
（2）矩阵的转置
print('矩阵转置结果为：\n',matr1.T) # 转置
print('矩阵共轭转置结果为：\n',matr1.H) # 共轭转置（实数的共轭就是其本身）
print('矩阵的逆矩阵结果为：\n',matr1.I) # 逆矩阵
print('矩阵的二维数组结果为：\n',matr1.A) # 返回二维数组的视图
# 矩阵转置结果为：
# [[1 4 7]
# [2 5 8]
# [3 6 9]]
# 矩阵共轭转置结果为：
# [[1 4 7]
# [2 5 8]
# [3 6 9]]
# 矩阵的逆矩阵结果为：
# [[-4.50359963e+15 9.00719925e+15 -4.50359963e+15]
# [ 9.00719925e+15 -1.80143985e+16 9.00719925e+15]
# [-4.50359963e+15 9.00719925e+15 -4.50359963e+15]]
# 矩阵的二维数组结果为：
# [[1 2 3]
# [4 5 6]
# [7 8 9]]
八、数组的保存与读取（.npy文件）
import numpy as np
arr = np.arange(100).reshape(10,10) #创建一个数组
np.save("../tmp/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为：\n',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'])
arr = np.arange(0,12,0.5).reshape(4,-1)
print('创建的数组为：\n',arr)
# fmt ="%d"为指定保存为整数
np.savetxt("../arr.txt", arr, fmt="%d", delimiter=",")
# 读入的时候也需要指定逗号分隔
loaded_data = np.loadtxt("../arr.txt",delimiter=",")
print('读取的数组为：\n',loaded_data)
# 创建的数组为：
# [[ 0. 0.5 1. 1.5 2. 2.5]
# [ 3. 3.5 4. 4.5 5. 5.5]
# [ 6. 6.5 7. 7.5 8. 8.5]
# [ 9. 9.5 10. 10.5 11. 11.5]]
# 读取的数组为：
# [[ 0. 0. 1. 1. 2. 2.]
# [ 3. 3. 4. 4. 5. 5.]
# [ 6. 6. 7. 7. 8. 8.]
# [ 9. 9. 10. 10. 11. 11.]]
九、数据类型转换
print('转换结果为：',np.float64(42)) # 整型转换为浮点型
print('转换结果为：',np.int8(42.0)) # 浮点型转换为整型
print('转换结果为：',np.bool(42)) # 整型转换为布尔型
print('转换结果为：',np.bool(0)) # 整型转换为布尔型
print('转换结果为：',np.float(True)) # 布尔型转换为浮点型
print('转换结果为：',np.float(False)) # 布尔型转换为浮点型
# 转换结果为： 42.0
# 转换结果为： 42
# 转换结果为： True
# 转换结果为： False
# 转换结果为： 1.0
# 转换结果为： 0.0
十、NumPy综合应用实例
import numpy as np
iris_sepal_length = np.loadtxt("../data/iris_sepal_length.csv", delimiter=",") #读取文件
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)) #计算最大值
版权声明：本文为NKhth原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。