NumPy简介

Numpy是一个Python包，它代表“Numeric Python”.它是一个有多维数组对象和用于处理数组的集合组成的库。Numeric,即Numpy的前身，是由 Jim Hugunin 开发的。 也开发了另一个包 Numarray ，它拥有一些额外的功能。 2005年，Travis Oliphant 通过将 Numarray 的功能集成到 Numeric 包中来创建 NumPy 包。 这个开源项目有很多贡献者。

标量（scalar）：一个标量就是一个单独的数标量通常被赋予小写的变量名称。
向量(vector)：一个向量是一列数，这些数是有序排列的，通过次序中的索引，我们可以确定每个单独的数，通常被赋予向量粗体的小写变量名称。
矩阵（matrix）:矩阵是具有相同特征和纬度的对象的集合，表现为一张二维数组。
张量（tensor）：超过两维的数组。一般的，一个数组中的元素分布在若干为坐标的空间中，将其称为张量。

Numpy基础

Numpy的主要对象是同种元素的多维数组，这是一个所有的元素都是一种类型，通过一个正整数元素索引的元素表格，在Numpy中维度（dimensions）叫做轴(axes),轴的个数叫做秩（rank）.

例如，在一个3D空间一个点的坐标[1,2,3]是一个秩为1的数组因为它只有一个轴。那个轴长度为3

[[1.,0.,0.],         # 此数组的秩为2，（因为它有两个维度）第一个维度长度为2，第二个维度长度为3
 [0.,1.,2.]]

Numpy的数组类被称为ndarray，通常被称作数组。注意numpy.array和标准Python库类array.array并不相同，后者只处理一维数组提供少量功能。而ndarray对象属性有：

• nsarray.ndim:数组轴的个数，在Python世界中，轴的个数被称作秩。
• ndarray.shape:数组的维度。这是一个指示数组在每个维度上大小的整数元组。例如一个n排m列的矩阵它的shape属性将是（2，3），这个元组的长度显然是秩，即维度或ndim属性。
• ndarray.size数组元素的总个数，等于shape属性中元组元素的乘积。
• ndarray.dtype一个用来描述数组中元素类型的对象，可以通过创造或指定dtype使用标准python类型，另外Numpy提供它自己的数据类型。
• ndarray.itemsize数组中每个元素的字节大小。例如：一个元素类型为float64的数组itemsize属性值为8（=64/8）。
• ndarray.data包含实际数组元素的缓冲区，通常不使用这个属性，因为我们总是通过索引来使用数组中的元素。

import numpy as np

a = np.arange(15).reshape(3,5)
print(a)      # [[ 0  1  2  3  4],[ 5  6  7  8  9],[10 11 12 13 14]]
print(a.shape)    # (3, 5)
print(a.ndim)     # 2
print(a.dtype.name)     # int32
print(a.itemsize)     # 4
print(a.size)       # 15

ndarray对象创建事例

#利用嵌套序列(一组等长列表组成的列表),将生成多维数组
In [4]: arr1=np.array([[1, 2], [3, 4]])
In [4]: arr1
Out[4]: 
array([[1, 2],
       [3, 4]])
In [3]: np.array([1, 2, 3],ndmin=2)
Out[3]: array([[1, 2, 3]])
#从子类中产生一个数组:
In [3]: np.array(np.array([1, 2, 3]), subok=True)
Out[76]: array([1, 2, 3])

#每个数组都有一个shape(一个表示各维度大小的元组) ：
In [6]: arr1=np.array([[1, 2], [3, 4]])
In [6]: arr1.shape
Out[6]: (2,2)

#可以利用numpy的reshape 或ndarray类的reshape方法更改数组维度大小
a.reshape(shape, order='C')
reshape(a, newshape, order='C')
shape:表示新数组形状大小的整数或元组  # a.reshape(3,2)
newshape:表示新数组形状大小的元组    #np.reshape(a,(3,2))

