Numpy函数 - 悦读

、 3.np.add.at()   
 将传入的数组中制定下标位置的元素加上指定的值  
 >>> x=np.array([1,2,3,4])
 #将x中下标为0和为2的元素加上了3
 >>> np.add.at(x,[0,2],3)
 >>> x
 array([4, 2, 6, 4])
 ------------------------------------
 >>> a = np.array([1, 2, 3, 4])
 #在a[0]的位置上加1，在a[1]的位置上加2
 >>> b = np.array([1, 2])
 >>> np.add.at(a, [0, 1], b)
 >>> print(a)
 array([2, 4, 3, 4])
 
 4.np.add.outer()    
 将第一个列表或数组中的每个元素依次加到
 第二个列表或数组中的每个元素，得到每一行    >>> np.add.outer([1,2,3],[4,5,6,7])
 array([[ 5, 6, 7, 8],[ 6, 7, 8, 9], [ 7, 8, 9, 10]])
 
 5.np.add.reduceat(x,list)   
 在各切片上作reduce运算,根据传入的list(第二个参数)作指定的变化，传入的list中的数字是成对出现的 
 >>> x=np.arange(8)
 >>> x
 array([0, 1, 2, 3, 4, 5, 6, 7])
 >>> np.add.reduceat(x,[0,4,1,5,2,6,3,7]) #在各切片上作reduce运算
 array([ 6, 4, 10, 5, 14, 6, 18, 7], dtype=int32)
 
 ’’’
 x中0,4部分切片作np.add.reduce()运算(也就是连加)，放在第一个位置，然后第二个位置就是下标4在x中的值，也就是4,第三个位置是 x中1，5部分切片作np.add.reduce()运算
 ’’’

2.numpy.info()查看函数的帮助文档

np.info(function)从命令行获得numpy中函数的文档，获取函数信息

1.numpy.lookfor()查找指定的函数:numpy.lookfor("resize")

2.numpy.lookfor()在指定module中查找指定函数:

numpy.lookfor("resize", module="numpy")

3.math.isclose()以及np.allclose()用法

 1.import math
 math.isclose()综合了绝对接近和相对接近两个选项
 math.isclose(a, b, rel_tol=1e-09, abs_tol=0.0)
 numpy的isclose方法，比较两个array是不是每一元素都相等，默认在1e-05的误差范围内。
 
 numpy.isclose(a, b, rtol=1.e-5, atol=1.e-8, equal_nan=False)
 参数：
 a, b : 对比的数组
 rtol : 相对公差参数
 atol : 绝对公差参数
 equal_nan : bool，默认False，即NaN值默认不等，如果为True，a与b相同位置的NaN元素将判断相等
 判断公式：
 absolute(a - b) <= (atol + rtol * absolute(b))
 
 其中rel_tol就是相对忍耐值，abs_tol就是绝对忍耐值。到时候会判断两个忍耐值哪个最大，然后取那个忍耐值作为判断是否接近的依据。简而言之就是下面这个公式：
 
 abs(a-b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol).
 结果是一个布尔值。
 
 
 2.import numpy as np
 
 这个api也是同理，但是可以同时比较多个，多个都接近，那么返回接近。
 np.allclose(a, b, rtol=1e-05, atol=1e-08)
 #参数与numpy.isclose相同，判断公式也一样，区别在于numpy.isclose输出a，b两个数组每个位置判断的bool值，而numpy.allclose输出的是a，b两个数组整体的判断结果。
 a=[[1,2],[3,4]]
 b=[[1,3],[3,3]]、
 
 np.isclose(a,b)
 Out: 
 array([[ True, False],
        [ True, False]])
        
 np.allclose(a,b)
 #numpy.allclose源码：在nump.isclose基础上，使用all做进一步处理
 Out: False
 ##其有一点比较有意思，和上面不同，上面是绝对忍耐和相对忍耐的最大值作为最终的忍耐，这里是绝对忍耐加上相对忍耐（abs(b)*rtol+atol)
 
 a=np.array([1,2])
 b=np.array([2,3])
 np.allclose(a,b,rtol=0.1,atol=0.9)
     True
 可以验证，去掉任何一个忍耐值，结果都会是False。

