Python的第三方扩展库，是其他数据分析模块的基础，主要用于数组、矩阵计算（比列表快得多）等方面
安装
pip install numpy
常用方法
array()
创建数组，举例：
创建一维数组：numpy.array([x,y,...])
二维数组：numpy.array([[x,y...],[x,y...],[x,y...])
注：
创建的数组如果想看格式（几行几列），就通过array.shape来看就行了，要知道是几维的数据，可以通过array.ndim查看，举例：
>>> z = np.array([[1,2],[3,4],[5,6]])
>>> z.ndim
2
#2维
>>> z.shape
(3, 2)
#3行两列
>>> m = np.array([1,2])
>>> m.shape
(2,)
#1行两列
注2：
数组创建后大小就固定了，所以如果想要进行增删改查则可以参考如下方法：
- 增：使用
tile()扩展、vstack()合并、转成列表操作再转回来（参考后面） - 删：可以直接像
a=a[0]，那么就只有一行了、分片操作 - 改：直接改
- 查：直接查，可以参考后面的数组切片
举例：
>>> a = np.array([1,2,3,4])
>>> np.tile(a, 2) #此时第二个参数相当于(1,2)，即扩展成1行2列（x轴变成原来2倍）
array([1, 2, 3, 4, 1, 2, 3, 4])
数组操作
对数组的操作都是通过依次对其中的元素进行相同操作，举例：
>>> x = np.array([-1,0,1,2,3])
>>> x
array([-1, 0, 1, 2, 3])
>>> x > 1 #依次判断，若满足条件则True，否则False
array([False, False, False, True, True])
>>> x * 2 #依次对所有元素乘2
array([-2, 0, 2, 4, 6])
>>> x = np.array([[1,2],[3,4]])
>>> x[x>2] = 0
# 将数组中大于2的值都置0
>>> x
array([[1, 2],
[0, 0]])
>>> x = np.arange(0, 5)
>>> x
array([0, 1, 2, 3, 4])
>>> y = x[:, np.newaxis]
# 把x转成二维就是y
>>> y
array([[0],
[1],
[2],
[3],
[4]])
>>> x + y
# 对于两个不是相同格式的数据添加，会自动拓展成两个都合适的维度进行计算，后面会还原计算过程
array([[0, 1, 2, 3, 4],
[1, 2, 3, 4, 5],
[2, 3, 4, 5, 6],
[3, 4, 5, 6, 7],
[4, 5, 6, 7, 8]])
>>> x1 = np.tile(x, (5, 1))
# 把x的行复制成原来的5倍
>>> x1
array([[0, 1, 2, 3, 4],
[0, 1, 2, 3, 4],
[0, 1, 2, 3, 4],
[0, 1, 2, 3, 4],
[0, 1, 2, 3, 4]])
>>> y1 = np.tile(y, (1, 5))
# 把y的列复制成原来的5倍
>>> y1
array([[0, 0, 0, 0, 0],
[1, 1, 1, 1, 1],
[2, 2, 2, 2, 2],
[3, 3, 3, 3, 3],
[4, 4, 4, 4, 4]])
>>> x1 + y1
# 可以看到结果和之前是一样的
array([[0, 1, 2, 3, 4],
[1, 2, 3, 4, 5],
[2, 3, 4, 5, 6],
[3, 4, 5, 6, 7],
[4, 5, 6, 7, 8]])
注：
数组是可以定义里面所有的类型统一的（通过astype方法或者有些数据读取自带类型，比如图片读取默认是np.uint8），所以在对数组进行操作前需要判断数据类型是否符合要求或者需要转型，否则将可能发生数据被自动转型或者操作失败等问题，举例：
>>> x = np.array([[-1,0,1], [2,3,4]], np.int8)
# 数据类型是int8：-256~255
>>> x[1, :] = [1., 2., 300.]
>>> x
array([[-1, 0, 1],
[ 1, 2, 44]], dtype=int8)
# 300超过边界，被自动转成44（300-255，从0开始）
数组索引
数组除了可以通过输入对应行列或者切片（后面会介绍）进行索引以外，也可以输入一个列表进行批量指定索引，举例：
>>> x = np.array([-1,0,1,2,3])
>>> x[[1,2,4]]
# 索引第2,3,5个数据
array([0, 1, 3])
注：
输入列表是批量索引，但输入的如果是元组，则是指定坐标索引，举例：
>>> x = np.array([[1,2,3], [4,5,6], [7,8,9]])
>>> x
array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
>>> x[[0,1]]
# 输入列表，代表要第一行和第二行
array([[1, 2, 3],
[4, 5, 6]])
>>> x[(0,1)]
# 输入元组，代表要第一行第二列的数据
2
>>> x[(0,1), (1,1)]
# 要坐标为0,1和1,1的数据
array([2, 5])
>>> x[(0,1,1)]
# 用元组默认是当成一组坐标，因此必须是2个值成对出现，这里输入3个，而数据是二维，自然就报错了
Traceback (most recent call last):
File "", line 1, in
x[(0,1,1)]
IndexError: too many indices for array
逻辑操作
从前面的代码可以知道数组可以进行整体的逻辑判断，但是前面的示例都是单个条件判断，如果想进行多个判断后再进行与或异或这些操作，可以使用logical_and()等这类逻辑操作方法，举例：
>>> a = np.array([[1,2,3], [1,2,""], [1,2,None]])
>>> np.logical_and.reduce([a!="", a!=None])
array([[ True, True, True],
[ True, True, False],
[ True, True, False]])
# 同时判断值不为空字符串和None
上面的方法只能对两个条件进行判断，多个条件的情况参考：
https://www.jianshu.com/p/1146b51ae6de
sort()
排序，正常排，遇到无法排序的放最后，举例：
>>> x = np.array([1,3,2,'a',5])
>>> x
array(['1', '3', '2', 'a', '5'], dtype='>> x.sort()
>>> x
array(['1', '2', '3', '5', 'a'], dtype=' 注：
二维数组排序只排每一行里面的，其他行之间互不干扰
max()
求最大值，如果在二维数组中，每行的列数相等，那么最大值就是所有元素里最大的，举例：
>>> x = np.array([[1,2,3,5],[1,2,0,0],[5,8,23,1]])
>>> x.max()
23
但如果每行列数不同，返回的就是数开头最大的那一行（假如第一个一样，再比第二个...），举例：
>>> x = np.array([[3,2,1,4,10],[1,2,0,0],[3,6,9,1]])
>>> x.max()
[3, 6, 9, 1]
注：
最小值min()，平均值是mean()，加权平均值是average()，标准差是std()
[:]
数组切片，参考列表，举例：
>>> b = np.array([1,2,3,4,5])
>>> b[1:3]
array([2, 3])
>>> a = np.array(([1,2,3,4],[5,6,7,8],[9,10,11,12]))
>>> a[1:]
array([[ 5, 6, 7, 8],
[ 9, 10, 11, 12]])
>>> a[:][1] #切出所有行，取第2个
array([5, 6, 7, 8])
>>> a[:][1:] #切出所有行，取第二个2到最后一个
array([[ 5, 6, 7, 8],
[ 9, 10, 11, 12]])
可以看出上面只能切出行而不能切分列（其将行看作整体来切分），所以推荐使用下面的针对数组特殊的切片方法来切分行列，格式：[:,:]，在一个括号里写分片，逗号分隔行列，举例：
>>> a = np.array(([1,2,3,4],[5,6,7,8],[9,10,11,12]))
>>> a[1:, 1] #取第二、三行的第二列数据
array([ 6, 10])
>>> a[:, 0:3] #取所有行的第一列到第三列数据
array([[ 1, 2, 3],
[ 5, 6, 7],
[ 9, 10, 11]])
...
省略号在数组当中也是可以使用的，也是切片的一种，但有所不同，举例：
>>> x = np.array([[[1],[2],[3]], [[4],[5],[6]]])
>>> x.shape
(2, 3, 1)
>>> x[...,0]
array([[1, 2, 3],
[4, 5, 6]])
>>> x[:,0]
# 发现和x[...,0]结果不一样
array([[1],
[4]])
>>> x[:,:,0]
# 和x[...,0]结果一样
array([[1, 2, 3],
[4, 5, 6]])
从上面可以看出...的切片效果就是将所有...以外没设置范围的地方都调整为:
random.randint(x,y,n)
随机数整数生成，前两个参数代表范围，第三个为可选，表示生成格式或者数量，比如：
>>> np.random.randint(1,10,10)
# 随机生成10个1到10的随机数
array([ 6, 5, 7, 6, 5, 4, 9, 9, 10, 5])
>>> np.random.randint(0, 256, (100, 80))
# 随机生成格式为100行80列的数组
array([[ 46, 100, 98, ..., 56, 97, 172],
[ 60, 141, 217, ..., 208, 157, 70],
[189, 200, 13, ..., 193, 95, 80],
...,
[ 88, 155, 253, ..., 183, 139, 182],
[ 24, 101, 117, ..., 103, 30, 77],
[ 88, 236, 35, ..., 47, 211, 189]])
上面那个是生成整数的随机数，还有rand()用来生成0到1之间的随机数，中间可以加参数代表生成几个，举例：
>>> np.random.rand(10) #生成10个0-1的随机数
array([0.42462596, 0.0985224 , 0.22108224, 0.46230285, 0.40928969,
0.54201574, 0.88982411, 0.8450716 , 0.21384846, 0.38896833])
random.random.normal(μ,σ,n)
生成一堆符合正态分布的数，第一个参数是均值，第二个参数是标准差，第三个参数是生成数，举例：
>>> a = np.random.normal(0,1,10)
>>> a
array([-0.55491277, -1.1161704 , 0.97514814, 1.99653332, -0.08500584,
0.64075696, 1.96409159, -0.11636198, 0.52605946, 0.90563603])
>>> a.mean()
0.513577451404013
>>> a.std()
0.9612030098851562
#当生成的数多了，精度自然也会提高
更多numpy.random参考：
http://www.mamicode.com/info-detail-507676.html
arange()
类似range，前两个参数代表范围，第三个代表阶值类似range，举例：
>>> np.arange(10)
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> np.arange(1,10,2)
array([1, 3, 5, 7, 9])
注：
发现了吗，像python自带的random、range虽然和这些几乎一样，但有个区别就是numpy下的这几个方法生成的都是array类型的，原来那些都是list类型
concatenate()
将数组整合在一起，数组不像列表那样可以直接加着整合，比如列表里：
>>> a = [1,2,3]
>>> b = [4,5,6]
>>> a+b
[1, 2, 3, 4, 5, 6]
>>> a*2
[1, 2, 3, 1, 2, 3]
从上面可以看出对列表进行运算都是把列表当成整体来运算，而对于数组里：
>>> a = np.array([1,2,3])
>>> b = np.array([4,5,6])
>>> a + b
array([5, 7, 9])
>>> a * 2
array([2, 4, 6])
可以看出对数组的运算是对他里面的值进行运算，因此要对数组进行列表那样的操作，就需要用上面那个方法，对上面的a、b举例：
>>> np.concatenate((a, b)) #以元组形式传入
array([1, 2, 3, 4, 5, 6])
sum()
计算总和，举例：
>>> np.sum([1,2,3])
6
上面的是对行内相加，如果是多行数据，并且希望是各行的对应数据之间相加，可以设置参数：axis=0（默认为1，即行内相加），举例：
>>> a = np.array([[1,2,3,4], [5,6,7,8], [1, 2, 3, 4]])
>>> a.sum() #全部数据之和
46
>>> a.sum(axis=0) #各行对应数据之和
array([ 7, 10, 13, 16])
注：
其他计算操作如：求对数用np.log()，向上取整用np.ceil()，比如3.1就变成4
unique()
去重，举例：
>>> np.unique([1,2,3,1,2,3,5,6,4])
array([1, 2, 3, 4, 5, 6])
>>> np.unique(np.array([1,2,3,1,2,3,5,6,4])) #对数组、列表都可以，但最终都是变成数组
array([1, 2, 3, 4, 5, 6])
drop()
丢弃
fillna()
对丢失值的填充
tile()
复制扩展数组，有两个参数，第一个是要复制扩展的数组，第二个参数是个元组，意思是变成几行几列，举例：
>>> a = np.array([1,2,3,4])
>>> np.tile(a, 2) #此时第二个参数相当于(1,2)，即扩展成1行2列（x轴变成原来2倍）
array([1, 2, 3, 4, 1, 2, 3, 4])
第二个参数的元组有几位，就代表几维，一般都是用二维，即两个值，代表几行几列，在列上扩展举例1：
>>> np.tile(a, (2, 1)) #扩展成2行1列
array([[1, 2, 3, 4],
[1, 2, 3, 4]])
其还能扩展到更多维，如三维举例：
>>> np.tile(a, (3, 2, 1)) #在三维下，分3组，每组2行1列
array([[[1, 2, 3, 4],
[1, 2, 3, 4]],
[[1, 2, 3, 4],
[1, 2, 3, 4]],
[[1, 2, 3, 4],
[1, 2, 3, 4]]])
四维举例：
>>> np.tile(a, (2, 3, 3, 2)) #在4维下，分2组，每组3个，每个3行2列
array([[[[1, 2, 3, 4, 1, 2, 3, 4],
[1, 2, 3, 4, 1, 2, 3, 4],
[1, 2, 3, 4, 1, 2, 3, 4]],
[[1, 2, 3, 4, 1, 2, 3, 4],
[1, 2, 3, 4, 1, 2, 3, 4],
[1, 2, 3, 4, 1, 2, 3, 4]],
[[1, 2, 3, 4, 1, 2, 3, 4],
[1, 2, 3, 4, 1, 2, 3, 4],
[1, 2, 3, 4, 1, 2, 3, 4]]],
[[[1, 2, 3, 4, 1, 2, 3, 4],
[1, 2, 3, 4, 1, 2, 3, 4],
[1, 2, 3, 4, 1, 2, 3, 4]],
[[1, 2, 3, 4, 1, 2, 3, 4],
[1, 2, 3, 4, 1, 2, 3, 4],
[1, 2, 3, 4, 1, 2, 3, 4]],
[[1, 2, 3, 4, 1, 2, 3, 4],
[1, 2, 3, 4, 1, 2, 3, 4],
[1, 2, 3, 4, 1, 2, 3, 4]]]])
发现了吗，可以这样理解第二个参数，那就是元组的最后两个数代表变成原来的几行几列，前面的数都是分多少组多少个，比如三维的3个数分别代表：几组几行几列；四维分别代表：几组几个几行几列；五维：几组几个几块几行几列；六…（单位是瞎编的，但是意思没错）
zero()
生成一个自定义大小值全为0的数组，传入参数是一个列表或元组，代表几行几列，举例：
>>> np.zeros([2,5])
array([[0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0.]])
其传入的列表也可以是多维的，比如：
>>> np.zeros([2,2,5]) #2组，每组2行5列
array([[[0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0.]],
[[0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0.]]])
多维的用法和tile()函数的基本一样，参考上面即可
注：
numpy里还有生成一个自定义大小值全为1的数组放方法：ones()，还有值都为空的数组：empty()
vstack()/hstack()
将两个数组在垂直/水平方向合并，举例：
>>> a = np.array([1,2,3,4])
>>> b = np.array([5,6,7,8])
>>> np.hstack((a,b))
array([1, 2, 3, 4, 5, 6, 7, 8])
>>> np.vstack((a,b))
array([[1, 2, 3, 4],
[5, 6, 7, 8]])
注：
如果是对当前数组自己进行垂直/水平方向合并，则相当于转成二维或者一维，举例：
>>> a = np.array([1,2,3,4])
>>> b = np.array([5,6,7,8])
>>> np.hstack(a)
array([1, 2, 3, 4])
>>> np.vstack(a)
array([[1],
[2],
[3],
[4]])
stack
也是把数组堆叠在一起，可以指定维度，默认维度是0，,即把数组看作一个整体堆叠在后面，和concatenate/vstack/hstack的区别参考：
https://cloud.tencent.com/developer/article/1378491
https://www.cnblogs.com/nkh222/p/8932369.html
举例：
>>> a = np.array([[1, 2, 3], [4, 5, 6]])
>>> a
array([[1, 2, 3],
[4, 5, 6]])
>>> b = a
>>> np.vstack((a, b))
array([[1, 2, 3],
[4, 5, 6],
[1, 2, 3],
[4, 5, 6]])
>>> np.hstack((a, b))
array([[1, 2, 3, 1, 2, 3],
[4, 5, 6, 4, 5, 6]])
# 整个拼在右边
>>> np.concatenate((a, b))
array([[1, 2, 3],
[4, 5, 6],
[1, 2, 3],
[4, 5, 6]])
>>> np.stack((a, b))
array([[[1, 2, 3],
[4, 5, 6]],
[[1, 2, 3],
[4, 5, 6]]])
stack的第二个参数，用于设置在第几个维度进行堆叠，举例：
>>> a = np.array([[1, 2, 3], [4, 5, 6]])
>>> a
array([[1, 2, 3],
[4, 5, 6]])
>>> a.shape
(2, 3)
>>> b = a
>>> np.stack((a, b), axis=0)
array([[[1, 2, 3],
[4, 5, 6]],
[[1, 2, 3],
[4, 5, 6]]])
# 在第0个维度堆叠，相当于新建一个维度
>>> np.stack((a, b), axis=0).shape
(2, 2, 3)
# 所以数据a从(2, 3) -> (1, 2, 3) -> (2, 2, 3)
>>> np.stack((a, b), axis=1)
array([[[1, 2, 3],
[1, 2, 3]],
[[4, 5, 6],
[4, 5, 6]]])
>>> np.stack((a, b), axis=1).shape
(2, 2, 3)
# 在第1个维度进行堆叠，所以数据a从(2, 3) -> (2, 1, 3) -> (2, 2, 3)
>>> np.stack((a, b), axis=2)
array([[[1, 1],
[2, 2],
[3, 3]],
[[4, 4],
[5, 5],
[6, 6]]])
>>> np.stack((a, b), axis=2).shape
(2, 3, 2)
# 在第2个维度进行堆叠，所以数据从(2, 3) -> (2, 3, 1) -> (2, 3, 2)
>>> np.stack((a, b), axis=-1)
array([[[1, 1],
[2, 2],
[3, 3]],
[[4, 4],
[5, 5],
[6, 6]]])
# -1代表在最后一个维度进行堆叠，所以看出和2的时候结果一样
linspace()
生成一个等差数列，举例：
>>> np.linspace(-1,1,5, dtype=np.float32) # -1到1分成5份的等差数列
array([-1. , -0.5, 0. , 0.5, 1. ], dtype=float32)
newaxis
如果直接输出，你会发现他就是None（源码里就是newaxis = None），但是他常被用来添加一个新的维度，比如一维向量变二维矩阵，二维则变三维等等，可能因为None在这里有这个功能，因为为了方便阅读程序而设置了一个别名，使用举例：
>>> np.newaxis == None # 可以发现他就是None
True
>>> x = np.array([1,2,3,4])
>>> x
array([1, 2, 3, 4])
>>> x.shape # 可以看出是一维的向量
(4,)
>>> x[:, np.newaxis]
array([[1],
[2],
[3],
[4]])
>>> x[:, np.newaxis].shape # 变成二维了
(4, 1)
sin()/cos()
正弦/余弦函数，举例：
>>> np.sin(math.pi/6)
0.49999999999999994
astype()
类型转换，举例：
>>> y
array([False, False, False, True, True])
>>> y.astype(np.int) #将bool类型转int
array([0, 0, 0, 1, 1])
数据类型范围：
这里列一些常用数据类型及对应范围：
NaN 没有填东西，也就是空
inf 无穷大
int8 -128~127
uint8 0~256
int16 32768~32767
uint16 0~65535
int/int32 -2^32~2^32-1
float16 半精度浮点型
float32 单精度浮点型
float_/float64 双精度浮点型
更多参考：https://www.runoob.com/numpy/numpy-dtype.html
dot()
矩阵相乘，举例：
>>> x = np.array([[1,2],[3,4]])
>>> y = np.array([[1,1],[1,1]])
>>> np.dot(x, y)
array([[3, 3],
[7, 7]])
也可以通过python内置的@符号实现矩阵相乘，举例：
>>> x = np.array([[1,2],[3,4]])
>>> y = np.array([[1,1],[1,1]])
>>> x@y
array([[3, 3],
[7, 7]])
T
矩阵转置，即x和y对调过来，举例：
>>> x = np.array([[1,2], [0, 1]])
>>> x
array([[1, 2],
[0, 1]])
>>> x.T
array([[1, 0],
[2, 1]])
mat()
定义矩阵，虽然array也能够定义矩阵，但并不是真正的矩阵，只是可以定义矩阵的形状，因此也缺少了一些矩阵专门有的方法，比如求逆矩阵（I属性实现），举例：
>>> x = np.mat([[1,2], [0, 1]])
>>> x
matrix([[1, 2],
[0, 1]])
>>> x.I
matrix([[ 1., -2.],
[ 0., 1.]])
>>> x @ x.I
# 可以看到相乘结果为1001，也就证明是逆矩阵了
matrix([[1., 0.],
[0., 1.]])
argmax()/argmin()
索引维度当中最大值/最小值，举例：
>>> x = np.array([[0.1, 0.6, 0.1], [0.3, 0.1, 0.6],[0.2, 0.5, 0.3], [0.8, 0.1, 0.1]])
>>> y = np.argmax(x) #索引整个数组最大元素
>>> y
9
#第10个最大，为0.8
>>> y = np.argmax(x, axis=1) #在每个维度（沿着一维方向）里面索引最大值
>>> y
array([1, 2, 1, 0], dtype=int32)
#每个维度最大的分别是0.6,0.6,0.5,0.8，位置分别是1,2,1,0
argsort()
沿着索引维度从小到大排序，返回的是排序后的索引，举例：
>>> x = np.array([2,1,5,4,3])
>>> x.argsort()
# 可以看到从小到大排序的索引
array([1, 0, 4, 3, 2], dtype=int64)
>>> x[x.argsort()]
# 通过索引查看对应排序的值
array([1, 2, 3, 4, 5])
>>> (-x).argsort()
# 如果想要从大到小排序，可以乘个负号
array([2, 3, 4, 0, 1], dtype=int64)
arctan
计算某个点的正切，举例：
>>> np.arctan(2/1)
1.1071487177940904
如果想知道对应的角度就可以乘以180/π，也可以用numpy下的rad2deg()方法，举例：
>>> np.arctan(2/1) * 180 / np.pi
63.43494882292201
>>> np.rad2deg(np.arctan(2/1))
63.43494882292201
# 可以看出结果一样
arctan2
和上面的很像，也是计算某个点的正切。但前者是计算某个点在正切曲线上对应的值，而这个则是计算某个点相对坐标(0, 0)的正切值，传入前两个参数分别是：y和x（记住第一个参数是y不是x），举例：
>>> np.arctan2(2, 1) * 180 / np.pi
# 坐标(1, 2)的正切值，可以看出和np.arctan(2/1)一样
63.43494882292201
>>> np.arctan2(-2, 1) * 180 / np.pi
# 坐标(1, -2)的正切值，想象一下，是在x轴下方，但是角度一样，因此为负
-63.43494882292201
>>> np.arctan2(2, -1) * 180 / np.pi
# 坐标(-1, 2)的正切值
116.56505117707799
reshape
改变数组的形状，其中-1代表对剩下的进行合并处理，举例：
>>> a = np.random.randint(0, 255, (50, 50, 50))
>>> a.shape
>>> a.reshape(500, 25, 10).shape
# 转成(500, 25, 10)
(500, 25, 10)
>>> a.reshape(50, -1).shape
# 转成(50, 剩下的)
(50, 2500)
>>> a.reshape(500, 10, -1).shape
# 转成(500, 10, 剩下的)
(500, 10, 25)
clip
限制数组范围，举例：
>>> x = np.array([i for i in range(10)])
>>> x
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> np.clip(x, 0, 5)
# 限制数组x范围在0~5
array([0, 1, 2, 3, 4, 5, 5, 5, 5, 5])
>>> x = np.array([i+.1 for i in range(10)])
>>> x
array([0.1, 1.1, 2.1, 3.1, 4.1, 5.1, 6.1, 7.1, 8.1, 9.1])
>>> np.clip(x, 0., 5.)
# 对于超过范围的数进行边界值处理，其他值不会处理
array([0.1, 1.1, 2.1, 3.1, 4.1, 5. , 5. , 5. , 5. , 5. ])
fabs
对数组的值去绝对值，举例：
>>> x = np.array([i for i in range(0, -10, -1)])
>>> x
array([ 0, -1, -2, -3, -4, -5, -6, -7, -8, -9])
>>> np.fabs(x)
array([0., 1., 2., 3., 4., 5., 6., 7., 8., 9.])
prod
计算阶乘，举例：
>>> np.prod(np.array([1,2,3,4]))
# 1*2*3*4
24
cum开头的方法
比如cumsum，可以知道sum是计算总和，那么cumsum返回的就是从第一个到第n个数里第n次进行操作的结果，举例：
>>> np.cumsum(np.array([1,2,3,4]))
# 1, 1+2, 1+2+3, 1+2+3+4
array([ 1, 3, 6, 10], dtype=int32)
>>> np.cumprod(np.array([1,2,3,4]))
array([ 1, 2, 6, 24], dtype=int32)
浮点数转换整数
参考：https://blog.csdn.net/sinat_34072381/article/details/84567523`
nonzero
返回所有不为0的数的索引，举例：
>>> np.nonzero(np.array([1,2,3,0,-1,0]))
# 第0、1、2、4个数不为0
(array([0, 1, 2, 4], dtype=int64),)
>>> x = np.array([[1,0,3], [4,5,0]])
>>> np.nonzero(x)
# 返回2个数组，第一个数组代表行的索引，第二个代表列的索引，比如这里就是：
# 0行0列、0行2列、1行0列、1行1列的都不为0，这样也方便我们索引数据
(array([0, 0, 1, 1], dtype=int64), array([0, 2, 0, 1], dtype=int64))
>>> x[np.nonzero(x)]
# 可以看到返回所有的非0数据
array([1, 3, 4, 5])
pad
填充数组，举例：
>>> x = np.array([1,2,3])
>>> x
array([1, 2, 3])
>>> np.pad(x, (1,0), 'constant')
# 在左边添加一个0
array([0, 1, 2, 3])
>>> np.pad(x, (1,2), 'constant')
# 在左边添加1个0，右边添加2个0
array([0, 1, 2, 3, 0, 0])
>>> np.pad(x, (1,2), 'mean')
# 在左边添加1个平均值，右边添加2个平均值
array([2, 1, 2, 3, 2, 2])
>>> np.pad(x, (1,2), 'edge')
# 填充边缘值
array([1, 1, 2, 3, 3, 3])
>>> y = np.random.rand(2, 3)
>>> y
array([[0.47236851, 0.1362846 , 0.16687831],
[0.57028361, 0.22399912, 0.49424253]])
>>> np.pad(y, (1, 1), 'constant')
# 对二维数据填充，如果只传入2个值，那么第一个默认是左边和上边的填充，第二个是右边和下边的填充
# 可以看出四边都填充了0
array([[0. , 0. , 0. , 0. , 0. ],
[0. , 0.47236851, 0.1362846 , 0.16687831, 0. ],
[0. , 0.57028361, 0.22399912, 0.49424253, 0. ],
[0. , 0. , 0. , 0. , 0. ]])
>>> np.pad(y, (1, 0), 'constant')
# 就左边和上边填充0
array([[0. , 0. , 0. , 0. ],
[0. , 0.47236851, 0.1362846 , 0.16687831],
[0. , 0.57028361, 0.22399912, 0.49424253]])
>>> np.pad(y, ((0, 1), (1, 1)), 'constant')
# 如果希望上下左右填充的维度都自己控制，那么就传入2个元组，依次代表上下左右
# 可以看到这里就上面没填充
array([[0. , 0.47236851, 0.1362846 , 0.16687831, 0. ],
[0. , 0.57028361, 0.22399912, 0.49424253, 0. ],
[0. , 0. , 0. , 0. , 0. ]])
>>> np.pad(y, ((0, 1), (0, 1)), 'constant')
# 填充右下
array([[0.47236851, 0.1362846 , 0.16687831, 0. ],
[0.57028361, 0.22399912, 0.49424253, 0. ],
[0. , 0. , 0. , 0. ]])
更多参考：https://blog.csdn.net/qq_36332685/article/details/78803622
打印数组显示省略问题
numpy中一般对于数组超过一定大小，就会以省略号形式显示，因此为了解决该问题，可以通过np.set_printoptions(threshold=行数)设置超过某个行数才以省略形式打印，举例：
>>> np.set_printoptions(threshold=10)
# 超过10行就省略号展示
>>> np.array([[[i] for i in range(100)]])
array([[[ 0],
[ 1],
[ 2],
...,
[97],
[98],
[99]]])
>>> np.set_printoptions(threshold=100)
# 超过100行...
>>> np.array([[[i] for i in range(100)]])
# 此处省略100行...
>>> np.set_printoptions(threshold=np.inf)
# 直接点，设置无穷大展示
踩坑记录
TypeError: only integer scalar arrays can be converted to a scalar index
看看你使用的方法里是不是传参有误，例如使用concatenate方法拼接数组时应该把数组都拼成一个列表/元组放进去：
>>> x = np.array([1,2,3])
>>> y = np.array([4,5,6])
>>> np.concatenate(x, y)
# 拼接报错，因为人家规定第一个参数就是接受所有的数组
Traceback (most recent call last):
File "", line 1, in
np.concatenate(x, y)
TypeError: only integer scalar arrays can be converted to a scalar index
>>> np.concatenate((x, y))
# 可以看到拼接成功
array([1, 2, 3, 4, 5, 6])