代码收藏家技术教程 2022-09-30

Numpy常用函数汇总

文章目录

1 创建数组

1.1 使用array（）导入向量

1.2 numpy.array()也可以用来导入矩阵

本文使用的是Jupyter notebook，因此仅在开头引入了Numpy，后续没有引入，如果在其他编译器中运行的话请确保引入了numpy

1 创建数组

import numpy as np

1.1 使用array（）导入向量

vector = np.array([1, 2, 3, 4])
vector

array([1, 2, 3, 4])

1.2 numpy.array()也可以用来导入矩阵

matrix = np.array([[1, 'Tim'], [2, 'Joey'], [3, 'Johnny']])
print(matrix)

[['1' 'Tim']
 ['2' 'Joey']
 ['3' 'Johnny']]

2 创建Numpy数组

2.1 创建全0矩阵

默认情况下创建的类型为float64类型

zeros = np.zeros(10)
print(zeros)
print(type(zeros))

[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
<class 'numpy.ndarray'>

如果希望在创建Numpy矩阵时候强制规定一种类型，那么我们可以使用以下代码

int_zeros = np.zeros(10, dtype=int)
print(int_zeros)
print(type(int_zeros))

[0 0 0 0 0 0 0 0 0 0]
<class 'numpy.ndarray'>

2.2 创建多维矩阵

创建的是三行四列的矩阵并且其数据类型是float64

np.zeros(shape=(3, 4))

array([[0., 0., 0., 0.],
       [0., 0., 0., 0.],
       [0., 0., 0., 0.]])

2.3 创建全1矩阵

np.ones(shape=(3, 4))  # 这里可以省略shape=,即可以直接写成这样：np.ones((3,4))

array([[1., 1., 1., 1.],
       [1., 1., 1., 1.],
       [1., 1., 1., 1.]])

2.4 创建一个用指定值填满的矩阵

创建一个三行五列的矩阵，默认值为121

np.full((3, 5), 121)

array([[121, 121, 121, 121, 121],
       [121, 121, 121, 121, 121],
       [121, 121, 121, 121, 121]])

2.5 生成一个在指定范围的矩阵

arange接受三个参数，与python中的range方法相似，arange也是前闭后开的方法，第一个参数为向量的第一个值，第二个参数为向量的最后一个值（由于是前闭后开的，因此向量的最后一个值实际上是该值减去步长），第三个参数为步长，默认为1，

np.arange(0, 20, 2)

array([ 0,  2,  4,  6,  8, 10, 12, 14, 16, 18])

2.6 将指定范围的值均分生成向量

使用np.linespace方法可以将Numpy矩阵进行等分，该方法的范围是前闭后闭的

np.linspace(0, 10, 5)

array([ 0. ,  2.5,  5. ,  7.5, 10. ])

2.7 生成随机数矩阵

生成一个长度为10的向量，里面每一个数值都是介于 0-10 之间的正数，注意这里的范围是前闭后开的

np.random.randint(0, 10, 10)

array([8, 8, 1, 8, 2, 4, 7, 3, 9, 2])

如果不确定每个参数代表的意思，可以加上参数名size

np.random.randint(0, 5, size=5)

array([1, 2, 2, 0, 4])

也可以生成一个三行五列的正数矩阵

np.random.randint(4, 9, size=(3, 5))

array([[5, 7, 7, 4, 4],
       [4, 6, 7, 8, 4],
       [5, 7, 6, 7, 7]])

也可以生成介于0-1之间的浮点数的向量或者矩阵，不用指定范围

np.random.random(10)

array([0.06534131, 0.37071446, 0.02235879, 0.52019336, 0.21088465,
       0.27516892, 0.07299309, 0.90930363, 0.38513079, 0.45422644])

np.random.random((2, 4))

array([[0.58483127, 0.38876978, 0.39987466, 0.75698103],
       [0.91688914, 0.49879013, 0.28552401, 0.61492315]])

np.random.normal()表示的是一个正太分布，normal在这里是正态的意思。numpy.random.normal(loc = 0, scale = 1, size = shape)的意义如下：
参数loc(float)：正态分布的均值，对应这个分布的中心。loc=0说明这是一个以Y轴为对称轴的正态分布
参数scale(float)：正态分布的标准差，对应分布的宽度，scale越大，正态分布的曲线越矮胖，scale越小，曲线越高廋
参数size(int 或者整数元组)：输出的值赋在shape里，默认为None

np.random.normal(loc=0, scale=1, size=5)

array([ 0.28137909,  0.44488236, -0.29643414,  1.06214656, -0.33401709])

3 获取Numpy属性

通过shape查看Numpy数组的属性
通过.ndim来获取Numpy数组的维度

a = np.arange(15)
print(a.shape)
print(a.ndim)

a = a.reshape(3, 5)
print(a.shape)
print(a.ndim)

(15,)
1
(3, 5)
2

reshape方法的特别用法
如果只关心需要多少行或者需要多少列，其他由计算机自己计算，那么这个时候我们可以使用如下方法

a.reshape(15, -1)

array([[ 0],
       [ 1],
       [ 2],
       [ 3],
       [ 4],
       [ 5],
       [ 6],
       [ 7],
       [ 8],
       [ 9],
       [10],
       [11],
       [12],
       [13],
       [14]])

a.reshape(-1, 15)

array([[ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14]])

4 Numpy数组索引

Numpy支持类似list的定位操作，在Numpy中数组索引也是从0开始的

matrix = np.array([[1, 2, 3], [20, 30, 40]])
print(matrix)

print(matrix[0][1])

[[ 1  2  3]
 [20 30 40]]
2

5 切片

Numpy支持类似list的切片操作，对于下面的代码

print(matrix[:,1])代表选中所有的行，并且列的索引是1的数据

print(matrix[:,0:2])代表选中所有的行，并且列的索引是0和1的数据

print(matrix[1:3,:])代表选中所有的列，并且行的索引是1和3的数据

print(matrix[1:3,0:2])代表选中行的索引是1和2，并且列的索引是0和1的所有数据

matrix = np.array([
    [5, 10, 15],
    [20, 25, 30],
    [35, 40, 45]
])
print(matrix[:, 1])
print(matrix[:, 0:2])
print(matrix[1:3, :])
print(matrix[1:3, 0:2])

[10 25 40]
[[ 5 10]
 [20 25]
 [35 40]]
[[20 25 30]
 [35 40 45]]
[[20 25]
 [35 40]]

6 Numpy中的矩阵运算

Numpy中矩阵运算（加、减、乘、除）必须严格按照公式进行计算，即两个矩阵的基本运算必须具有相同的行数和列数。

6.1 矩阵的加法与减法

myones = np.ones((3, 3))
myeye = np.eye(3)
print(myones)
temp = myones + myeye
print('plus:')
print(temp)
temp = myones - myeye
print('minus:')
print(temp)

[[1. 1. 1.]
 [1. 1. 1.]
 [1. 1. 1.]]
plus:
[[2. 1. 1.]
 [1. 2. 1.]
 [1. 1. 2.]]
minus:
[[0. 1. 1.]
 [1. 0. 1.]
 [1. 1. 0.]]

6.2 矩阵的点乘

矩阵真正的乘法必须满足第一个矩阵的列数等于第二个矩阵的行数，矩阵乘法的函数为dot

matrix_1 = np.array([
    [1, 2, 3],
    [4, 5, 6]
])
matrix_2 = np.array([
    [1, 2],
    [3, 4],
    [5, 6]
])
print(matrix_1.shape[0] == matrix_2.shape[1])
print(matrix_1.dot(matrix_2))

True
[[22 28]
 [49 64]]

6.3 矩阵的转置

矩阵的转置是指将矩阵中的行变为列

a = np.array([
    [1, 2, 3],
    [4, 5, 6]
])
print(a.shape)
print(a.T.shape)

(2, 3)
(3, 2)

6.4 矩阵的逆

需要使用numpy.linalg.inv函数来求逆,矩阵求逆的条件是矩阵的行数和列数必须是相同的，并且该矩阵是满秩的
同时，原矩阵与逆矩阵的点积为单位矩阵

A = np.array([
    [0, 1],
    [2, 3]
])
invA = np.linalg.inv(A)
print(A)
print(invA)
print(A.dot(invA))

[[0 1]
 [2 3]]
[[-1.5  0.5]
 [ 1.   0. ]]
[[1. 0.]
 [0. 1.]]

6.5 其他预置函数

除了上面说的那些函数之外，Numpy中还预置了很多函数，使用这些函数可以作用于矩阵中的每个元素

矩阵函数	说明
np.sin(a)	对矩阵a中的每个元素取正弦，sin(x)
np.cos(a)	对矩阵a中的每个元素取余弦，cos(x)
np.tan(a)	对矩阵a中的每个元素取正切，tan(x)
np.sqrt(a)	对矩阵a中的每个元素开根号，sqrt(x)
np.abs(a)	对矩阵a中的每个元素取绝对值

7 数据类型转换

Numpy ndarray数据类型可以通过参数dtype进行设定。而且还可以使用参数astype来转换类型，在处理文件时该参数会很实用。
注意，astype调用会返回一个新的数组，也就是原始数据的备份
比如，下面是将String转换为float的代码

在这个例子中，如果字符串中包含非数字类型，那么从String转换成float会报错

vector = np.array(["1", "2", "3"])
print(vector)
vector = vector.astype(float)
print(vector)

['1' '2' '3']
[1. 2. 3.]

8 Numpy的统计计算方法

Numpy中内置了很多计算方法，其中最重要的方法及说明具体如下

sum():计算矩阵元素的和；矩阵的计算结果为一个一维数组，需要指定行或者列

mean():计算矩阵元素的平均值；矩阵的计算结果为一个一维数组，需要指定行或者列

max():计算矩阵元素的最大值；矩阵的计算结果为一个一维数组，需要指定行或者列

median():计算矩阵元素的中位数

需要注意的是，用于这些统计方法的数据类型必须是int或者float

matrix = np.array([
    [5, 10, 15],
    [20, 10, 30],
    [35, 40, 45]
])
print(matrix.sum())  # 计算所有元素的和
print(matrix[0].sum())  # 计算第一行元素的和
print(matrix.sum(axis=1))  # 计算行的和，结果以列的形式展示
print(matrix.sum(axis=0))  # 计算列的和，结果以行的形式展示

210
30
[ 30  60 120]
[60 60 90]

9 Numpy中的arg运算

9.1 得到数组中最大值的下标

argmax函数就是用来求一个array中最大值的下标；简单来说，就是最大的数所对应的索引位置

maxIndex = np.argmax([1, 2, 4, 5, 2])
print('maxIndex = ', maxIndex)

maxIndex =  3

9.2 得到数组中最小值的下标

minIndex = np.argmin([1, 3, 2, 10, 5])
print('minIndex = ', minIndex)

minIndex =  0

9.3 打乱数组顺序

x = np.arange(15, 30)
print(x)
np.random.shuffle(x)
print(x)
sortXIdx = np.argsort(x)  # 对X从小到大排序，并返回索引值，注意这里并未修改数组x的状态，仅仅是将其排序后应该位于某一位的元素的下标给出，可以对照输出理解一下
print(x)
print(sortXIdx)

[15 16 17 18 19 20 21 22 23 24 25 26 27 28 29]
[20 29 24 22 16 19 21 23 27 18 26 15 28 17 25]
[20 29 24 22 16 19 21 23 27 18 26 15 28 17 25]
[11  4 13  9  5  0  6  3  7  2 14 10  8 12  1]

排序后第一个元素9代表的是x素组中15的索引地址，即x[9]应该是最小的元素

10 FancyIndexing

要索引向量中的一个值是比较容易的，可以通过x[n]来取值。
但是，如果想要更复杂地取数，比如，需要返回第三个、第五个、第八个元素时，应该怎么办？示例代码如下：

x = np.arange(15)
ind = [3, 5, 8]
print(x)
print(x[ind])

[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14]
[3 5 8]

也可以从一维向量中构建新的二维矩阵
下面代码的第三行比较难理解，它的意思是构造一个新的二维矩阵，第一行需要取x向量中索引为0的元素，以及索引为2的元素；第二行需要取x向量中索引为1的元素，以及索引为3的元素。
可以对照输出来理解

x = np.arange(15)
np.random.shuffle(x)
ind = np.array([[0, 2], [1, 3]])
print(x)
print(x[ind])

[14  7  9 11 10  4  0  1 13  5  3  6  8  2 12]
[[14  9]
 [ 7 11]]

对于二维矩阵，我们使用fancyIndexing取数也是比较容易的，示例代码如下：

x = np.arange(16)
np.random.shuffle(x)
x = x.reshape(4, -1)
print(x)

row = np.array([0, 1, 2])
col = np.array([1, 2, 3])
print(x[row, col])  # 相当于取三个点(0,1),(1,2),(2,3)
print(x[1:3, col])  # 相当于取两行的对应列，第二行及第三行的1,2,3列

[[ 3  4  8 13]
 [15  5 11 12]
 [ 7  2  1  0]
 [ 9 10 14  6]]
[ 4 11  0]
[[ 5 11 12]
 [ 2  1  0]]

11 Numpy数组比较

Numpy有一个强大的功能是数组或矩阵的比较，数据比较之后会产生boolean值，示例代码如下，根据结果可以看出来对于矩阵中的每一个值，我们都将其与25进行了比较，并得出一个boolean值

matrix = np.array([
    [5, 10, 15],
    [20, 25, 30],
    [35, 40, 45]
])
m = (matrix == 25)
print(m)

[[False False False]
 [False  True False]
 [False False False]]

下面来看一个比较复杂的例子：
下面代码中，print(second_column_25)的输出是[False True False]，首先matrix[:,1]代表的是所有的行中索引为1的列，即[10,25,40]，将其与25比较，得到的就是前面的输出。
print(matrix[second_column_25, :])代表的是返回true值的那一行数据，即[20,25,30]

matrix = np.array([
    [5, 10, 15],
    [20, 25, 30],
    [35, 40, 45]
])
second_column_25 = (matrix[:, 1] == 25)
print(second_column_25)
print(matrix[second_column_25, :])