4.np.max()和np.maximum()的区别

 1.
 np.max(a, axis=None, out=None, keepdims=False)
 求序列的最值
 最少接受一个参数
 axis默认为axis=0即列向,如果axis=1即横向
 np.max([-2, -1, 0, 1, 2])
 2.
 np.maximum(X, Y, out=None)
 X和Y逐位进行比较,选择最大值.
 最少接受两个参数
 ex:
 np.maximum([-3, -2, 0, 1, 2], 0)
 array([0, 0, 0, 1, 2])

5.np.concatenate()函数

 1.是numpy中对array进行拼接的函数，使用方法如下所示：
 import numpy as np
  
 x1 = np.random.normal(1,1,(5,4))
 x2 = np.random.normal(1,1,(3,4))
 print(x1)
 print(x1.shape)
 print(x2)
 print(x2.shape)
 con = np.concatenate([x1,x2],axis=0)
 print(con)
 print(con.shape)

6.np.min()和np.argmin()函数用法

 np.min()函数用于返回列表中的最小值
 np.argmin()函数用于返回一维列表最小值索引或多维列表展平之后的最小值索引
 import numpy as np
 lst1=[1,100,56,78,0]
 lst2=[[100,4,5],[3,5,7],[5,0,6]]
 print("lst列表中的最小值是:")
 print(np.min(lst1))
 print("lst1列表中最小值的索引是：")
 print(np.argmin(lst1))
 print("lst2列表中最小值的索引是：")
 print(np.argmin(lst2))

7. numpy.pad（）

 方法参数：pad(array, pad_width, mode, **kwargs)
 方法返回：填充后的[数组]
 array：表示需要填充的数组；
 pad_width：表示每个轴（axis）边缘需要填充的数值数目。
 mode：表示填充的方式（取值：str字符串或用户提供的函数）
 kwargs：定值扩充(定值由kwars传入)
 
 mode中的填充方式：
 constant’——表示连续填充相同的值，每个轴可以分别指定填充值，constant_values=（x, y）时前面用x填充，后面用y填充，缺省值填充0
 ‘edge’——表示用边缘值填充
 ‘linear_ramp’——表示用边缘递减的方式填充
 ‘maximum’——表示最大值填充
 ‘mean’——表示均值填充
 ‘median’——表示中位数填
 ‘minimum’——表示最小值填充
 ‘reflect’——表示对称填充
 ‘symmetric’——表示对称填充
 ‘wrap’——表示用原数组后面的值填充前面，前面的值填充后面
 eg:
     Z = np.ones((5,5))
     Z = np.pad(Z, pad_width=1, mode='constant', constant_values=0)
     print(Z)
 [[0. 0. 0. 0. 0. 0. 0.]
  [0. 1. 1. 1. 1. 1. 0.]
  [0. 1. 1. 1. 1. 1. 0.]
  [0. 1. 1. 1. 1. 1. 0.]
  [0. 1. 1. 1. 1. 1. 0.]
  [0. 1. 1. 1. 1. 1. 0.]
  [0. 0. 0. 0. 0. 0. 0.]]
     # Using fancy indexing
     Z[:, [0, -1]] = 0
     Z[[0, -1], :] = 0
     print(Z)
 [[0. 0. 0. 0. 0. 0. 0.]
  [0. 1. 1. 1. 1. 1. 0.]
  [0. 1. 1. 1. 1. 1. 0.]
  [0. 1. 1. 1. 1. 1. 0.]
  [0. 1. 1. 1. 1. 1. 0.]
  [0. 1. 1. 1. 1. 1. 0.]
  [0. 0. 0. 0. 0. 0. 0.]]
 
 np.pad(A,((3,2),(2,3)),'constant',constant_values = (-2,2))   #填充值，前面填充改为-2，后面填充改为2