备注:新数组不会更改原数组的数据

#可以利用ndarray的astype方法转换数组数据类型：
astype(dtype, order='K', casting='unsafe', subok=True, copy=True)
dtype: 需要转换的类型

In [7]: arr1=np.array([[1, 2], [3, 4]])
In [7]: arr1.astype(np.float)
Out[7]: 
array([[1., 2.],
       [3., 4.]])

arange([start,] stop [, step,], dtype=None)

函数功能:在start,stop间生成一个间隔为step等差数列的一维数组;
参数说明:
start : 数组的起始数据,包含该数据,可省略,若省略起始值为0;
stop:    数组的截至数据,不包含该数据;
step:    数组数据间的间隔.可省略,缺省为1;
dtype:  生成数组中数据的类型

返回值:  ndarray 对象

In [10]: np.arange(1,6,2)
Out[10]: array([1, 3, 5])

In [10]: np.arange(1,6)
Out[10]: array([1, 2,3,4,5])

linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)

功能:在start,stop间生成一个数量为num的等差数列的一维数组;
参数说明:
start :  生成数组的起始数据,
stop:    生成数组的截至数据,是否包含该数据取决endpoint的值;
num:     生成数组中数据个数;
endpoint:生成数组的截至数据是否包含stop,true 包含,否则不
         包含;
retstep: 生成返回值是否包含step ,true 包含,否则不包含
dtype:  生成数组中数据的类型

返回值: endpoint  为true  返回ndarray 对象,step, 否则只返回 ndarray 对象.

#创建步长为1/4 的等差数列的一维数组
in[150]: np.linspace(2.0, 3.0, 5)
Out[146]: array([ 2.  ,  2.25,  2.5 ,  2.75,  3.  ])

#创建步长为1/5的等差数列的一维数组
in[149]: np.linspace(2.0, 3.0, 5,endpoint=False)
Out[149]: array([ 2. ,  2.2,  2.4,  2.6,  2.8])

#返回step
in[150]: arr1,step=np.linspace(2.0, 3.0, 5,retstep=True)
in[151]: arr1
Out[151]: array([ 2.  ,  2.25,  2.5 ,  2.75,  3.  ])
in[151]: step
Out[152]: 0.25

logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)

功能:和linspace类似,不过创建的数组是等比数列
base: 基数

#生成从   10^0   到  10^1   有5个元素的等比数列  
in[149]: np.logspace(0, 1, 5)
Out[149]:  array([  1.,   1.77827941, 3.16227766,
                     5.62341325,  10.        ])

#生成从   2^0   到  2^1   有5个元素的等比数列  
in[149]: np.logspace(0, 1, 5,base=2)
Out[149]:  array([ 1.,  1.18920712,  1.41421356, 
                   1.68179283,  2.])

zeros(shape, dtype=float, order='C')
功能:根据指定的数组形状大小和类型生成数据全为0的数组

in[149]: np.zeros(5)
Out[149]:    array([ 0.,  0.,  0.,  0.,  0.])
    
in[150]: np.zeros((5,), dtype=np.int)
Out[149]:   array([0, 0, 0, 0, 0])
    
in[149]: np.zeros((2, 1))
Out[149]:  array([[ 0.],
           [ 0.]])
    
in[149]: s = (2,2)
in[149]: np.zeros(s)
Out[149]:    array([[ 0.,  0.],
           [ 0.,  0.]])

ones(shape, dtype=None, order='C')
功能:根据指定的数组形状大小和类型生成数据全为1的数组

in[171] np.ones((3,2),np.int)
Out[171]: 
array([[1, 1],
       [1, 1],
       [1, 1]])

empty(shape, dtype=float, order='C')
功能:根据指定的数组形状大小和类型生成数据未初始化的数组;
未初始化的含义就是数组中的数据是随机值.
in[171] np.empty((3,2),np.int)
Out[171]: 
array([[        80, 2146435072],
       [         0, 2146435072],
       [ 202611408,          0]])

