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))  #计算最大值