8.np.unravel_index(indices, shape, order = ‘C’)

 np.unravel_index()一般与np.argmax(A)或 np.argmin(A) 配合使用
 
 indices: 整数构成的数组， 其中元素是索引值（integer array whose elements are indices into flattened version of array)
 shape: tuple of ints, 一般是原本数组的维度，也可以给定的新维度。
 
 A = np.random.randiant(1, 100, size = (2, 3, 5))
 print(A)
 array([[[98, 29, 32, 73, 90],
         [36, 52, 24,  2, 37],
         [66, 80, 23, 29, 98]],
 
        [[17, 32, 58, 99, 74],
         [53,  3, 20, 48, 28],
         [53,  7, 74, 34, 68]]])
    
 #利用argmax求最大值对应的索引
 ind_max = np.argmax(A)
 print(ind_max)
 18
 #由观察知， 18是矩阵A中99拉伸成一维之后的索引值， 接下来利用unravel_index求其在自身维度（2，3，5）下的索引值
 ind_max_src = np.unravel_index(ind_max, A.shape)
 print(ind_max_src)
 (1, 0, 3)
 #验证此索引值对应的元素为99
 print(A[ind_max_src])
 99
 
 index可以升维,假设取indices = (4, 7), 此时np.unravel_index输出的结果为3个数组（3即为A的维度），每个数组的第0位为下标为4的元素在A.shape下的下标， 每个数组的第1位为下标为7的元素在A.shape下的下标
 inds = np.unravel_index((4, 7), A.shape)
 print(inds)
 (array([0, 0]), array([0, 1]), array([4, 2]))
 #验证
 first_ind = (inds[0][0], inds[1][0], inds[2][0])
 Sec_ind = (inds[0][1], inds[1][1], inds[2][1])
 print(A[first_ind], A[Sec_ind])
 90, 24

9.np.tile

 np.tile(A,res)函数，A 是个数组，reps 是个元组,reps则决定A重复的次数。整个函数用于重复数组A来构建新的数组。
 reps可为一个可为数组，元组或列表
 reps可为一个值
 reps:(m,n),m控制纵向重复，n{n}n控制横向重复
 假设reps的维度为d，那么新数组的维度为max（d，A.ndim）。下面分三种情况进行讨论：
 （1）A.dim < d
 则向A中添加新轴扩充A的维度。维度大小可以从shape中看出，一般通过向shape对应的元组中添加1完成对A维度的扩充。扩充完成后，则可根据reps的值对A中相应维度的值进行重复。
 例如，一维数组shape为（3，），扩充至2维则shape值为（1,3），扩充至3维则shape值为（1,1,3）
 (2)A.dim > d
 将reps扩充至与A相同的维度。扩充方法同上，也是向shape对应元组中添1，然后再进行重复。
 例如，4维数组A的shape为（2,3,4,5），而reps为（2,2）只有2维，那么就要对reps添维进行扩充，得到（1,1,2,2）
 （3）A.dim = d
 不需要扩充，直接按reps的值对相应维度的值进行重复。
 
 import numpy as np
 a = np.array([0,1,2,3])
 np.tile(a, 2)   # shape可以是一维的，此时可以不用元组表示
 -->array( [0, 1, 2, 3, 0, 1, 2, 3] )
 np.tile(a, (2,2))
 -->array( [ [0, 1, 2, 3, 0, 1, 2, 3] ,
           [0, 1, 2, 3, 0, 1, 2, 3] ] )
 np.tile(a, (2,1,2))
 -->array( [ [ [0, 1, 2, 3, 0, 1, 2, 3] ] ,
           [ [0, 1, 2, 3, 0, 1, 2, 3] ] ] )
 np.tile(a,(2,1))第一个参数为Y轴扩大倍数，第二个为X轴扩大倍数。本例中X轴扩大一倍便为不复制