full(shape, fill_value, dtype=None, order='C')
功能:根据shape指定的数组形状大小和dtype类型生成数据全为fill_value的数组,
in[171] np.full((3,2),5,np.int)
Out[171]: 
array([[5, 5],
       [5, 5],
       [5, 5]])

其他(根据给定数组a的大小和类型生成数据全为0的数组)
zeros_like(a, dtype=None, order='K', subok=True)
ones_like(a, dtype=None, order='K', subok=True)
empty_like(a, dtype=None, order='K', subok=True)
full_like(a, fill_value, dtype=None, order='K', subok=True)

eye(N, M=None, k=0,dtype=<class 'float'>)

功能:生成大小为NxM,k对角上数据为1的二维数组,
参数说明:
N:数组的行数;
M:数组的列数,缺省的时候M=N;
K:对角索引,0,主对角,正值表示上对角,负值下对角

In[114]:np.eye(3,3,-1)
Out[114]: 
array([[ 0.,  0.,  0.],
       [ 1.,  0.,  0.],
       [ 0.,  1.,  0.]])

数组元素访问

一维数组的元素访问

In[122]: ar = np.arange(1,10)
In[123]: ar
Out[123]: array([1, 2, 3, 4, 5, 6, 7, 8, 9])

ar[3]:用整数做下标访问数组元素,下标为负,表示从后往前访问                  (从1开始计数)
ar[3:5]:用切片做下标访问数组元素
ar[:5]:切片中省略开始下标,表示从0开始
ar[:-1]:切片中使用负数,表示从数组最后一个元素向前访问
高级下标存取  (整数列表,整数数组,布尔数组)


In[122]: ar = np.arange(1,10)
In[123]: ar
Out[123]: array([1, 2, 3, 4, 5, 6, 7, 8, 9])

#整数列表做下标
In[123]: ar[[2,5,3,-3]]
Out[123]: array([3, 6, 4, 7])

#整数数组做下标
In[123]: ar1 = np.array([2,5,-1,7])
In[123]: arr[ar1]
Out[123]: array[3,6,9,8]

多维数组的元素访问

   多维数组的访问和一维数组类似,因为多维数组有多个轴(axis),所以它的下标需要用多个值来表示,

In [4]: arr=np.array([[1,2,3],[4,5,6],[7,8,9]])
In [5]: arr[2][1] #传统方式
Out[5]: 8
In [6]: arr[2,1] #使用逗号隔开索引列表，前面表示第一级索引，后面表示第二级索引
Out[6]: 8
In [7]: arr[(2,1)]  #使用元组，元组中每个数据和数组的每个轴对应
Out[7]: 8



切片索引: 
In [4]: arr=np.array([[1,2,3],[4,5,6],[7,8,9]])
In [5]: arr
Out[5]: array([[ 1,  2,  3],
        [ 4,  5,  6],
       [ 7,  8,  9]])
In [8]: arr[:2]
Out[8]: 
array([[1, 2, 3],
          [4, 5, 6]])
in [9]: arr[:2,1:]
Out[9]: 
array([ [2, 3],
           [5, 6]])



bool索引: 
通过布尔型索引选取数组中的数据，将总是创建数据的副本，即使返回一模一样数组也是如此。
通过布尔型数组设置值是经常使用的方法，如要将data里所有的的负值改为0，可以这样：

arr=np.array([[1,-2,3],[-4,5,6],[7,8,-9]])
arr
Out[189]: 
array([[ 1, -2,  3],
       [-4,  5,  6],
       [ 7,  8, -9]])

花式索引(Fancy indexing)是一个NumPy术语，指的是利用整数数组进行索引
In[200] :arr = np.empty((4,3),dtype = np.int32)
In[200] : for x in range (0,len(arr)):
      …:    arr[x]=x**2
      …:
In[201] : arr
Out[201]: 
array([[ 0,  0,  0],
       [ 1,  1,  1],
       [ 4,  4,  4],
       [ 9,  9,  9] ])

ufunc函数

ufunc 是(universal function)的缩写.它是一种能对数组的每个元素进行运算的函数,

 arr1=np.arrage(0,4)
 arr2=np.arrage(1,5)
 arr1+arr2        # array([1,  3,  5 ,  7]),
 arr1-arr2        #  array([-1,  -1,  -1 ,  -1]),
 arr1*arr2        # array([ 0,  2,  6, 12]),
 arr1/arr2        # array([0.  ,  0.5   , 0.66666667,  0.75 ])

数组排序：
sort(a, axis=-1, kind='quicksort', order=None)
参数说明:
a:     需排序的数组
axis: 轴索引,表示按照那个轴排序,-1表示按照最后一个轴排序
kind: 排序方式,可选 快速排序,归并排序,堆排序,默认快速偏序
order: 如果a是含有字段的数组,表示先按那个字段排序

a=np.array([8,5,2,9,12])
a.sort()   #修改原数组a:array([ 2,  5,  8,  9, 12])
#np.sort(a) #和上面的等价

argsort(a, axis=-1, kind='quicksort', order=None)
返回排序后的数据在原数组中的索引

极值函数：
max(a, axis=None, out=None, keepdims=<class 'numpy._globals._NoValue'>)
参数说明:
a:操作的数组
axis:轴索引,默认会将a转换为一维后取最大值
out: 输出数组,用于放置输出结果
keepdims: 不常用,使用默认就可以了
返回值:返回沿着轴axis 的最大值
min(a, axis=None, out=None, keepdims=<class 'numpy._globals._NoValue'>)
返回值:返回沿着轴axis 的最小值


获取极值索引函数：
argmax(a, axis=None, out=None)
参数说明:
a:操作的数组
axis:轴索引,默认会将a转换为一维后取最大值索引
out: 输出数组,用于放置输出结果
返回值:返回沿着轴axis 的最大值的索引
argmin(a, axis=None, out=None)
返回值:返回沿着轴axis 的最小值的索引


获取条件索引函数：
argwhere(a)
功能:查找满足条件元素的索引。
参数说明:
a:操作的数组,往往是个bool数组
返回值:索引的ndarray类对象
In: x = np.arange(6).reshape(2,3)
Out:x
    array([[0, 1, 2],
           [3, 4, 5]])
In: np.argwhere(x>1)
Out:    array([[0, 2],
           [1, 0],
           [1, 1],
           [1, 2]])


获取非零元素索引函数：
 nonzero(a)
功能:查找数组中非零元素的索引。
参数说明:a:操作的数组
返回值:非零元素的索引组成的数组的元组,元组元素中数组对应位置上的元素,表示非零元素在原数组中的索引.
In: x = np.arange(6).reshape(2,3)
Out:x
    array([[0, 1, 2],
           [3, 4, 5]])
In: np.nonzero(x)
Out: (array([0, 0, 1, 1, 1], dtype=int64),
      array([1, 2, 0, 1, 2], dtype=int64))


数组条件选择：
where(condition, [x, y])
据condition条件,返回x 或 y 中的数据
conditon: bool 数组
In[101]:arr = np.arange(0,8)
# array([0,1,2,3,4,5,6,7])
In[102]:np.where(arr>3) 
Out[103]:(array([4, 5, 6, 7], dtype=int64),)
In[104]: np.where([[True, False], [True, True]],
         [[1, 2], [3, 4]],
         [[9, 8], [7, 6]])
Out[105]: array([[1, 8],
           [3, 4]])


数组极值过滤：
clip(a, a_min, a_max, out=None)
a.clip(min=None, max=None, out=None)
功能:将数组a中,小于a_min的的元素设为 a_min,大于a_max的的元素设为 a_max,
参数说明:
a_min,a_max : 可为标量,数组 或 None,如果为None表示在较低/较高位置不执行clip,但a_min,a_max不能同时为None
In: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
In: np.clip(a, [3, 4, 1, 1, 1, 4, 4, 4, 4, 4], 8)
Out: array([3, 4, 2, 3, 4, 5, 6, 7, 8, 8])

