Python 常用库之一：Numpy
1，Python 常用库之一：Numpy
Numpy 支持大量的维度数组和矩阵运算，对数组运算提供了大量的数学函数库！
Numpy 比 Python 列表更具优势，其中一个优势便是速度。在对大型数组执行操作时，Numpy 的速度比 Python 列表的速度快了好几百。因为 Numpy 数组本身能节省内存，并且 Numpy 在执行算术、统计和线性代数运算时采用了优化算法。
Numpy 的另一个强大功能是具有可以表示向量和矩阵的多维数组数据结构。Numpy 对矩阵运算进行了优化，使我们能够高效地执行线性代数运算，使其非常适合解决机器学习问题。
与 Python 列表相比，Numpy 具有的另一个强大优势是具有大量优化的内置数学函数。这些函数使你能够非常快速地进行各种复杂的数学计算，并且用到很少代码（无需使用复杂的循环），使程序更容易读懂和理解。
Numpy 简单创建数组
复制代码
1 a = [1, 2, 3]
2 b = np.array(a)
3 c = np.array([[0, 1, 2, 10],
4 [12, 13, 100, 101],
5 [102, 110, 112, 113]], int)
6 print(c)
7 print(b)
复制代码
创建数值为 1 的数组
Numpy.ones(参数 1：shape，数组的形状；参数 2：dtype， 数值类型)
1 array_one = np.ones([10, 10], dtype=np.int)
2 print(array_one)
创建数值为 0 的数组
Numpy.zeros(参数 1：shape，数组的形状；参数 2：dtype， 数值类型)
1 array_zero = np.zeros([10, 9], dtype=np.float)
2 print(array_zero)
创建指定数值的数组
Numpy.full(参数 1：shape，数组的形状； 参数 2：constant value，数组填充的常数值；参数 3：dtype， 数值类型)
1 array_full = np.full((2, 3), 5)
2 print(array_full)
创建单位矩阵
Numpy.eye(参数 1：N，方阵的维度)
1 array_eye = np.eye(5)
2 print(array_eye)
创建对角矩阵
Numpy.diag(参数 1：v，主对角线数值，参数 2：k，对角线元素)：K = 0 表示主对角线，k>0 的值选择在主对角线之上的对角线中的元素，k<0 的值选择在主对角线之下的对角线中的元素
1 array_diag = np.diag([10, 20, 30, 40])
2 print(array_diag)
Numpy 查看数组属性
数组元素个数：b.size
数组形状：b.shape
数组维度：b.ndim
数组元素类型：b.dtype
复制代码
数组元素个数：3
print(b.size)
数组形状:(3,)
print(b.shape)
数组维度:1
print(b.ndim)
数组元素类型:int32
print(b.dtype)
复制代码
矩阵第一维的长度：shape[0] # 行
矩阵第二维的长度：shape[1] # 列
…….
复制代码
1 array_rand = np.random.rand(10, 10, 4)
2 print(array_rand)
3 print(array_rand.ndim)
4 print(array_rand.shape[0])
5 print(array_rand.shape[1])
6 print(array_rand.shape[2])
复制代码
Numpy 创建随机数组（np.random）
均匀分布
创建指定形状的数组，数值范围在 0~1 之间
1 array_rand = np.random.rand(10, 10, 4)
2 print(array_rand)
3 print(array_rand.ndim)
创建指定范围内的一个数：Numpy.random.uniform(low, high, size=None)
1 array_uniform = np.random.uniform(0, 100, size=5)
2 print(array_uniform)
创建指定范围的一个整数：Numpy.random.randint(low, high, size=None)
1 array_int = np.random.randint(0, 100, size=3)
2 print(array_int)
3 print(array_int.size)
Numpy.arange()和 Numpy.linspace() 函数也可以均匀分布
Numpy.arange(start, stop, step)：创建一个秩为 1 的 array，其中包含位于半开区间 [start, stop) 内并均匀分布的值，step 表示两个相邻值之间的差。
Numpy.linspace(start, stop, N)：创建 N 个在闭区间 [start, stop] 内均匀分布的值。
1 X = np.arange(1, 5, 2, dtype=np.int)
2 print(X)
3 y = np.linspace(1, 5, 3)
4 print(y)
正态分布
创建给定均值、标准差、维度的正态分布：Numpy.random.normal(loc, scale, size)
1 # 正态生成 4 行 5 列的二位数组
2 array_normal = np.random.normal(loc=1.75, scale=0.1, size=[4, 5])
3 print(array_normal)
4 print(array_normal.ndim)
Numpy 数组操作
数组的索引
array[start : end]
array[start:]
array[:end]
布尔型索引：array[array>10 & array<20]
np.random.seed(10)
arr = np.random.randint(0,100,size=(5,6))
arr
array([[9, 15, 64, 28, 89, 93],
[29, 8, 73, 0, 40, 36],
[16, 11, 54, 88, 62, 33],
[72, 78, 49, 51, 54, 77],
[69, 13, 25, 13, 92, 86]])
arr1,2
array([[29, 8, 73, 0, 40, 36],
[16, 11, 54, 88, 62, 33]])
数组的切片
arr[0:2]
array([[9, 15, 64, 28, 89, 93],
[29, 8, 73, 0, 40, 36]])
#获取二维数组前两列
arr[:,0:2]
array([[9, 15],
[29, 8],
[16, 11],
[72, 78],
[69, 13]])
#获取二维数组前两行和前两列数据
arr[0:2,0:2]
array([[9, 15],
[29, 8]])
#将数组的行倒序
arr[::-1]
array([[69, 13, 25, 13, 92, 86],
[72, 78, 49, 51, 54, 77],
[16, 11, 54, 88, 62, 33],
[29, 8, 73, 0, 40, 36],
[9, 15, 64, 28, 89, 93]])
#列倒序
arr[:,::-1]
array([[93, 89, 28, 64, 15, 9],
[36, 40, 0, 73, 8, 29],
[33, 62, 88, 54, 11, 16],
[77, 54, 51, 49, 78, 72],
[86, 92, 13, 25, 13, 69]])
#全部倒序
arr[::-1,::-1]
array([[86, 92, 13, 25, 13, 69],
[77, 54, 51, 49, 78, 72],
[33, 62, 88, 54, 11, 16],
[36, 40, 0, 73, 8, 29],
[93, 89, 28, 64, 15, 9]])
数组的复制
Numpy.copy(参数 1：数组)：创建给定 array 的一个副本，还可当做方法用。
1 after_array = array_normal[:3, 2:4].copy()
2 copy_array = np.copy(array_normal[:, 2:4])
数组排序
Numpy.sort(参数 1：a，数组；参数 2：axis=0/1，0 表示行 1 表示列)：np.sort()作为函数使用时，不更改被排序的原始 array；array.sort() 作为方法使用时，会对原始 array 修改为排序后数组 array
复制代码
1 # 整体排序
2 np.sort(array_normal)
3 # 仅行排序
4 np.sort(array_normal, axis=0)
5 # 仅列排序
6 np.sort(array_normal, axis=1)
复制代码
数组唯一元素
Numpy.unique(参数 1：a，数组；参数 2：return_index=True/False，新列表元素在旧列表中的位置；参数 3：return_inverse=True/False，旧列表元素在新列表中的位置；参数 4：return_counts，元素的数量；参数 5：axis=0/1，0 表示行 1 表示列)：查找 array 中的唯一元素。
1 print(“提取唯一元素”, np.unique(array_normal))
2 print(“提取唯一元素”, np.unique(array_normal, return_index=True))
3 print(“提取唯一元素”, np.unique(array_normal, return_counts=True))
4 print(“提取唯一元素”, np.unique(array_normal, return_index=True, return_inverse=True, axis=0))
数组的改变
数组转置
1 array_normal.T
reshape()：把指定的数组改变形状，但是元素个数不变；有返回值，即不对原始多维数组进行修改
复制代码
1 c = np.array([[[0, 1, 2],
2 [10, 12, 13]],
3 [[100, 101, 102],
4 [110, 112, 113]]])
5 """
6 [[[0 1]
7 [2 10]]
9 [[12 13]
10 [100 101]]
12 [[102 110]
13 [112 113]]]
14 """
15 print(c.reshape(3, 2, 2))
16 """
17 [[0 1 2 10]
18 [12 13 100 101]
19 [102 110 112 113]]
20 """
21 # 某一维指定为 -1 时，自动计算维度
22 print(c.reshape(3, -1))
23 “““[[[0 1]
24 [2 10]
25 [12 13]]
26
27 [[100 101]
28 [102 110]
29 [112 113]]]”””
30 print(c.reshape(2, -1, 2))
复制代码
resize()：把指定的数组改变形状，但是元素个数可变，不足补 0；无返回值，即对原始多维数组进行修改
复制代码
1 a = np.array([[[0, 1, 2],
2 [10, 12, 13]],
3 [[100, 101, 102],
4 [110, 112, 113]]])
5 b = np.array([[[0, 1, 2],
6 [10, 12, 13]],
7 [[100, 101, 102],
8 [110, 112, 113]]])
9 ‘‘‘[[0]
10 [1]
11 [2]]’’’
12 a.resize((3, 1))
13 ‘‘‘[[0 1 2 10 12]
14 [13 100 101 102 110]
15 [112 113 0 0 0]]’’’
16 b.resize((3, 5))
17 print(a)
18 print(b)
复制代码
数组的级联
np.concatenate((arr,arr),axis=1)
array([[9, 15, 64, 28, 89, 93, 9, 15, 64, 28, 89, 93],
[29, 8, 73, 0, 40, 36, 29, 8, 73, 0, 40, 36],
[16, 11, 54, 88, 62, 33, 16, 11, 54, 88, 62, 33],
[72, 78, 49, 51, 54, 77, 72, 78, 49, 51, 54, 77],
[69, 13, 25, 13, 92, 86, 69, 13, 25, 13, 92, 86]])
级联需要注意的点：
级联的参数是列表：一定要加中括号或小括号
维度必须相同
形状相符: 在维度保持一致的前提下，如果进行横向（axis=1）级联，必须保证进行级联的数组行数保持一致。如果进行纵向（axis=0）级联，必须保证进行级联的数组列数保持一致。
可通过 axis 参数改变级联的方向
*Numpy 计算
条件运算
Numpy.where(condition, x, y)：三目运算满足 condition，为 x；不满足 condition，则为 y
1 score = np.array([[80, 88], [82, 81], [84, 75], [86, 83], [75, 81]])
2 # 如果数值小于 80，替换为 0，如果大于等于 80，替换为 90
3 re_score = np.where(score < 80, 0, 90)
4 print(re_score)
统计运算
指定轴最大值：amax(参数 1：数组；参数 2：axis=0/1，0 表示行 1 表示列)
复制代码
1 # 求整个矩阵的最大值
2 result = np.amax(score)
3 print(result)
4 # 求每一列的最大值（0 表示行）
5 result = np.amax(score, axis=0)
6 print(result)
7 # 求每一行的最大值（1 表示列）
8 result = np.amax(score, axis=1)
9 print(result)
复制代码
指定轴最小值：amin(参数 1：数组；参数 2：axis=0/1，0 表示行 1 表示列)
复制代码
1 # 求整个矩阵的最小值
2 result = np.amin(score)
3 print(result)
4 # 求每一列的最小值（0 表示行）
5 result = np.amin(score, axis=0)
6 print(result)
7 # 求每一行的最小值（1 表示列）
8 result = np.amin(score, axis=1)
9 print(result)
复制代码
指定轴平均值：mean(参数 1：数组；参数 2：axis=0/1，0 表示行 1 表示列；参数 3：dtype，输出数据类型)
复制代码
1 # 求整个矩阵的平均值
2 result = np.mean(score, dtype=np.int)
3 print(result)
4 # 求每一列的平均值（0 表示行）
5 result = np.mean(score, axis=0)
6 print(result)
7 # 求每一行的平均值（1 表示列）
8 result = np.mean(score, axis=1)
9 print(result)
复制代码
指定轴方差：std(参数 1：数组；参数 2：axis=0/1，0 表示行 1 表示列；参数 3：dtype，输出数据类型)
复制代码
1 # 求整个矩阵的方差
2 result = np.std(score)
3 print(result)
4 # 求每一列的方差（0 表示列）
5 result = np.std(score, axis=0)
6 print(result)
7 # 求每一行的方差（1 表示行）
8 result = np.std(score, axis=1)
9 print(result)
复制代码
类似的，求和：Numpy.sum()，求中值：Numpy.median
数组运算
数组与数的运算（加、减、乘、除、取整、取模）
复制代码
1 # 循环数组行和列，每一个数值都加 5
2 score[:, :] = score[:, :]+5
3 print(score)
4 # 循环数组行和列，每一个数值都减 5
5 score[:, :] = score[:, :]-5
6 print(score)
7 # 循环数组行和列，每一个数值都乘以 5
8 score[:, :] = score[:, :]*5
9 print(score)
10 # 循环数组行和列，每一个数值都除以 5
11 score[:, :] = score[:, :]/5
12 print(score)
13 # 循环数组行和列，每一个数值除以 5 取整
14 score[:, :] = score[:, :] // 5
15 print(score)
16 # 循环数组行和列，每一个数值除以 5 取模
17 score[:, :] = score[:, :] % 5
18 print(score)
复制代码
数组间运算（加、减、乘、除），前提是两个数组的 shape 一样
加：“+”或者 np.add(a, b) 减：“-”或者 np.subtract(a, b)
乘：“*”或者 np.multiply(a, b) 除：“/”或者 np.divide(a, b)
1 c = score + score
2 d = score - score
3 e = score * score
4 # 分母数组保证每个数值不能为 0
5 b = score / score
Numpy.intersect1d(参数 1：数组 a；参数 2：数组 b)：查找两个数组中的相同元素
Numpy.setdiff1d(参数 1：数组 a；参数 2：数组 b)：查找在数组 a 中不在数组 b 中的元素
Numpy.union1d(参数 1：数组 a；参数 2：数组 b)：查找两个数组的并集元素
矩阵运算（一种特殊的二维数组）
计算规则
（M 行，N 列）*（N 行，Z 列）=（M 行，Z 列）
1 st_score = np.array([[80, 88], [82, 81], [84, 75], [86, 83], [75, 81]])
2 # 平时成绩占 40% 期末成绩占 60%, 计算结果
3 q = np.array([[0.4], [0.6]])
4 result = np.dot(st_score, q)
5 print(result)
矩阵拼接
矩阵垂直拼接（前提两个两个矩阵列数相同，行数随意）：vstack(参数：tuple)
复制代码
1 v1 = [[0, 1, 2, 3, 4, 5],
2 [6, 7, 8, 9, 10, 11]]
3 v2 = [[12, 13, 14, 15, 16, 17],
4 [18, 19, 20, 21, 22, 23],
5 [18, 19, 20, 21, 22, 23]]
6 result = np.vstack((v1, v2))
7 print(result)
复制代码
矩阵水平拼接（前提两个两个矩阵行数相同，列数随意）：hstack(参数：tuple)
复制代码
1 v1 = [[0, 1, 2, 3, 4, 5],
2 [6, 7, 8, 9, 10, 11]]
3 v2 = [[12, 13, 14, 15, 16, 17],
4 [18, 19, 20, 21, 22, 23]]
5 result = np.hstack((v1, v2))
6 print(result)
复制代码
矩阵删除：Numpy.delete(参数 1：a，数组；参数 2：elements，删除的对象；参数 3：axis=0/1)
复制代码
1 OriginalY = np.array([[1, 2, 3],
2 [4, 5, 6],
3 [7, 8, 9]])
4 print(np.delete(OriginalY, [0, 2]))
5 print(np.delete(OriginalY, [0, 2], axis=0))
6 print(np.delete(OriginalY, [0, 2], axis=1))
复制代码
矩阵添加：Numpy.append(参数 1：array，数组；参数 2： elements，添加元素；参数 3： axis=0/1)
复制代码
1 OriginalY = np.array([[1, 2, 3],
2 [4, 5, 6],
3 [7, 8, 9]])
4 # 末尾添加元素
5 print(np.append(OriginalY, [0, 2]))
6 # 最后一行添加一行
7 print(np.append(OriginalY, 0, 2, 11, axis=0))
8 # 最后一列添加一列（注意添加元素格式）
9 print(np.append(OriginalY, [[0], [2], [11]], axis=1))
复制代码
矩阵插入：Numpy.insert(参数 1：array，数组；参数 2：index，插入位置索引；参数 3： elements，添加元素；参数 4： axis=0/1)
复制代码
1 OriginalY = np.array([[1, 2, 3],
2 [4, 5, 6],
3 [7, 8, 9]])
4 print(np.insert(OriginalY, 1, [11, 12, 10]))
5 print(np.insert(OriginalY, 1, 11, 12, 10, axis=0))
6 # 在列索引 1 的位置插入（注意元素格式，跟添加格式不同）
7 print(np.insert(OriginalY, 1, 11, 12, 10, axis=1))
复制代码
文件加载
np.loadtxt(fname,dtype,comments=‘#’,delimiter=None,skiprows=0,usecols=None)
fname: 读取的文件、文件名
dtype：数据类型
comments：注释
delimiter：分隔符，默认是空格
skiprows：跳过前几行读取，默认是 0
usecols：读取哪些列，usecols=（1， 2， 5）读取第 1,2,5 列，默认所有列