10.np.dot

 np.dot()函数主要有两个功能，向量点积和矩阵乘法，这里我就简单列举了三种最常用到的情况
 1. np.dot(a, b), 其中a为一维的向量，b为一维的向量，当然这里a和b都是np.ndarray类型的, 此时因为是一维的所以是向量点积。
     import numpy as np 
     a = np.array([1, 2, 3, 4, 5])
     b = np.array([6, 7, 8, 9, 10])
     print(np.dot(a, b))
 output:
     130
     [Finished in 0.2s]
 
 2. np.dot(a, b), 其中a为二维矩阵，b为一维向量，这时b会被当做一维矩阵进行计算
 
     import numpy as np
      
     a = np.random.randint(0,10, size = (5,5))
     b = np.array([1,2,3,4,5])
     print("the shape of a is " + str(a.shape))
     print("the shape of b is " + str(b.shape))
     print(np.dot(a, b))
   output:
     the shape of a is (5, 5)
     the shape of b is (5,)
     [42 85 50 81 76]
     [Finished in 0.2s]
 
 这里需要注意的是一维矩阵和一维向量的区别，一维向量的shape是(5, ), 而一维矩阵的shape是(5, 1), 若两个参数a和b都是一维向量则是计算的点积，但是当其中有一个是矩阵时（包括一维矩阵），dot便进行矩阵乘法运算，同时若有个参数为向量，会自动转换为一维矩阵进行计算。
 
  
 
 3. np.dot(a ,b), 其中a和b都是二维矩阵，此时dot就是进行的矩阵乘法运算
 
     import numpy as np
      
     a = np.random.randint(0, 10, size = (5, 5))
     b = np.random.randint(0, 10, size = (5, 3))
     print("the shape of a is " + str(a.shape))
     print("the shape of b is " + str(b.shape))
     print(np.dot(a, b))
      
      
     output:
     the shape of a is (5, 5)
     the shape of b is (5, 3)
     [[ 66  80  98]
      [ 53  60  60]
      [ 65  84  85]
      [ 25 113 101]
      [ 42  78  77]]
     [Finished in 0.2s]

 1.如何在两个数组之间找到公共值(★☆☆)
 Z1 = np.random.randint(0,10,10)
 Z2 = np.random.randint(0,10,10)
 print(Z1,Z2)
 print(np.intersect1d(Z1,Z2))
 
 2.如何忽略所有numpy警告（不推荐）(★☆☆)
 # Suicide mode on
 defaults = np.seterr(all="ignore")#加上后不报错
 Z = np.ones(1) / 0 #直接运行报错信息
 # Back to sanity
 _ = np.seterr(**defaults)#加上忽略信息
 # Equivalently with a context manager
 with np.errstate(all="ignore"):★★★加上with...不报错
     np.arange(3) / 0#直接运行会有警告信息
 -->[nan inf inf]

11.numpy.seterr

 numpy.seterr(all=None, divide=None, over=None, under=None, invalid=None)
 
 1.all : {‘ignore’, ‘warn’, ‘raise’, ‘call’, ‘print’, ‘log’},
 ignore:异常发生时不处理。
 warn:打印一个RuntimeWarning(通过Python warnings模块)。
 raise:引发FloatingPointError。
 call:调用使用seterrcall函数指定的函数。
 print:直接将警告打印到标准输出。
 log:在seterrcall指定的log对象中记录error。
 
 默认值是不更改当前行为。
 
 2.divide : {‘ignore’, ‘warn’, ‘raise’, ‘call’, ‘print’, ‘log’}, optional
 除零的处理方法。
 
 3.over : {‘ignore’, ‘warn’, ‘raise’, ‘call’, ‘print’, ‘log’}, optional
 浮点溢出的处理。
 4.under : {‘ignore’, ‘warn’, ‘raise’, ‘call’, ‘print’, ‘log’}, optional
 浮点下溢的处理。
 
 5.invalid : {‘ignore’, ‘warn’, ‘raise’, ‘call’, ‘print’, ‘log’}, optional
 无效浮点运算的处理。