分段函数 (推荐使用)
piecewise(x, condlist, funclist, *args, **kw)
condlist:  bool数组列表，
funclist:待选择函数列表，
x=np.linspace(-4,4,100)
y=np.piecewise(x,[x>=0,x<0],
[lambda i:5*np.sin(i),lambda i: 5*np.sin(i*i)])
y1=np.piecewise(x,[ x>0, x<=0],[lambda i: 1/i,
             lambda i: np.exp(i) ])
plt.plot(x,y)
plt.plot(x,y1)
plt.show()


数组转置
transpose(a, axes=None)
功能:重排数组的尺寸
参数说明:
a:  需转换的数组，
axes:默认反转尺寸，否则根据给定的值对轴进行置换
In: x = np.arange(4).reshape((2,2))
Out:x
    array([[0, 1],
           [2, 3]])
In: np.transpose(x)
Out:    array([[0, 2],
           [1, 3]])


对于高维数组，transpose需要用到一个由轴编号组成的元组，才能进行转置。
假设 shape(z, x, y)
In [3]: arr = np.arange(16).reshape((2, 2, 4))
In [4]: arr
Out[4]: 
array([[[ 0, 1, 2, 3],
[ 4, 5, 6, 7]],
[[ 8, 9, 10, 11],
[12, 13, 14, 15]]])
In [6]: arr.shape
Out[6]: (2, 2, 4)
shape 的 x轴 与 y 轴的转换比较简单， 跟二维数组一样
In [27]: arr.transpose((0, 2, 1)) 
Out[27]: array([[[ 0, 4], [ 1, 5], [ 2, 6], [ 3, 7]], [[ 8, 12], [ 9, 13], [10, 14], [11, 15]]])


文件存取：
一，tofile()和fromfile()
tofile()将数组中的数据以二进制格式写进文件
tofile()输出的数据不保存数组形状和元素类型等信息
fromfile()函数读回数据时需要用户指定元素类型，并对数组的形状进行适当的修改
In [27]: arr = np.arange(0,12)
Out[27]: array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
In [28]: arr.shape=3,4
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
In [30]: arr.tofile('arr.bin')
In [32]: b=np.fromfile('arr.bin',dtype=arr.dtype)
In [36]: b.reshape(3,4) #还原原数组的形状


