释放双眼，带上耳机，听听看~！
本文介绍了Numpy的基本概念、数据类型以及安装方法，是初学者快速入门Numpy的绝佳学习资料。
公众号：尤而小屋
作者：Peter
编辑：Peter
大家好，我是Peter~
本文给整理了一份绝佳的Numpy入门学习资料，文章略长，建议收藏！
Numpy简介
Numpy的全称是”Numeric Python”，直译为”数值Python”，可以理解成它是Python的一个专注于数值运算的第三方扩展包，主要是用来处理、计算一维或者多维数组。它提供了丰富对数组的操作，比如：数学运算、数据筛选、线性代数、统计运算、随机模拟、傅里叶变换等。
随着数据科学的发展以及数据量的增加，对海量数据处理的要求也越来越高，Numpy作为Python数据分析、机器学习和数据科学的主力军，Numpy在矩阵和数组运算上有着非常不错的性能，计算速度极快。其次基于Numpy的数据处理库pandas也丰富了Numpy的使用场景。
数据类型
Numpy作为Python的第三方扩展包，它提供了比Python更为丰富的数据类型，下面的表格进行统计：
| 编号 | 类型 | 描述 |
|---|---|---|
| 1 | bool_ | 布尔型数据类型（True 或者 False） |
| 2 | int_ | 默认整数类型，类似于 C 语言中的 long，取值为 int32 或 int64 |
| 3 | intc | 和 C 语言的 int 类型一样，一般是 int32 或 int 64 |
| 4 | intp | 用于索引的整数类型（类似于 C 的 ssize_t，通常为 int32 或 int64） |
| 5 | int8 | 代表与1字节相同的8位整数。值的范围是-128到127 |
| 6 | int16 | 代表 2 字节（16位）的整数。范围是-32768至32767 |
| 7 | int32 | 代表 4 字节（32位）整数。范围是-2147483648至2147483647 |
| 8 | int64 | 表示 8 字节（64位）整数。范围是-9223372036854775808至9223372036854775807 |
| 9 | uint8 | 代表1字节（8位）无符号整数 |
| 10 | uint16 | 2 字节（16位）无符号整数 |
| 11 | uint32 | 4 字节（32位）的无符号整数 |
| 12 | uint64 | 8 字节（64位）的无符号整数 |
| 13 | float_ | float64 类型的简写 |
| 14 | float16 | 半精度浮点数，包括：1 个符号位，5 个指数位，10个尾数位 |
| 15 | float32 | 单精度浮点数，包括：1 个符号位，8 个指数位，23个尾数位 |
| 16 | float64 | 双精度浮点数，包括：1 个符号位，11 个指数位，52个尾数位 |
| 17 | complex_ | 复数类型，与 complex128 类型相同 |
| 18 | complex64 | 表示实部和虚部共享 32 位的复数 |
| 19 | complex128 | 表示实部和虚部共享 64 位的复数 |
| 20 | str_ | 表示字符串类型 |
| 21 | string_ | 表示字节串类型 |
数据类型标识码
NumPy 中每种数据类型都有自己的唯一标识的字符码，下表总结了常见的数据类型标识码：
| 字符 | 对应类型 |
|---|---|
| b | 代表布尔型 |
| i | 带符号整型 |
| u | 无符号整型 |
| f | 浮点型 |
| c | 复数浮点型 |
| m | 时间间隔（timedelta） |
| M | datatime（日期时间） |
| O | Python对象 |
| S,a | 字节串（S）与字符串（a） |
| U | Unicode |
| V | 原始数据（void） |
安装
下面通过实际案例来介绍快速入门Numpy。一般在安装了anaconda后便默认安装了Numpy，也可以通过其他方式安装：
pip install numpy # pip
conda install numpy # conda
每次使用之前先导入：
导入
import numpy as np
导入Numpy后国际惯例命名为np，方便后续使用。
查看版本信息
np.__version__
'1.21.5'
查看帮助文档
查看Numpy中某个函数的帮助文档：
np.info(np.abs) # 查看np.abs函数的使用文档
absolute(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
--------
>>> x = np.array([-1.2, 1.2])
>>> np.absolute(x)
array([ 1.2, 1.2])
>>> np.absolute(1.2 + 1j)
1.5620499351813308
Plot the function over ``[-10, 10]``:
>>> import matplotlib.pyplot as plt
>>> x = np.linspace(start=-10, stop=10, num=101)
>>> plt.plot(x, np.absolute(x))
>>> plt.show()
Plot the function over the complex plane:
>>> xx = x + 1j * x[:, np.newaxis]
>>> plt.imshow(np.abs(xx), extent=[-10, 10, -10, 10], cmap='gray')
>>> plt.show()
The `abs` function can be used as a shorthand for ``np.absolute`` on
ndarrays.
>>> x = np.array([-1.2, 1.2])
>>> abs(x)
array([1.2, 1.2])
通过内省的方式也能查看函数的帮助信息：
# ?np.abs
创建数组
np.array()
np.array(1)
array(1)
np.array([1,2,3])
# np.array((1,2,3))
array([1, 2, 3])
np.array([[1,2,3],[4,5,6]])
array([[1, 2, 3],
[4, 5, 6]])
np.array([[1,2,3],[4,5,6]],dtype=float)
array([[1., 2., 3.],
[4., 5., 6.]])
np.ararryay()
np.ararryay()和np.array类似，可以将一个Python序列直接转为ndarray对象：
np.asarray([1,2,3])
array([1, 2, 3])
np.asarray([[1,2,3],[4,5,6]])
array([[1, 2, 3],
[4, 5, 6]])
np.empty()
np.empty()是用来创建未初始化的数组，在创建的同时可以指定数组的形状和数据类型，函数语法为：
np.empty(shape,dtype,order="C")
- shape：指定生成的数组形状
- dtype：数组元素的数据类型，默认是float
- order：C或者F，默认是C（行优先）；表示数组在计算机中的存储顺序
np.empty(4)
array([2.12199579e-314, 4.67296746e-307, 4.74303020e-321, 6.95314361e-310])
np.empty([2,2])
array([[2.12199579e-314, 4.67296746e-307],
[4.74303020e-321, 6.95314361e-310]])
np.empty((2,2),dtype=int)
array([[2011357573, -857084477],
[ 627610809, 1610004255]])
从生成的结果中可以看到，np.empty生成的数组带有随机值，没有实际含义。注意：np.empty生成的不是空数组。
np.empty_like()
创建和指定的数组相同形状shape的数组
a = [[1,2,3],[4,5,6]] # 2行3列
a
[[1, 2, 3], [4, 5, 6]]
np.empty_like也是创建2行3列的数组：
np.empty_like(a,dtype=int)
array([[4456560, 7602273, 6029409],
[7274578, 7143521, 7209065]])
np.zeros()
创建全部是0的向量或者数组
np.zeros(10)
array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])
np.zeros((5,2)) # 元组形式
array([[0., 0.],
[0., 0.],
[0., 0.],
[0., 0.],
[0., 0.]])
np.zeros([5,2]) # 列表形式
array([[0., 0.],
[0., 0.],
[0., 0.],
[0., 0.],
[0., 0.]])
np.zeros([3,2,2],dtype=int) # 列表形式
array([[[0, 0],
[0, 0]],
[[0, 0],
[0, 0]],
[[0, 0],
[0, 0]]])
np.zeros_like()
创建和指定数组相同shape的全0数组：
np.zeros_like(a)
array([[0, 0, 0],
[0, 0, 0]])
np.ones()
创建全是1的一维或多维数组
np.ones(8)
array([1., 1., 1., 1., 1., 1., 1., 1.])
np.ones((4,2))
array([[1., 1.],
[1., 1.],
[1., 1.],
[1., 1.]])
np.ones((2,2,3))
array([[[1., 1., 1.],
[1., 1., 1.]],
[[1., 1., 1.],
[1., 1., 1.]]])
np.ones_like()
创建和指定数组相同shape的全1数组：
np.ones_like(a) # 2*3
array([[1, 1, 1],
[1, 1, 1]])
np.ones_like(a,dtype=float) # 指定类型
array([[1., 1., 1.],
[1., 1., 1.]])
np.eye()
创建指定对角线上为1，其他位置为0的矩阵。函数参数为：
np.eye(N,M=None,k=0,dtype,order)
- N：输出的行数
- M：输出的列数，如果不指定默认和N相同
- k：整数；如果是0，默认在主对角线上生成1；如果是正数，在主对角线上面；如果是负数，在主对角线下面；
- dtype：生成的数据类型
- order：C或者F，默认是C（行优先）；表示数组在计算机中的存储顺序
np.eye(3,dtype=int) # 主对角线
array([[1, 0, 0],
[0, 1, 0],
[0, 0, 1]])
np.eye(3,k=1) # 主对角线上面1个单位
array([[0., 1., 0.],
[0., 0., 1.],
[0., 0., 0.]])
np.eye(3,k=2) # 主对角线上面2个单位
array([[0., 0., 1.],
[0., 0., 0.],
[0., 0., 0.]])
np.eye(3,k=-2) # 主对角线下面2个单位
array([[0., 0., 0.],
[0., 0., 0.],
[1., 0., 0.]])
np.full()
函数参数为：
np.full(shape,fill_value,dtype=None,order="C")
- shape：数组形状
- fill_value：待填充的值，标量或者类似数组的值
- dtype：数据类型
- order：C或者F，默认是C（行优先）；表示数组在计算机中的存储顺序
np.full((2,2),np.inf) # np.inf 表示无穷
array([[inf, inf],
[inf, inf]])
np.full((2,2),np.nan) # np.nan 表示空值
array([[nan, nan],
[nan, nan]])
np.full((2,2),5) # 填充5
array([[5, 5],
[5, 5]])
np.full((2,2),[7,8]) # 填充列表[7,8]
array([[7, 8],
[7, 8]])
np.full_like()
函数语法为：
np.full_like(a,fill_value,dtype,order,subok=True,shape=None)
- a：指定的数组
- fill_value：待填充的值
- dtype：数组类型
- order：数据存储顺序，可选为{‘C’,’F’,’A’,’K’}
- subok：布尔值；如果是默认True，表示生成的数组使用a的数据类型；如果是False，使用numpy内置的基础数据类型
np.full_like(a,fill_value=0.8)
array([[0, 0, 0],
[0, 0, 0]])
np.full_like(a,fill_value=0.8,subok=False)
array([[0, 0, 0],
[0, 0, 0]])
np.full_like(a,fill_value=0.8,dtype=float)
array([[0.8, 0.8, 0.8],
[0.8, 0.8, 0.8]])
np.arange()
函数参数为：
np.arange(start, stop, step, dtype)
- start：起始值，默认是0；包含
- stop：终止值，不包含
- step：步长，默认是1
- dtype：指定数据类型
np.arange(10)
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
np.arange(0,10,2)
array([0, 2, 4, 6, 8])
np.arange(1,10,2,dtype=float)
array([1., 3., 5., 7., 9.])
np.arange(10,0,-1)
array([10, 9, 8, 7, 6, 5, 4, 3, 2, 1])
np.linspace()
表示在指定的数值区间内，返回均匀间隔的一维等差数组，默认均分50份，函数参数为：
np.linspace(start,
stop,
num=50,
endpoint=True,
retstep=False,
dtype)
- start：代表数值区间的起始值；
- stop：代表数值区间的终止值；
- num：表示生成多少个均匀的样本。默认值为50；
- endpoint：默认为True，表示数列包含stop终止值，反之不包含；
- retstep：默认为 True，表示生成的数组中会显示公差项，反之不显示；
- dtype：表示数组元素的数据类型。
np.linspace(1,10)
array([ 1. , 1.18367347, 1.36734694, 1.55102041, 1.73469388,
1.91836735, 2.10204082, 2.28571429, 2.46938776, 2.65306122,
2.83673469, 3.02040816, 3.20408163, 3.3877551 , 3.57142857,
3.75510204, 3.93877551, 4.12244898, 4.30612245, 4.48979592,
4.67346939, 4.85714286, 5.04081633, 5.2244898 , 5.40816327,
5.59183673, 5.7755102 , 5.95918367, 6.14285714, 6.32653061,
6.51020408, 6.69387755, 6.87755102, 7.06122449, 7.24489796,
7.42857143, 7.6122449 , 7.79591837, 7.97959184, 8.16326531,
8.34693878, 8.53061224, 8.71428571, 8.89795918, 9.08163265,
9.26530612, 9.44897959, 9.63265306, 9.81632653, 10. ])
np.linspace(1,10,10) # 生成10份
array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.])
默认是包含stop值；下面的例子不包含stop10，也就是1到9生成10等份：
np.linspace(1,10,10,endpoint=False)
array([1. , 1.9, 2.8, 3.7, 4.6, 5.5, 6.4, 7.3, 8.2, 9.1])
np.logspace()
表示在指定的区间内生成基于对数的等比数组，函数语法为：
np.logspace(start,stop,num=50,endpoint,base=10,dtype)
参数含义类似于np.linspace函数；只有base参数表示对数函数的底数，默认是10
np.logspace(1,10)
array([1.00000000e+01, 1.52641797e+01, 2.32995181e+01, 3.55648031e+01,
5.42867544e+01, 8.28642773e+01, 1.26485522e+02, 1.93069773e+02,
2.94705170e+02, 4.49843267e+02, 6.86648845e+02, 1.04811313e+03,
1.59985872e+03, 2.44205309e+03, 3.72759372e+03, 5.68986603e+03,
8.68511374e+03, 1.32571137e+04, 2.02358965e+04, 3.08884360e+04,
4.71486636e+04, 7.19685673e+04, 1.09854114e+05, 1.67683294e+05,
2.55954792e+05, 3.90693994e+05, 5.96362332e+05, 9.10298178e+05,
1.38949549e+06, 2.12095089e+06, 3.23745754e+06, 4.94171336e+06,
7.54312006e+06, 1.15139540e+07, 1.75751062e+07, 2.68269580e+07,
4.09491506e+07, 6.25055193e+07, 9.54095476e+07, 1.45634848e+08,
2.22299648e+08, 3.39322177e+08, 5.17947468e+08, 7.90604321e+08,
1.20679264e+09, 1.84206997e+09, 2.81176870e+09, 4.29193426e+09,
6.55128557e+09, 1.00000000e+10])
np.logspace(1,10,num=20)
array([1.00000000e+01, 2.97635144e+01, 8.85866790e+01, 2.63665090e+02,
7.84759970e+02, 2.33572147e+03, 6.95192796e+03, 2.06913808e+04,
6.15848211e+04, 1.83298071e+05, 5.45559478e+05, 1.62377674e+06,
4.83293024e+06, 1.43844989e+07, 4.28133240e+07, 1.27427499e+08,
3.79269019e+08, 1.12883789e+09, 3.35981829e+09, 1.00000000e+10])
np.logspace(1,10,num=20,base=2)
array([ 2. , 2.77730229, 3.85670399, 5.3556164 ,
7.43708284, 10.32751358, 14.34131354, 19.91508143,
27.65510059, 38.40328703, 53.32876841, 74.05505519,
102.836637 , 142.80421347, 198.30523421, 275.37679007,
382.40229418, 531.02338276, 737.40622722, 1024. ])
索引和切片
模拟数据
在这里模拟生成一个简单的数据：np.arange()先生成一维数组
np.arange(24)
array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
17, 18, 19, 20, 21, 22, 23])
再通过reshape函数转成指定类型的shape：
arr = np.arange(24).reshape(6,4)
arr
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15],
[16, 17, 18, 19],
[20, 21, 22, 23]])
reshape函数的shape也可以使用-1；函数会自动推断（效果同上）：
np.arange(24).reshape(-1,4)
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15],
[16, 17, 18, 19],
[20, 21, 22, 23]])
slice函数
Numpy内置的slice函数用来构造切片对象，该函数有三个参数：start（起始索引）、stop（终止索引） 和 step（步长）。
a = np.arange(6)
a
array([0, 1, 2, 3, 4, 5])
构造从1到5步长为2的切片对象：
s = slice(1,5,2)
s
slice(1, 5, 2)
基于切片对象
从数组arr中根据切片对象取数：
arr[s]
array([[ 4, 5, 6, 7],
[12, 13, 14, 15]])
基础切片
通过冒号来分割切片；用法同python的切片相同，后文会详细介绍。
arr[1:5:2] # 同上
array([[ 4, 5, 6, 7],
[12, 13, 14, 15]])
再看看其他例子：
arr[1:]
array([[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15],
[16, 17, 18, 19],
[20, 21, 22, 23]])
arr[1:5]
array([[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15],
[16, 17, 18, 19]])
arr[1:5:3] #
array([[ 4, 5, 6, 7],
[16, 17, 18, 19]])
arr[6:1:-2]
array([[20, 21, 22, 23],
[12, 13, 14, 15]])
arr[1:4,1:3]
array([[ 5, 6],
[ 9, 10],
[13, 14]])
arr[1:5:2,1:3]
array([[ 5, 6],
[13, 14]])
高级切片
基于省略号...的切片方式。如果在行的位置使用省略号，表示所有行；如果在列的位置，则表示全部列
arr[...,2:]
array([[ 2, 3],
[ 6, 7],
[10, 11],
[14, 15],
[18, 19],
[22, 23]])
arr[1:,...]
array([[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15],
[16, 17, 18, 19],
[20, 21, 22, 23]])
arr[1:4,...]
array([[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15]])
arr[5:1:-2,...]
array([[20, 21, 22, 23],
[12, 13, 14, 15]])
广播机制
广播机制旨在解决Numpy中不同shape之间的运算问题。我们知道如果两个数组shape相同可以直接运算：
a = np.array([1,2,3,4,5,6])
a
array([1, 2, 3, 4, 5, 6])
b = np.arange(5,11)
b
array([ 5, 6, 7, 8, 9, 10])
在两个数组中相同位置的元素执行运算：
a * b
array([ 5, 12, 21, 32, 45, 60])
a / b
array([0.2 , 0.33333333, 0.42857143, 0.5 , 0.55555556,
0.6 ])
a - b
array([-4, -4, -4, -4, -4, -4])
如果两个数组的shape不同呢？
a = np.arange(12).reshape(2,-1)
a
array([[ 0, 1, 2, 3, 4, 5],
[ 6, 7, 8, 9, 10, 11]])
b
array([ 5, 6, 7, 8, 9, 10])
a + b
array([[ 5, 7, 9, 11, 13, 15],
[11, 13, 15, 17, 19, 21]])
a * b
array([[ 0, 6, 14, 24, 36, 50],
[ 30, 42, 56, 72, 90, 110]])
相当于是把b看成：
[[5,6,7,8,9,10],
[5,6,7,8,9,10]] # 复制一遍
此时和数组a的shape相同，再进行运算。
相关数组操作
改变形状reshape
以数组a为例：
a
array([[ 0, 1, 2, 3, 4, 5],
[ 6, 7, 8, 9, 10, 11]])
a.shape
(2, 6)
在前文中介绍过reshape函数：
a.reshape(4,3)
array([[ 0, 1, 2],
[ 3, 4, 5],
[ 6, 7, 8],
[ 9, 10, 11]])
a.reshape(3,4)
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
a.reshape(3,-1) # 同上
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
a.reshape(6,2)
array([[ 0, 1],
[ 2, 3],
[ 4, 5],
[ 6, 7],
[ 8, 9],
[10, 11]])
a.reshape(-1,2) # 同上
array([[ 0, 1],
[ 2, 3],
[ 4, 5],
[ 6, 7],
[ 8, 9],
[10, 11]])
拉直数组flat
该函数返回的是一个迭代器，可以通过for循环进行遍历：
a.flat
<numpy.flatiter at 0x1d0f923afa0>
for column in a.flat:
print("元素: ",column)
元素: 0
元素: 1
元素: 2
元素: 3
元素: 4
元素: 5
元素: 6
元素: 7
元素: 8
元素: 9
元素: 10
元素: 11
拉直数组flatten()
该函数返回的是一个数组副本，不会修改原数组，有参数：
ndarray.flatten(order='C')
a
array([[ 0, 1, 2, 3, 4, 5],
[ 6, 7, 8, 9, 10, 11]])
对比两种不同顺序下的结果：
a.flatten() # 默认order="C"
array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
a.flatten(order="F")
array([ 0, 6, 1, 7, 2, 8, 3, 9, 4, 10, 5, 11])
数组展开ravel
np.ravel函数将多维数组的元素以一维数组的形式进行展开。如果修改会影响原数组：
a
array([[ 0, 1, 2, 3, 4, 5],
[ 6, 7, 8, 9, 10, 11]])
# 默认是基于C
a.ravel()
array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
# 基于F
a.ravel(order="F")
array([ 0, 6, 1, 7, 2, 8, 3, 9, 4, 10, 5, 11])
转置transpose
a # 2*6
array([[ 0, 1, 2, 3, 4, 5],
[ 6, 7, 8, 9, 10, 11]])
a.transpose() # 6*2
array([[ 0, 6],
[ 1, 7],
[ 2, 8],
[ 3, 9],
[ 4, 10],
[ 5, 11]])
np.transpose(a) # 同上
array([[ 0, 6],
[ 1, 7],
[ 2, 8],
[ 3, 9],
[ 4, 10],
[ 5, 11]])
或者使用数组的T属性：
a.T # 同上
array([[ 0, 6],
[ 1, 7],
[ 2, 8],
[ 3, 9],
[ 4, 10],
[ 5, 11]])
数据滚动np.rollaxis()
a
array([[ 0, 1, 2, 3, 4, 5],
[ 6, 7, 8, 9, 10, 11]])
np.rollaxis(a,axis=1)
array([[ 0, 6],
[ 1, 7],
[ 2, 8],
[ 3, 9],
[ 4, 10],
[ 5, 11]])
数学运算
算术运算
a
array([[ 0, 1, 2, 3, 4, 5],
[ 6, 7, 8, 9, 10, 11]])
b
array([ 5, 6, 7, 8, 9, 10])
np.add(a,b)
# a + b 等价
array([[ 5, 7, 9, 11, 13, 15],
[11, 13, 15, 17, 19, 21]])
np.subtract(a,b)
# a - b
array([[-5, -5, -5, -5, -5, -5],
[ 1, 1, 1, 1, 1, 1]])
np.multiply(a,b)
# a * b
array([[ 0, 6, 14, 24, 36, 50],
[ 30, 42, 56, 72, 90, 110]])
np.divide(a,b)
# a / b # 相除求商 5 / 3 ---->1.66666667
array([[0. , 0.16666667, 0.28571429, 0.375 , 0.44444444,
0.5 ],
[1.2 , 1.16666667, 1.14285714, 1.125 , 1.11111111,
1.1 ]])
np.mod(a,b)
# np.remainder(a,b)
# a % b # 求余数 5 % 3 = 1...2 结果是2
array([[0, 1, 2, 3, 4, 5],
[1, 1, 1, 1, 1, 1]], dtype=int32)
指数运算
函数语法为：
np.power(a,b)
将a数组中的元素作为底数，b数组中元素作为幂，返回最终指数运算的结果：
a
array([[ 0, 1, 2, 3, 4, 5],
[ 6, 7, 8, 9, 10, 11]])
np.power(a,2) # a中所有元素的平方
array([[ 0, 1, 4, 9, 16, 25],
[ 36, 49, 64, 81, 100, 121]], dtype=int32)
np.power(a,b)
array([[ 0, 1, 128, 6561, 262144,
9765625],
[ 7776, 117649, 2097152, 43046721, 1000000000,
167620825]], dtype=int32)
三角函数
c = np.arange(0,100,30)
c
array([ 0, 30, 60, 90])
调用Numpy中的pi：
np.pi
3.141592653589793
np.sin(c * np.pi / 180)
array([0. , 0.5 , 0.8660254, 1. ])
np.cos(c * np.pi / 180)
array([1.00000000e+00, 8.66025404e-01, 5.00000000e-01, 6.12323400e-17])
np.tan(c * np.pi / 180)
array([0.00000000e+00, 5.77350269e-01, 1.73205081e+00, 1.63312394e+16])
此外，NumPy还提供arcsin，arcos和arctan 反三角函数。
弧度转换功能：
c
array([ 0, 30, 60, 90])
# 正弦值
sin_c = np.sin(c * np.pi / 180)
sin_c
array([0. , 0.5 , 0.8660254, 1. ])
# 反正弦
arcsin_c = np.arcsin(sin_c)
arcsin_c
array([0. , 0.52359878, 1.04719755, 1.57079633])
# 计算弧度
deg_c = np.degrees(arcsin_c)
deg_c
array([ 0., 30., 60., 90.])
四舍五入
np.around()
对数值进行四舍五入，保留到指定位数：
np.around(arr,decimals)
- arr：待执行的数组或者列表等
- decimals：指定多少位小数，默认是0；如果是负数，表示对小数点左边第n位近似
d = np.array([1.123, 2.456, 23.987, 14.1834])
d
array([ 1.123 , 2.456 , 23.987 , 14.1834])
np.around(d,2)
array([ 1.12, 2.46, 23.99, 14.18])
np.around(d,-1)
array([ 0., 0., 20., 10.])
np.floor()
向下取整，即不大于数组的数值
print("原数组: ",d)
print("向下取整后：",np.floor(d))
原数组: [ 1.123 2.456 23.987 14.1834]
向下取整后： [ 1. 2. 23. 14.]
np.ceil()
向上取整，和np.floor功能相反。
print("原数组: ",d)
print("向上取整后：",np.ceil(d))
原数组: [ 1.123 2.456 23.987 14.1834]
向上取整后： [ 2. 3. 24. 15.]
统计函数
np.amin()/np.amax()
沿着指定的轴axis查找数组中的最大值或者最小值，并以数组形式返回。
a
array([[ 0, 1, 2, 3, 4, 5],
[ 6, 7, 8, 9, 10, 11]])
整个数组中的最小值、最大值
print(np.amin(a))
print(np.amax(a))
0
11
沿着行方向-垂直方向：
print(np.amin(a,axis=0))
print(np.amax(a,axis=0))
[0 1 2 3 4 5]
[ 6 7 8 9 10 11]
沿着列方向-水平方向：
print(np.amin(a,axis=1))
print(np.amax(a,axis=1))
[0 6]
[ 5 11]
np.ptp
求最大值和最小值的差
np.ptp(a)
11
np.ptp(a,axis=0)
array([6, 6, 6, 6, 6, 6])
np.ptp(a,axis=1)
array([5, 5])
# 验证：axis=1方向的最大值和最小值
print(np.amin(a,axis=1))
print(np.amax(a,axis=1))
[0 6]
[ 5 11]
np.percentile()
沿着指定的轴，计算任意百分比下的分位数：
np.percentile(a,q,axis)
- a：数组
- q：指定要计算的百分位数，0-100间
- axis：指定的轴
np.percentile(a,q=0.25)
0.0275
np.percentile(a,q=0.25,axis=0)
array([0.015, 1.015, 2.015, 3.015, 4.015, 5.015])
np.percentile(a,q=0.25,axis=1)
array([0.0125, 6.0125])
np.median()
计算中位数
np.median(a)
5.5
np.median(a,axis=0)
array([3., 4., 5., 6., 7., 8.])
np.median(a,axis=1)
array([2.5, 8.5])
np.mean()
计算均值
np.mean(a)
5.5
np.mean(a,axis=0)
array([3., 4., 5., 6., 7., 8.])
np.mean(a,axis=1)
array([2.5, 8.5])
np.average()
求加权平均值
b
array([ 5, 6, 7, 8, 9, 10])
如果不指定权重，直接相加再求均值：
np.average(b)
7.5
np.average(b, weights=[6,5,4,3,2,1])
6.666666666666667
# 实际计算过程
(5*6 + 6*5 + 7*4 + 8*3 + 9*2 + 10*1) / (6+5+4+3+2+1)
6.666666666666667
returned 返回权重因子之和：
np.average(b, weights=[6,5,4,3,2,1],returned=True)
(6.666666666666667, 21.0)
np.var()
求数组的方差
np.var(a)
11.916666666666666
np.std()
求数组的标准差
np.std(a)
3.452052529534663
矩阵运算
常用的矩阵运算函数：
- np.dot：计算两个数组的点积
- np.vdot：计算两个向量的点积
- np.inner：计算两个数组的内积
- np.matmul：计算两个数组的矩阵积
- np.det：计算输入矩阵的行列式
- np.solve：求解线性矩阵方程
- np.inv：计算矩阵的逆矩阵（逆矩阵与原始矩阵相乘，会得到单位矩阵）
np.dot
将其中一个数组中的每一行元素和另个数组的每列元素相乘再相加：
A = [1,2,3]
B = [7,8,9]
np.dot(A,B)
50
A = np.arange(4).reshape(2,2)
B = np.array([[5,6],[8,9]])
A,B
(array([[0, 1],
[2, 3]]),
array([[5, 6],
[8, 9]]))
np.dot(A,B)
array([[ 8, 9],
[34, 39]])
A中的每行元素乘以B中每列的元素：
# 0*5 + 1*8 = 8
# 0*6 + 1*9 = 9
# 2*5 + 3*8 = 34
# 2*6 + 3*9=39 = 34
np.vdot
计算点积结果：对应位置的元素相乘再相加
np.vdot(A,B)
49
0*5 +1*6 + 2*8 + 3*9
49
np.inner
A = [1,2,3]
B = [7,8,9]
如果是一维数组，np.inner等价于np.dot：
np.inner(A,B)
50
np.dot(A,B)
50
如果是多维数组：
A = np.arange(4).reshape(2,2)
B = np.array([[5,6],[8,9]])
A,B
(array([[0, 1],
[2, 3]]),
array([[5, 6],
[8, 9]]))
np.inner(A,B)
array([[ 6, 9],
[28, 43]])
np.inner的计算过程是A中的每行元素乘以B中的每行元素再相加：
# 0*5+1*6 = 6
# 0*8+1*9 = 9
# 2*5+3*6 = 28
# 2*8+3*9 = 43
A中的每行元素乘以B中每列的元素：
np.dot(A,B)
array([[ 8, 9],
[34, 39]])
np.matmul
两个矩阵的乘积；矩阵的维度必须相匹配。
a
array([[ 0, 1, 2, 3, 4, 5],
[ 6, 7, 8, 9, 10, 11]])
e = np.arange(18).reshape(6,3)
e
array([[ 0, 1, 2],
[ 3, 4, 5],
[ 6, 7, 8],
[ 9, 10, 11],
[12, 13, 14],
[15, 16, 17]])
np.matmul(a,e)
array([[165, 180, 195],
[435, 486, 537]])
a是2*6，e是6*3，所以矩阵乘积的结果是2*3
np.linalg.det()
计算矩阵的行列式
# 比如二阶矩阵：
a = np.array([[1,2],[3,4]])
a
array([[1, 2],
[3, 4]])
np.linalg.det(a)
-2.0000000000000004
np.linalg.solve()
计算线性矩阵方程组，并以矩阵的形式表示方程的解。
m = np.array([[3,2,1],[1,1,1],[1,2,-1]])
m
array([[ 3, 2, 1],
[ 1, 1, 1],
[ 1, 2, -1]])
n = np.array([[10],[6],[2]])
n
array([[10],
[ 6],
[ 2]])
# m * x = n ----> x = m^(-1)n
np.linalg.solve(m,n)
array([[1.],
[2.],
[3.]])
np.linalg.inv()
求解矩阵的逆矩阵；原矩阵和逆矩阵的矩阵乘积就是单位矩阵：
a
array([[1, 2],
[3, 4]])
# 逆矩阵
a_ = np.linalg.inv(a)
a_
array([[-2. , 1. ],
[ 1.5, -0.5]])
# 矩阵乘积
np.matmul(a,a_)
array([[1.00000000e+00, 1.11022302e-16],
[0.00000000e+00, 1.00000000e+00]])
本网站的内容主要来自互联网上的各种资源，仅供参考和信息分享之用，不代表本网站拥有相关版权或知识产权。如您认为内容侵犯您的权益，请联系我们，我们将尽快采取行动，包括删除或更正。