12.日期

 1.yesterday = np.datetime64('today') - np.timedelta64(1)
 today     = np.datetime64('today')
 tomorrow  = np.datetime64('today') + np.timedelta64(1)
 print(yesterday,today,tomorrow)
 2022-08-15 2022-08-16 2022-08-17
 
 #获取2016-07到2016-08的所有日期
 Z = np.arange('2016-07', '2016-08', dtype='datetime64[D]')
 print(Z)
 ['2016-07-01' '2016-07-02' '2016-07-03' '2016-07-04' '2016-07-05'
  '2016-07-06' '2016-07-07' '2016-07-08' '2016-07-09' '2016-07-10'
  '2016-07-11' '2016-07-12' '2016-07-13' '2016-07-14' '2016-07-15'
  '2016-07-16' '2016-07-17' '2016-07-18' '2016-07-19' '2016-07-20'
  '2016-07-21' '2016-07-22' '2016-07-23' '2016-07-24' '2016-07-25'
  '2016-07-26' '2016-07-27' '2016-07-28' '2016-07-29' '2016-07-30'
  '2016-07-31']
 
 2.busday_offset(dates, offsets, roll=‘raise’, weekmask=‘1111100’, holidays=None, busdaycal=None, out=None)
 #dates:要处理的日期数组;
 #weekmask：str or array_like of bool, optional，即规定的一周工作日与非工作日分别为哪天（默认为1111100，即周六、周日为非工作日）。
 #holidays：array_like of datetime64[D], optional，即可以人工设置哪一天为假期（非工作日），默认为None。
 #busdaycal：busdaycalendar, optional，即可以人工指定哪一天为工作日，如果设置此参数，则指定的weekmask参数以及holidays参数都会无效，默认为None。
 #out：如果提供，则用结果填充该数组，默认为None。
 #offsets：偏移量数组，若小于零，则返回在工作日中向前查找offsets绝对值大小步长的日期；若大于零，则返回在工作日中向后查找offsets绝对值大小步长的日期。
 
 a = np.busday_offset('2020-10-16',offsets = 1)
 print(a)
 输出：2020-10-19
 
 3.
 numpy.is_busday(dates, weekmask='1111100', holidays=None, busdaycal=None, out=None)
 #函数的功能为返回指定日期是否为工作日。
 import numpy as np
 # 2020-07-10 星期五
 a = np.is_busday('2020-07-10')
 b = np.is_busday('2020-07-11')
 print(a)  # True
 print(b)  # False
 #此函数还可以用于统计一段时间内的天数
 begindates = np.datetime64('2020-07-10')
 enddates = np.datetime64('2020-07-20')
 a = np.arange(begindates, enddates, dtype='datetime64')
 b = np.count_nonzero(np.is_busday(a))
 print(a)
 # ['2020-07-10' '2020-07-11' '2020-07-12' '2020-07-13' '2020-07-14'
 #  '2020-07-15' '2020-07-16' '2020-07-17' '2020-07-18' '2020-07-19']
 print(b)  # 6
 
 4.numpy.busday_count()
 #函数的功能为返回两个日期之间的工作日的数量
 numpy.busday_count(begindates, enddates, weekmask='1111100', holidays=[], busdaycal=None, out=None)
 # 2020-07-10 星期五
 begindates = np.datetime64('2020-07-10')
 enddates = np.datetime64('2020-07-20')
 a = np.busday_count(begindates, enddates)
 b = np.busday_count(enddates, begindates)
 print(a)  # 6
 print(b)  # -6

 A = np.ones(3)*1
 B = np.ones(3)*2
 print(A,B)-->[1. 1. 1.] [2. 2. 2.]
 np.add(A,B,out=B)#A,B相加，再去掉B
 print(A,B)-->[1. 1. 1.] [3. 3. 3.]
 np.divide(A,2,out=A)#A,2相除，再去掉A
 print(A,B)-->[0.5 0.5 0.5] [2. 2. 2.]
 np.negative(A,out=A)#获取A相反数，再去掉原来的A
 print(A,B)-->[-1. -1. -1.] [2. 2. 2.]
 np.multiply(A,B,out=A)#A,B数组对应元素位置相乘，再去掉A
 print(A,B)-->[-2. -2. -2.] [2. 2. 2.]

13.使数组不可变（只读）(★★☆)

 Z = np.zeros(10)
 Z.flags.writeable = False
 Z[0] = 1