savetxt()和loadtext()
savetxt(fname, X, fmt='%.18e', delimiter=' ', newline='\n', header='', footer='', comments='# ‘)
loadtxt(fname, dtype=<class 'float'>, comments='#', delimiter=None, converters=None, skiprows=0, usecols=None, unpack=False, ndmin=0)
用来读写文本文件
In [56]: a=np.arange(0,12,0.5).reshape(4,-1)
In [58]: np.savetxt("a.txt",a)
In [59]: np.loadtxt("a.txt")
Out[59]: 
array([[ 0. , 0.5, 1. , 1.5, 2. , 2.5],
[ 3. , 3.5, 4. , 4.5, 5. , 5.5],
[ 6. , 6.5, 7. , 7.5, 8. , 8.5],
[ 9. , 9.5, 10. , 10.5, 11. , 11.5]])



save()和load()
save(file, arr, allow_pickle=True, fix_imports=True)
load(file, mmap_mode=None, allow_pickle=True, fix_imports=True, encoding='ASCII')
用 numpy 的”npy”格式将数组保存为二进制文件,或从用 numpy 的”npy”格式的二进制文件中加载数据
In : np.save('/tmp/123', np.array([[1, 2, 3], [4, 5, 6]]))
Out: np.load('/tmp/123.npy')
    array([[1, 2, 3],
           [4, 5, 6]])



savez()
savez(file, *args, **kwds)
用 numpy 的”npz”格式保存多个文件到一个二进制文件,
args:可变参数,输入要保存的数组,如果参数传入时没有关键字，则为相应的变量在``.npz``文件中，名称是‘arr_0’，‘arr_1’等。如果关键字在``.npz``中给出参数，相应的变量名称文件将匹配关键字名称。
x = np.arange(10)
y = np.arange(1,11)
np.savez(“multi.npz”,x,y) 
file =np.load(“multi.npz”)
file.files     # ['arr_0', 'arr_1']
file['arr_0']       # array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
file['arr_1']         # array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10])

矩阵创建

矩阵的创建有两种方法：
一.是使用np.mat函数或np.matrix函数；
二.是使用数组代替矩阵，使用二维数组代替矩阵来进行矩阵运算；
a=np.mat([[1,2,3],[4,5,6]])#使用mat函数创建一个2*3的矩阵In [4]: b=np.matrix([[1,2,3],[4,5,6]])#与np.mat函数效果一样
#使用二维数组来代替矩阵，常用方法
c=np.array([[1,2,3],[4,5,6]])#注意c是array类型，而a是matrix类型

矩阵的复合构造：
vstack(tup) 功能: 按行顺序堆叠数组
参数说明:Tup:包含要堆叠的数组的元组.

a = np.array([1, 2, 3])
b = np.array([2, 3, 4])
np.vstack((a,b))
array([[1, 2, 3],
[2, 3, 4]])

hstack(tup) 功能: 按列顺序堆叠数组
参数说明:Tup:包含要堆叠的数组的元组.

a = np.array([[1],[2],[3]])
b = np.array([[2],[3],[4]])
np.hstack((a,b))
array([[1, 2],
[2, 3],
[3, 4]]

矩阵乘法和加法

矩阵类型，在满足乘法规则的条件下可以直接相乘：
a=np.mat([[1,2,3],[4,5,6],[7,8,9]])
b=np.mat([[5,3,1],[1,6,2],[0,3,4]])
a*b #注意a和b都是matrix类型，可以直接相乘，如果有一个是array则不能直接使用乘号
matrix([[ 7, 24, 17],[25, 60, 38],[43, 96, 59]])

如果是使用数组代替矩阵进行运算则不可以直接使用乘号，应使用dot()函数。dot函数用于矩阵乘法，对于二维数组，它计算的是矩阵乘积，对于一维数组，它计算的是内积。
C = np.array([[1, 2, 3], [3, 4, 5], [6, 7, 8]])
D = np.array([[5, 4, 2], [1, 7, 9], [0, 4, 5]])
np.dot(C, D)
array([[ 7, 30, 35],[ 19, 60, 67],[ 37, 105, 115]])

矩阵的迹

方阵的迹就是主对角元素之和，使用trace()函数获得方阵的迹：
A = np.array([[1, 2, 3], [3, 4, 5], [6, 7, 8]])
B = np.array([[5, 4, 2], [1, 7, 9], [0, 4, 5]])
np.trace(A) # 13
np.trace(A+B) # 30
np.trace(A)+np.trace(B) # 30

diag(v, k=0)
功能:获取k对角上的数据.
k: 默认为0,表示主对角线,>0 上对角中的对角线
V: 矩阵,如果是个2维矩阵返回矩阵对角线元素组成的一维数组,如果为1维数组,返回以v中数据做对角线元素的二维数组
x = np.arange(9).reshape((3,3))
x
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])

计算行列式

numpy.linalg.det(a)
功能:计算数组a的行列式,请注意a 必须是个NxN 数组
A = np.array([[1, 2, 3], [3, 4, 5], [6, 7, 8]])
numpy.linalg.det(A)
1.1102230246251625e-15

线性方程组求解

numpy.linalg.solve(a,b)
a:系数矩阵(方阵).
b:常数项向量
x + 2y + z = 7
2x - y + 3z = 7
3x + y + 2z =18

