一 概述
NumPy 是一个 Python 包。 它代表 “Numeric Python”。 它是一个由多维数组对象和用于处理数组的例程集合组成的库。Numeric，即 NumPy 的前身，是由 Jim Hugunin 开发的。 他也开发了另一个包 Numarray ，它拥有一些额外的功能。 2005年，Travis Oliphant 通过将 Numarray 的功能集成到 Numeric 包中来创建 NumPy 包。 这个开源项目有很多贡献者。
NumPy是高性能科学计算和数据分析的基础包。部分功能如下：
- ndarray, 具有矢量算术运算和复杂广播能力的快速且节省空间的多维数组。
- 用于对整组数据进行快速运算的标准数学函数（无需编写循环）。
- 用于读写磁盘数据的工具以及用于操作内存映射文件的工具。
- 线性代数、随机数生成以及傅里叶变换功能。
- 用于集成C、C++、Fortran等语言编写的代码的工具。
二 创建矩阵
NumPy 中定义的最重要的对象是称为 ndarray 的 N 维数组类型。 它描述相同类型的元素集合。 可以使用基于零的索引访问集合中的项目。ndarray中的每个元素在内存中使用相同大小的块。 ndarray中的每个元素是数据类型对象的对象（称为 dtype）。从ndarray对象提取的任何元素（通过切片）由一个数组标量类型的 Python 对象表示。 下图显示了ndarray，数据类型对象（dtype）和数组标量类型之间的关系。
基本的ndarray是使用 NumPy 中的数组函数创建的，如下所示：
numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)
上面的构造器接受以下参数：
| 序号 | 参数及描述 |
|---|---|
| 1. | object 任何暴露数组接口方法的对象都会返回一个数组或任何（嵌套）序列。 |
| 2. | dtype 数组的所需数据类型，可选。 |
| 3. | copy 可选，默认为true，对象是否被复制。 |
| 4. | order C（按行）、F（按列）或A（任意，默认）。 |
| 5. | subok 默认情况下，返回的数组被强制为基类数组。 如果为true，则返回子类。 |
| 6. | ndimin 指定返回数组的最小维数。 |
看看下面的例子来更好地理解。
import numpy as np #引入numpy库
#创建一维的ndarray对象
a = np.array([1,2,3,4,5])
#创建二维的ndarray对象
a2 = np.array([[1,2,3,4,5],[6,7,8,9,10]])
#创建多维对象以其类推
三 获取矩阵行列数（二维情况）
要获取ndarray对象的各维的长度，可以通过narray对象的shape属性。
import numpy as np
a = np.array([[1,2,3,4,5],[6,7,8,9,10]])
print(a.shape) #结果返回一个tuple元组 (2, 5)
print(a.shape[0]) #获得行数，返回 2
print(a.shape[1]) #获得列数，返回 5
四 矩阵的截取
4.1 按行列截取
矩阵的截取和list相同，可以通过[]（方括号）来截取
import numpy as np
a = np.array([[1,2,3,4,5],[6,7,8,9,10]])
print(a[0:1]) #截取第一行,返回 [[1 2 3 4 5]]
print(a[1,2:5]) #截取第二行，第三、四、五列，返回 [8 9 10]
print(a[1,:]) #截取第二行,返回 [ 6 7 8 9 10]
4.2 按条件截取
按条件截取其实是在[]（方括号）中传入自身的布尔语句。例如
import numpy as np
a = np.array([[1,2,3,4,5],[6,7,8,9,10]])
b = a[a>6] # 截取矩阵a中大于6的元素，范围的是一维数组
print(b) # 返回 [ 7 8 9 10]
# 其实布尔语句首先生成一个布尔矩阵，将布尔矩阵传入[]（方括号）实现截取
print(a>6)
# 返回
[[False False False False False]
[False True True True True]]
按条件截取应用较多的是对矩阵中满足一定条件的元素变成特定的值。 例如将矩阵中大于6的元素变成1。
import numpy as np
a = np.array([[1,2,3,4,5],[6,7,8,9,10]])
print(a)
#开始矩阵为
[[ 1 2 3 4 5]
[ 6 7 8 9 10]]
a[a>6] = 1
print(a)
#大于6的值改为1后矩阵为
[[1 2 3 4 5]
[6 1 1 1 1]]
五 矩阵的合并
矩阵的合并可以通过numpy中的hstack方法和vstack方法实现。
import numpy as np
a1 = np.array([[1,2],[3,4]])
a2 = np.array([[5,6],[7,8]])
#!注意 参数传入时要以列表list或元组tuple的形式传入
print(np.hstack([a1,a2]))
#横向合并，返回结果如下
[[1 2 5 6]
[3 4 7 8]]
print(np.vstack((a1,a2)))
#纵向合并，返回结果如下
[[1 2]
[3 4]
[5 6]
[7 8]]
矩阵的合并也可以通过concatenatef方法。
np.concatenate( (a1,a2), axis=0 ) 等价于 np.vstack( (a1,a2) ),纵向合并
np.concatenate( (a1,a2), axis=1 ) 等价于 np.hstack( (a1,a2) ),横向合并
六 通过函数创建矩阵
numpy模块中自带了一些创建ndarray对象的函数，可以很方便的创建常用的或有规律的矩阵。
（1）arange
import numpy as np
a = np.arange(10) # 默认从0开始到10（不包括10），步长为1
print(a) # 返回 [0 1 2 3 4 5 6 7 8 9]
a1 = np.arange(5,10) # 从5开始到10（不包括10），步长为1
print(a1) # 返回 [5 6 7 8 9]
a2 = np.arange(5,20,2) # 从5开始到20（不包括20），步长为2
print(a2) # 返回 [ 5 7 9 11 13 15 17 19]
（2）linspace
linspace()和matlab的linspace很类似，用于创建指定数量等间隔的序列，实际生成一个等差数列。
import numpy as np
a = np.linspace(0,10,7) # 生成首位是0，末位是10，含7个数的等差数列
print(a)
# 结果
[ 0. 1.66666667 3.33333333 5. 6.66666667 8.33333333 10. ]
（3）logspace
linspace用于生成等差数列，而logspace用于生成等比数列。下面的例子用于生成首位是100，末位是102，含5个数的等比数列。
import numpy as np
a = np.logspace(0,2,5)
print(a)
# 结果
[ 1. 3.16227766 10. 31.6227766 100. ]
假如，我们想要改变基数，不让它以10为底数，我们可以改变base参数，将其设置为2试试。
a = np.logspace(0,9,10,base=2)
print(a)
>>>array([ 1., 2., 4., 8., 16., 32., 64., 128., 256., 512.])
(4) ones、zeros、eye、empty
新的ndarray对象可以通过任何下列数组创建例程或使用低级ndarray构造函数构造。
- ones创建全1矩阵
- zeros创建全0矩阵
- eye创建单位矩阵
- empty创建空矩阵（实际有值）
import numpy as np
a_ones = np.ones((3,4)) # 创建3*4的全1矩阵
print(a_ones)
# 结果
[[ 1. 1. 1. 1.]
[ 1. 1. 1. 1.]
[ 1. 1. 1. 1.]]
a_zeros = np.zeros((3,4)) # 创建3*4的全0矩阵
print(a_zeros)
# 结果
[[ 0. 0. 0. 0.]
[ 0. 0. 0. 0.]
[ 0. 0. 0. 0.]]
a_eye = np.eye(3) # 创建3阶单位矩阵
print(a_eye)
# 结果
[ 1. 0. 0.]
[ 0. 1. 0.]
[ 0. 0. 1.]]
a_empty =lnp.empty((3,4)，dtype=int) # 创建3*4的空矩阵
print(a_empty)
# 结果
（5）fromstring
fromstring()方法可以将字符串转化成ndarray对象，需要将字符串数字化时这个方法比较有用，可以获得字符串的ascii码序列。
a = "abcdef"
b = np.fromstring(a,dtype=np.int8) # 因为一个字符为8为，所以指定dtype为np.int8
print(b) # 返回 [ 97 98 99 100 101 102]
（6）fromfunction
fromfunction()方法可以根据矩阵的行号列号生成矩阵的元素。例如创建一个矩阵，矩阵中的每个元素都为行号和列号的和。
import numpy as np
def func(i,j):
return i+j
a = np.fromfunction(func,(5,6))
# 第一个参数为指定函数，第二个参数为列表list或元组tuple,说明矩阵的大小
print(a)
# 返回
[[ 0. 1. 2. 3. 4. 5.]
[ 1. 2. 3. 4. 5. 6.]
[ 2. 3. 4. 5. 6. 7.]
[ 3. 4. 5. 6. 7. 8.]
[ 4. 5. 6. 7. 8. 9.]]
#注意这里行号的列号都是从0开始的
(7)meshgrid
meshgrid函数通常使用在数据的矢量化上。它适用于生成网格型数据，可以接受两个一维数组生成两个二维矩阵，对应两个数组中所有的(x,y)对。
import numpy as np x = np.arange(-2,2)#-2,-1,0,1 y = np.arange(0,3) #生成一位数组，其实也就是向量 0,1,2 z,s = np.meshgrid(x,y)#将两个一维数组变为二维矩阵 z array([[-2, -1, 0, 1], [-2, -1, 0, 1], [-2, -1, 0, 1]]) s array([[0, 0, 0, 0], [1, 1, 1, 1], [2, 2, 2, 2]]) #同理 z,s = np.meshgrid(y,x)#将两个一维数组变为二维矩阵 z array([[0, 1, 2], [0, 1, 2], [0, 1, 2], [0, 1, 2]]) s array([[-2, -2, -2], [-1, -1, -1], [ 0, 0, 0], [ 1, 1, 1]])
由上面的示例展示可以看出，meshgrid的作用是：
根据传入的两个一维数组参数生成两个数组元素的列表。
如果第一个参数是xarray，维度是xdimesion，
第二个参数是yarray，维度是ydimesion。
那么生成的第一个二维数组是以xarray为行，共ydimesion行的向量；
而第二个二维数组是以yarray的转置为列，共xdimesion列的向量。
七 矩阵的运算
7.1 常用矩阵运算符
numpy中的ndarray对象重载了许多运算符，使用这些运算符可以完成矩阵间对应元素的运算。
| 运算符 | 说明 |
|---|---|
| + | 矩阵对应元素相加 |
| - | 矩阵对应元素相减 |
| * | 矩阵对应元素相乘 |
| / | 矩阵对应元素相除，如果都是整数则取商 |
| % | 矩阵对应元素相除后取余数 |
| ** | 矩阵每个元素都取n次方，如**2：每个元素都取平方 |
部分运算符举例如下：
import numpy as np
a1 = np.array([[4,5,6],[1,2,3]])
a2 = np.array([[6,5,4],[3,2,1]])
print(a1+a2) # 相加
# 结果
[[10 10 10]
[ 4 4 4]]
print(a1/a2) # 整数相除取商
# 结果
[[0.66666667 1. 1.5 ]
[0.33333333 1. 3. ]]
print(a1%a2) # 相除取余数
# 结果
[[4 0 2]
[1 0 0]]
7.2 常用矩阵函数
同样地，numpy中也定义了许多函数，使用这些函数可以将函数作用于矩阵中的每个元素。 表格中默认导入了numpy模块，即 import numpy as np。a为ndarray对象。
| 矩阵函数 | 说明 |
|---|---|
| np.sin(a) | 对矩阵a中每个元素取正弦,sin(x) |
| np.cos(a) | 对矩阵a中每个元素取余弦,cos(x) |
| np.tan(a) | 对矩阵a中每个元素取正切,tan(x) |
| np.arcsin(a) | 对矩阵a中每个元素取反正弦,arcsin(x) |
| np.arccos(a) | 对矩阵a中每个元素取反余弦,arccos(x) |
| np.arctan(a) | 对矩阵a中每个元素取反正切,arctan(x) |
| np.exp(a) | 对矩阵a中每个元素取指数函数,ex |
| np.sqrt(a) | 对矩阵a中每个元素开根号√x |
部分举例如下：
import numpy as np
a = np.array([[1,2,3],[4,5,6]])
print(np.sin(a))
# 结果
[[ 0.84147098 0.90929743 0.14112001]
[-0.7568025 -0.95892427 -0.2794155 ]]
print(np.arcsin(a))
# 结果
[[1.57079633 nan nan]
[ nan nan nan]]
当矩阵中的元素不在定义域范围内，会产生RuntimeWarning，结果为nan(not a number)。
7.3 矩阵乘法（点乘）
矩阵乘法必须满足矩阵乘法的条件，即第一个矩阵的列数等于第二个矩阵的行数。 矩阵乘法的函数为 dot
import numpy as np
a1 = np.array([[1,2,3],[4,5,6]]) # a1为2*3矩阵
a2 = np.array([[1,2],[3,4],[5,6]]) # a2为3*2矩阵
print(a1.shape[1]==a2.shape[0]) # True, 满足矩阵乘法条件
print(a1.dot(a2))
# a1.dot(a2)相当于matlab中的a1*a2
# 而python中的a1*a2相当于matlab中的a1.*a2
# 结果
[[22 28]
[49 64]]
7.4 矩阵的转置
import numpy as np a = np.array([[1,2,3],[4,5,6]]) print(a.transpose()) # 结果 [[1 4] [2 5] [3 6]]
矩阵的转置还有更简单的方法，就是a.T
import numpy as np a = np.array([[1,2,3],[4,5,6]]) print(a.T) # 结果 [[1 4] [2 5] [3 6]]
7.5 矩阵的逆
求矩阵的逆需要先导入numpy.linalg，用linalg的inv函数来求逆。 矩阵求逆的条件是矩阵的行数和列数相同。
import numpy as np
import numpy.linalg as lg
a = np.array([[1,2,3],[4,5,6],[7,8,9]])
print(lg.inv(a))
# 结果
[[ -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]]
a = np.eye(3) # 3阶单位矩阵
print(lg.inv(a)) # 单位矩阵的逆为他本身
# 结果
[[ 1. 0. 0.]
[ 0. 1. 0.]
[ 0. 0. 1.]]
八 矩阵信息的获取
8.1 最大值最小值
获得矩阵中元素最大最小值的函数分别是max和min，可以获得整个矩阵、行或列的最大最小值。 例如
import numpy as np
a = np.array([[1,2,3],[4,5,6]])
print(a.max()) #获取整个矩阵的最大值 结果： 6
print(a.min()) #结果：1
# 可以指定关键字参数axis来获得行最大（小）值或列最大（小）值
# axis=0 行方向最大（小）值，即获得每列的最大（小）值
# axis=1 列方向最大（小）值，即获得每行的最大（小）值
# 例如
print(a.max(axis=0))
# 结果为 [4 5 6]
print(a.max(axis=1))
# 结果为 [3 6]
# 要想获得最大最小值元素所在的位置，可以通过argmax函数来获得
print(a.argmax(axis=1))
# 结果为 [2 2]
8.2 平均值
获得矩阵中元素的平均值可以通过函数mean()。同样地，可以获得整个矩阵、行或列的平均值。
import numpy as np
a = np.array([[1,2,3],[4,5,6]])
print(a.mean()) #结果为： 3.5
# 同样地，可以通过关键字axis参数指定沿哪个方向获取平均值
print(a.mean(axis=0)) # 结果 [ 2.5 3.5 4.5]
print(a.mean(axis=1)) # 结果 [ 2. 5.]
8.3 方差
方差的函数为var(),方差函数var()相当于函数mean(abs(x - x.mean())**2),其中x为矩阵。
import numpy as np
a = np.array([[1,2,3],[4,5,6]])
print(a.var()) # 结果 2.91666666667
print(a.var(axis=0)) # 结果 [ 2.25 2.25 2.25]
print(a.var(axis=1)) # 结果 [ 0.66666667 0.66666667]
8.4 标准差
标准差的函数为std()。 std()相当于sqrt(mean(abs(x - x.mean())**2))，或相当于sqrt(x.var())。
import numpy as np
a = np.array([[1,2,3],[4,5,6]])
print(a.std()) # 结果 1.70782512766
print(a.std(axis=0)) # 结果 [ 1.5 1.5 1.5]
print(a.std(axis=1)) # 结果 [ 0.81649658 0.81649658]
8.5 中值
中值指的是将序列按大小顺序排列后，排在中间的那个值，如果有偶数个数，则是排在中间两个数的平均值。例如序列[5,2,6,4,2]，按大小顺序排成 [2,2,4,5,6]，排在中间的数是4，所以这个序列的中值是4。又如序列[5,2,6,4,3,2]，按大小顺序排成 [2,2,3,4,5,6]，因为有偶数个数，排在中间两个数是3、4，所以这个序列中值是3.5。中值的函数是median()，调用方法为numpy.median(x,[axis])，axis可指定轴方向，默认axis=None，对所有数去中值。
import numpy as np
x = np.array([[1,2,3],[4,5,6]])
print(np.median(x)) # 对所有数取中值
# 结果
3.5
print(np.median(x,axis=0)) # 沿第一维方向取中值
# 结果
[ 2.5 3.5 4.5]
print(np.median(x,axis=1)) # 沿第二维方向取中值
# 结果
[ 2. 5.]
8.6 求和
矩阵求和的函数是sum()，可以对行，列，或整个矩阵求和。
import numpy as np
a = np.array([[1,2,3],[4,5,6]])
print(a.sum()) # 对整个矩阵求和
# 结果 21
print(a.sum(axis=0)) # 对行方向求和
# 结果 [5 7 9]
print(a.sum(axis=1)) # 对列方向求和
# 结果 [ 6 15]
8.7 累积和
某位置累积和指的是该位置之前(包括该位置)所有元素的和。例如序列[1,2,3,4,5]，其累计和为[1,3,6,10,15]，即第一个元素为1，第二个元素为1+2=3，……，第五个元素为1+2+3+4+5=15。矩阵求累积和的函数是cumsum()，可以对行，列，或整个矩阵求累积和。
import numpy as np
a = np.array([[1,2,3],[4,5,6]])
print(a.cumsum()) # 对整个矩阵求累积和
# 结果 [ 1 3 6 10 15 21]
print(a.cumsum(axis=0)) # 对行方向求累积和
# 结果
[[1 2 3]
[5 7 9]]
print(a.cumsum(axis=1)) # 对列方向求累积和
# 结果
[[ 1 3 6]
[ 4 9 15]]
参考：
https://www.cnblogs.com/smallpi/p/4550361.html
https://blog.csdn.net/a373595475/article/details/79580734