14.np.iinfo ,np.finfo

 np.iinfo 返回值是int8、int16、int32、int64 数据类型的最大值和最小值
 np.finfo 返回值是float16、float32、float64数据类型的最大值和最小值以及各种参数。
 np.finfo(np.float32).eps
 eps是取非负的最小值。
 iexp: int浮点数的指数部分中的位数
 machar : MachAr计算这些参数并保存更多详细信息的对象。
 machep : int 产生``eps''的指数。    
 max :适当类型的浮点数,可表示的最大数字。   
 maxexp :导致溢出的基极（2）的最小正功率。
 min:最小的可表示数字，通常是“ -max”。
 minexp : int基数（2）的最大负幂与尾数中没有前导0一致。    
 nexp : int指数中的位数，包括其符号和偏差。
 nmant : int尾数的位数。    
 negep : int产生``epsneg''的指数。
 precision : int这种浮点数精确到的近似十进制数字    
 resolution:适当类型的浮点数,此类型的近似十进制分辨率，即``10 **-precision''。 tiny :  适当类型的浮点数 ,最小幅度的可用数字。   
 dtype :浮点类型，dtype或实例,获取有关信息的浮点数据类型的种类。

15.数组的升维与降维：np.atleast

1.升维

 numpy.atleast_1/2/3d
 #1.
 numpy.atleast_1d(*arys)
 将输入转换为至少一维的数组。
 &&&标量输入被转换为一维数组，而高维输入被保留。
 #参数 :arys1, arys2, … ：array_like
 #一个或多个输入数组。
 返回值 ：ret ：ndarray
 一个数组或数组列表，每个数组均带有a.ndim>= 1。 仅在必要时进行复印。
 > np.atleast_1d(1.0)
 array([1.])
 >>> x = np.arange(9.0).reshape(3,3)
 >>> np.atleast_1d(x)#二维数组被保留
 array([[0., 1., 2.],
        [3., 4., 5.],
        [6., 7., 8.]])
 >>> np.atleast_1d(x) is x
 True
 
 >>> np.atleast_1d(1, [3, 4])
 [array([1]), array([3, 4])]
 
 #2.
 numpy.atleast_2d(*arys)     
 将输入视为至少具有二维的数组。
 #参数 ：
 arys1, arys2, … ：array_like
 一个或多个类似数组的序列。 非数组输入将转换为数组。 
 保留已经具有二维或更多维的数组。
 
 返回值 ：
 res, res2, … ：ndarray
 一个数组或数组列表，每个数组均带有a.ndim>= 2。 
 尽可能避免复制，并返回二维或更大尺寸的视图。
 
 例子:
 >>> np.atleast_2d(3.0)
 array([[3.]])
 
 >>> x = np.arange(3.0)-->[0. 1. 2.]
 >>> np.atleast_2d(x)
 array([[0., 1., 2.]])
 >>> np.atleast_2d(x).base is x
 True
 
 >>> np.atleast_2d(1, [1, 2], [[1, 2]])#1, [1, 2], [[1, 2]]为三个不同的数组，把他们分别转换为二维数组
 -->[array([[1]]), array([[1, 2]]), array([[1, 2]])]
 a = np.array([1,2,3,4,5])
 -->array([1, 2, 3, 4, 5])
 #将数组升为二维数组
 a = np.atleast_2d(a)
 -->array([[1, 2, 3, 4, 5]])
 #通过转置来改变二维数组的形状
 a = a.T
 >array([[1],
        [2],
        [3],
        [4],
        [5]])
 
 #3.
 array[:,np.newaxis] 升维一次 n行一列
 a = np.array([1,2,3,4,5])
 a[:,np.newaxis]
 -->array([[1],
        [2],
        [3],
        [4],
        [5]])
 #4.
 array[np.newaxis,:] 升维一次 一行n列
 a = np.array([1,2,3,4,5])
 a[np.newaxis:,]
 -->array([[1, 2, 3, 4, 5]])
 #5.
 array.reshape(-1,1) 变成n行一列
 a = np.array([[1,2,3,4,5],[1,2,3,4,5]])
 a.reshape(-1,1)
 -->array([[1],
        [2],
        [3],
        [4],
        [5]
        [1],
        [2],
        [3],
        [4],
        [5]])
 #6.
 array.reshape(1,-1) 变成一行n列
 a = np.array([1,2,3,4,5])
 a.reshape(1,-1)
 -->array([[1, 2, 3, 4, 5]])
 #7.
 np.expand_dims(a, axis)#axis=0/1
 a = np.array([1,2,3,4,5])
 np.expand_dims(a, axis=0)#变成一行n列
 -->array([[1, 2, 3, 4, 5]])
 np.expand_dims(a, axis=1)#变成1列n行
 -->array([[1],
        [2],
        [3],
        [4],
        [5]])