A = np.array([[1, 2, 1], [2, -1, 3], [3, 1, 2]])
B = np.array([7, 7, 18])
x = np.linalg.solve(A, B)
x
array([ 7., 1., -2.])

概率与统计学相关

平均值(mean)：np.mean()
mean(a, axis=None, dtype=None, out=None,
keepdims=<class ‘numpy.globals.NoValue’>)

   a.mean()==a.sum()/a.size

方差(variance)： np.var
在数学中方差用来度量变量和其数学期望值（即均值）之间的偏离程度,是每个样本值与全体样本值的平均数之差的平方值的平均数.

var(a,axis=None,dtype=None, out=None, ddof=0, keepdims=<class ‘numpy.globals.NoValue’>))
主要参数:ddof: 计算过程中使用 N-ddof作为除数,N 表示元素数量,缺省ddof为零,表示除数为N,统计学中往往采用 ddof =1,使得除数为 N-1;
a = np.array([1,2,3,4])
np.var(a,ddof=1) #统计学中计算方差的方式
1.6666666666666667
np.var(a) #数学中计算方差的方式
1.25

标准差：np.std()
std(a, axis=None, dtype=None, out=None, ddof=0, keepdims=<class ‘numpy._globals._NoValue’>)
a.std()==a.var()**(1/2)

中位数：np.median(),排序后顺序在中间的数,若数组长度为偶数,则为中间两位偶数的平均值
a=np.random.randint(10,100,100)
b=np.sort(a)
fi=(a.size-1)/2
b1=int(np.floor(fi))
b2=int(np.ceil(fi))
b1,b2,(b[b1]+b[b2])/2
分位数：所有数值由小到大排列并分成n等份，处于n-1个分割点位置的数值就是n分位数

**协方差:**cov(m, y=None, rowvar=True, bias=False, ddof=None, fweights=None, aweights=None)
返回值:协方差矩阵(对称阵),对角线元素是每个维度的方差，非对角线上的元素则是不同维度间的协方差
主要参数Ⓜ️包含多个变量和观察值的1维或2维数组。 每行代表一个变量或观察值取决于rowvar参数。
y: 一组额外的变量和观察值.和x具有一样形状大小
Rowvar:如果rowvar为True（默认值），则每行表示一个变量，并在列中有观察值。 否则，该关系将被转置

随机数的产生

import numpy.random as npr
随机选择:
npr .choice(a, size=None, replace=True, p=None)
功能:从给定的一维阵列生成一个随机样本
主要参数说明:
a:如果一个一维数组，随机样本是从其元素生成的。如果是一个int，随机样本的生成是np.arange（a）
size:输出样本的个数
返回值;单个样本(size默认),或size样本组成的一维ndarray对象
np.random.choice(5, 3)
array([0, 3, 4])

import numpy.random as npr
随机整数数组:
npr.randint(low, high=None, size=None, dtype=‘l’)
功能:从[low, high) 返回随机整数,如果high缺省,则结果来自[0,low)
主要参数说明:
size:整数或表示输出样本数组的shape,
dtype:默认为(‘np.int’)
返回值:包含size个元素的ndarray类对象
In: np.random.randint(5, size=(2, 4))
Out: array([[4, 0, 2, 1],
[3, 2, 2, 0]])

import numpy.random as npr
随机数数组:
rand(d0, d1, …, dn)
功能:创建一个给定形状的数组，然后用[0，1)上均匀分布随机样本填充它。
参数说明:
d0,d1,… dn:生成数组的shape,全部缺省,返回一个float单样本
返回值:参数全部缺省返回一个float单样本,否则返回shape为(d0,d1…dn)的ndarray类对象.
In: np.random.rand(3,2)
Out: array([[ 0.14022471, 0.96360618], #random
[ 0.37601032, 0.25528411], #random
[ 0.49313049, 0.94909878]]) #random