2.降维

 #1.array.ravel()
 不管几维都转换为一维
 a = np.array([[1,2,3,4,5]])
 a.ravel()
 -->array([1, 2, 3, 4, 5])
 
 
 #2. np.squeeze(array)
 #只限定为1行n列数组
 a = np.array([[1,2,3,4,5]])
 np.squeeze(a)
 -->array([1, 2, 3, 4, 5])
 
 
 #3. array.reshape(-1)
 不管里面的数是多少，都转换为一维(只要是负数)
 如果为正数,需要是几行几列的形式,且符合数组划分,比如10个数,可以是2行5列或5行2列
 a = np.array([[1,2,3,4,5]])
 a.reshape(-1)
 -->array([1, 2, 3, 4, 5])
 a = np.array([[[1,2,3,4,5]],[[1,2,3,4,5]]])
 a = a.reshape(2,5)
 -->[[1 2 3 4 5]
  [1 2 3 4 5]]
 
 #4.array.flatten（）：返回源数据的副本,把里面的数全部一维输出
 
 a = np.array([[1,2,3,4,5]])
 a.flatten()
 -->array([1, 2, 3, 4, 5])
 a = np.array([[[[1,2,3,4,5],[12,11,13,14,15]]],[[[16,17,18,19,20],[1,2,3,4,5]]]])
 a = a.flatten()
 -->[ 1  2  3  4  5 12 11 13 14 15 16 17 18 19 20  1  2  3  4  5]
 #注意：
 #矩阵可以通过转置（array.T或array.transpose() ）来生成想要的m行n列或n行m列
 
 import numpy as np
 a = np.array([1,2,3,4,5])
 -->array([[1, 2, 3, 4, 5, 6]])
 
 a.shape#几行几列
 -->(1,6)
 
 a = a.T
 -->array([[1],
        [2],
        [3],
        [4],
        [5],
        [6]])
 a.shape
 -->(6, 1)
 
 a = np.array([[[[1,2,3,4,5],[12,11,13,14,15]]],[[[16,17,18,19,20],[1,2,3,4,5]]]])
 a = a.T
 -->
 [[[[ 1 16]]
   [[12  1]]]
 
  [[[ 2 17]]
   [[11  2]]]
 
  [[[ 3 18]]
   [[13  3]]]
 
  [[[ 4 19]]
   [[14  4]]]
 
  [[[ 5 20]]
   [[15  5]]]]

15.np.put(a, ind, v, mode=‘raise’)

 np.put加入参数
 a:目标数组
 ind:目标索引，解释为整数。
 v:放置在目标索引中的值。如果v比ind短，它将在必要时重复。
 mode: 模式:{' raise '， ' wrap '， ' clip '}，可选指定越界索引的行为方式。         ' raise ' -引发错误(默认)
         ' wrap ' -环绕，当索引超过数组时，进行循环，取索引
         ' clip '——剪辑到范围内
         ' clip '模式意味着所有太大的索引将被指向该轴上最后一个元素的索引所取代。注意，这将禁用负数索引。在“提高”模式中,如果发生异常目标数组可能仍然被修改。(“剪辑”模式意味着所有太大的索引都将替换为沿该轴寻址最后一个元素的索引)。
 1.a = np.array([0,5,6,75,6])
 np.put(a, [0, 2], [-44, -55])#把索引为0,2的数字替换成-44, -55
 print(a)-->[-44   5 -55  75   6]
 2.a = np.arange(5)
 np.put(a, 22, -5, mode='clip')#22超过a的索引值，clip——剪辑到范围内所以默认为最后一个索引
 print(a)-->[ 0  1  2  3 -5]

16.np.putmask()

 numpy.putmask(a, mask, values)
 mask:布尔面具数组。它必须和a的形状相同。
 values:要放入掩码为True的值。如果值小于a，则重复。
     
 x = np.arange(6).reshape(2, 3)
 np.putmask(x, x>2, x**2)#将数组a中的满足条件大于2的值做平方操作,当给出的values值额个数小于满足条件的数组中的值得个数时，需要将给定的值重复
 print(x)-->[[ 0, 1, 2],
         [ 9, 16, 25]]
 x = np.arange(5)
 np.putmask(x, x>1, [-33, -44])#在这里满足大于1的值得个数超过了2个,在进行值的替换的过程中就主要是对这一values进行重复
 print(x)-->[ 0, 1, -33, -44, -33]

17.np.place()

 numpy.place(arr, mask, vals)
 根据条件值和输入值更改数组元素。
 arr = np.arange(6).reshape(2, 3)
 np.place(arr, arr>2, [44, 55])
 arr-->[[ 0, 1, 2],
 [44, 55, 44]]
 #将arr中满足值大于2的元素用给定的值进行替换，出现给定的值的个数与满足条件的个数不同时，就相当于把values值进行重复操作

18.numpy.copyto()

 numpy.copyto(dst, src, casting=‘same_kind’, where=True)
 a=np.arange(4).reshape(2,2)
 b=np.array([5,3,8,2]).reshape(2,2)
 print(a)-->[[0 1]
 [2 3]]
 print(b)-->[[5 3]
 [8 2]]
 print('***')
 np.copyto(a,b)
 print(a)-->[[5 3]
 [8 2]]
 print(b)-->[[5 3]
 [8 2]]

二.数学函数

 #1.
 np.exp(B) : 求e的幂次方
 np.sqrt(B):求B的开方（算数平方根）
 np.arctan()函数求反三角函数，
 np.square(a): 计算各元素的平方 
 np.abs(a) np.fabs(a) : 取各元素的绝对值 
 #多维数组切片
 np.rint(a) : 各元素 四舍五入 
 np.modf(a) : 将数组各元素的小数和整数部分以两个独立数组形式返回 
 np.exp(a) : 计算各元素的指数值 
 np.sign(a) : 计算各元素的符号值 1（+），0，-1（-） 
 np.mod(a, b) : 元素级的模运算 
 np.copysign(a, b) : 将b中各元素的符号赋值给数组a的对应元素
 #numpy随机数函数
 poisson(lam, size) : 产生泊松分布的数组， lam随机事件发生概率，size为形状 
 shuffle(a) : 根据数组a的第一轴进行随机排列，改变数组a 
 permutation(a) : 根据数组a的第一轴进行随机排列， 但是不改变原数组，将生成新数组 
 choice(a[, size, replace, p]) : 从一维数组a中以概率p抽取元素， 形成size形状新数组，replace表示是否可以重用元素，默认为False。
     
 #numpy的统计函数
 argmin(a) argmax(a) : 计算数组a的最小、最大值的下标（注：是一维的下标） 
 unravel_index(index, shape) : 根据shape将一维下标index转成多维下标 
 ptp(a) : 计算数组a最大值和最小值的差 
 median(a) : 计算数组a中元素的中位数（中值）     
     
 #2.np.rad2deg()函数和np.deg2rad()函数
 np.rad2deg()把弧度值转换为角度值
 np.deg2rad()把角度值转换为弧度值
 
 #3.np.tile(A,B)函数
 重复A，B次，这里的B可以时int类型也可以是远组类型
 print(np.tile(1,5))-->[1 1 1 1 1]
 
 #4.np.repeat()函数重复相关的词义
 np.repeat(1, 5)
 -->array([1, 1, 1, 1, 1])
 # 1 重复5次
 
 #5.np.squeeze()从数组的形状中删除单维条目，即把shape中为1的维度去掉
 a = np.array([[1], [2], [3]])
 a1 = np.squeeze(a)
 print(a1)
 print(a1.shape)
 -->[1 2 3]
 shape:(3,)