NumPy模块：：
  这是一个用于科学计算的基础模块，不但能够完成科学计算任务而且能够用作高效的多维数据容器，可用于存储和处理大型矩阵
  python自身的array模块有其局限性，它不支持多维，也没有各种运算函数，不适合做数值运算
  NumPy弥补了这些不足，它提供了一种存储单一数据类型的多维数组--ndarray

  具体用法和相关方法：
  import numpy as np
  arr1=np.array([1,2,3,4]) #创建一维数组
  arr2=np.array([[1,2],[3,4]]) #创建二维数组
  相关属性：
    shape:表示数组的尺寸，如n行m列的数组，就会返回(n,m)的元组 
    如 arr2.shape 返回的就是(2,2),表明这是一个两行两列的数组
    还可以重新设置数组的尺寸 如 arr2.shape=1,4 这样arr2就变成了一个1行4列的数组了，数组元素的顺序没有变

    reshape:和shape一样，都是用来改变数组形状，但和shape不同的是，reshape改变的不是数组本身，而是相当于新建了一个对象
    如 arr是一个一维数组 arr.reshape(3,4) 输出的是一个三行四列数组，但arr本身仍旧是一个一维数组，reshape用于赋值
       而shape是直接改变了数组形状 arr.shape=3,4 那么arr本身就会从一维数组变为一个三行四列数组
    
    ndim:表示数组的维数
    如 arr2.ndim 返回就是2

    dtype:表示数组中元素的类型
    如 arr2.dtype 返回的是int32

    size:表示数组的元素总数
    如 arr2.size 返回的是4，总共的元素个数

  arange函数,类似于python自带的range，通过指定开始值，终值和步长来创建一维数组，创建的数组不含终值
    如 np.arange(1,4,2) 生成的数组就是 [1,3]
    这里既然说到了range就有必要说下，在python2版本中，用range函数就是生成的一个数组如上面的例子[1,3]
    但是在python3版本中，range就是一个迭代器，它并不会在内存中真正产生一个列表对象，这样也是为了节约内存空间
    range() 函数返回的是一个可迭代对象（类型是对象），而不是列表类型 如果你要将它确实打印出来就可以用list(range(x,x,x))
    将迭代对象转化为一个列表

  linspace函数，通过指定开始值，终值和元素个数来创建一维数组，默认设置包括终值，这点需要和arange区分开
    如 np.linspace(0,10,6) 生成的就是[0., 2., 4., 6., 8., 10.,]

  logspace函数，和上面的linspace类似，创建的等比数列
    如 np.logspace(0,2,4) 生成的就是 10^0(1)到10^2(100) 即1-100的4个元素的等比数列

  zeros函数，创建的数组值全部填充为0
    如 np.zeros( (1,3) ) 生成一个1行3列 值全为0的数组 [0,0,0]

  eye函数，用来生成主对角线上的元素为1，其余为0的数组
    如 np.eye(3),生成的数组就是
     [1,0,0]
     [0,1,0]
     [0,0,1]

  diag函数，和eye函数的区别在于，对角线上元素可以是0或其他值
    如 np.diag([1,2,3]),生成的就是
     [1,0,0]
     [0,2,0]
     [0,0,3]

  ones函数，和zeros函数类似，区别在于，填充值全为1
    如 np.ones( (2,2) )  生成的是[[1,1][1,1]]

  因为一般来说同一数组中的元素都是相同的数据类型，所以当需要用到由不同数据类型组成的数组时，可以自己去创建需要的数据类型
    如 df=np.dtype([("name",np.str_,40),("numitems",np.int64),("price",np.float64)])
    这个df就是我们创建的数据类型了，数组中的三个元素分别是字符串型，整数型和浮点数型
    然后，我们在创建数组的时候，指定下数据类型，就能生成出我们需要的数组了
    itemz=np.array([("tomatoes",42,4.14)],dtype=df)



  数组的索引和操作：
    简单的切片就不多说了，这里就说下切片的高级玩法
    切片赋值，切片可以直接赋值
    如：arr[2:4]=9,10  就是将数组的第三，第四个元素赋值为9和10
    
    切片步长取值
    如: arr[1:-1:2] 从数组的第一个元素开始到最后一个元素为止，不包含最后一个元素，每隔一个元素取一个元素
        [1,2,3,4] 来举例的话那么，最后生成的数组就是[1,3]
    
    切片倒序，可以通过切片将数组元素倒过来
    如： arr[-1,5]这种用法是错误的，最后生成的是一个空数组，要加上步长才行
         正确用法是arr[-1,5,-1],步长一定要是负数才行，用这种方法就能很轻松地得到数组的倒序

    多维数组的切片操作：
    如： 现在有这样一个多维数组
        [1,2,3]
        [4,5,6]
        [7,8,9]

        arr[0,1:] 生成的数组就是 第0行中的第一个元素开始，到最后一个元素 即[2,3]
        也就是说如果是多维数组的话，那么里面的第一个参数指的是第几行的数组，第二个切片参数针对的是改行的数组
        
        arr[1:,1:] 就是说对第1行，第2行的数组进行操作，取这两行数组的第1第2个元素
        生成的结果就是[5,6][8,9]

        arr[:,2] 这个就是说取所有行的第2列元素，可以直接理解为索引第二列元素
        生成的结果是[3,6,9]

        arr[1,1] 取第1行第1列的元素，即5

        arr[1:,(0,2)] 取第1行第2行的第0和第2个元素，生成的结果应该是[4,6],[7,9]

        arr[(0,2),2] 取第0行和第2行的第2列，生成的结果应该是[3,9]            

        arr[(0,2),(0,2)] 取第0行的第0列 取第2行的第2列 生成的结果是[1,9]

        arr[::2,::2] 取第0行和第2行的第0和第2列，生成的结果是[1,3][7,9]
      
  数组形态变换：
    shape和reshape上面已经提到过了，都是用来改变数组的形状。

    ravel: 展平数组(降维)，将多维数组展开为一维数组
    如 arr=np.array([[1,2],[3,4]]) arr是一个二维的2行2列数组，经ravel降维 arr.ravel() 展开后的结果为[1,2,3,4]

    flatten：和ravel函数一样可以将数组降维展开，区别在于，flatten函数可以选择横向或纵向展开
    如 上面的arr这个二维数组，用flatten横向展开 arr.flatten()得到的结果是[1,2,3,4]
       而用纵向展开 arr.flatten('F') 得到的结果就是[1,3,2,4]

    hstack：将数组横向组合
    如 arr1=np.array([[1,2],[3,4]]) arr2=np.array([[5,6],[7,8]]) 将两个数组作为一个元组参数 hstack((arr1,arr2))
       hstack将两个数组进行再组合  再组合的结果是 [[1,2,5,6],[3,4,7,8]]  

    vstack: 将数组纵向组合
    如 上面的arr1,arr2 经vstack再组合后 vstack((arr1,arr2))生成的结果是[[1,2],[3,4],[5,6],[7,8]]

    concatenate: 根据参数axis的不同，axis=1时横向组合，axis=0时纵向组合
    如 np.concatenate((arr1,arr2),axis=1) 横向组合后的结果就是[[1,2,5,6],[3,4,7,8]]
       np.concatename((arr1,arr2),axis=0) 纵向组合后的结果就是[[1,2],[3,4],[5,6],[7,8]]

    
    hsplit：横向分割数组
    如 arr=np.array([[1,2,3,4],[5,6,7,8]])  arr1,arr2=np.hsplit(arr,2) 用hsplit横向切割
       横向切割的结果是 arr1=[[1,2],[5,6]]  arr2=[[3,4],[7,8]]

    vsplit: 纵向分割数组
    如 上面的arr，以vsplit进行切割 arr1,arr2=np.vsplit(arr,1)
       纵向切割的结果是 arr1=[[1,2,3,4]] arr2=[[5,6,7,8]]

    split :根据axis的不同，axis=1时横向切割，axis=0时纵向切割
    如 np.split(arr,2,axis=1) 和上面的hsplit效果是相同的 np.split(arr,2,axis=0)则和上面的vsplit效果是相同的

    
  矩阵和相关函数
    在numpy中，矩阵是ndarray的子类，数组和矩阵是有着重要的区别的。
    矩阵是继承自numpy数组对象的二维数组对象。

    mat: 用来创建矩阵   如 matr1=np.mat("1 2 3;4 5 6;7 8 9") 一定要用分号分隔 生成的矩阵 [[1 2 3][4 5 6][7 8 9]]
    matrix：和mat一样用来创建矩阵 如 matr2=np.matrix([[1,2,3],[4,5,6],[7,8,9]]) 生成的矩阵与上面相同

    bmat:通过聚合数组来创建矩阵 
    如 arr1=[[1,2],[5,6]]  arr2=[[3,4],[7,8]]  np.bmat("arr1 arr2") 生成的矩阵 [[1 2 3 4][5 6 7 8]]
    np.bmat("arr1;arr2") 生成矩阵 [[1,2][5,6][3,4][7,8]]

    矩阵可以直接进行加减乘除，矩阵计算是直接针对矩阵中的每个元素进行的，
    如 matr1*3 ，生成的结果就是[[3 6 9][12 15 18][21 24 27]]
       matr1-1,生成的结果是[[0 1 2][3 4 5][6 7 8]]
       matr1*matr2 ，生成的结果是[[30 36 42][66 81 96][102 126 150]]
    
    multiply: 矩阵对应元素相乘 ,np.multiply(matr1,matr2),生成的结果是[[1 4 9][16 25 36][49 64 81]]

    相关属性(矩阵，数组通用)：
      T：返回自身的转置 ，如matr1.T 转置结果为[[1 4 7][2 5 8][3 6 9]]
      H: 返回自身的共轭转置，如 matr1.H 其转置结果是其自身(实数的共轭就是其本身)
         但比如现在有matr3=[[-1 -2 -3][-4 -5 -6]],那么matr3.H 的结果就是 [[-1 -4][-2 -5][-3 -6]]
      I: 返回自身的逆矩阵，这个暂时就不举例了
      A：返回自身数据的二维数组的一个视图 

   ufunc函数：全称通用函数，是一种能够对数组中的所有元素进行操作的函数，常用的ufunc函数运算有四则运算，比较运算和逻辑运算等
     如上面的加减乘除就算是ufunc四则运算的范畴，数组的运算和矩阵的运算，唯一的差别就在乘法
     数组的乘法和上面的multiply运算结果相同，是对应元素之间的相乘

     比较运算,数组与矩阵运算结果相同。以上面的arr1=[[1,2],[5,6]]  arr2=[[3,4],[7,8]]为例
     arr1<arr2生成的结果是 [[True,True],[True,True]] 都是数组中单个元素之间的比较结果

     ufunc函数的广播机制，是指不同形状之间执行算数运算的方式。两个数组之间的计算的前提是它们的shape一致，若是两个数组的shape
     不一致，就会按广播机制进行计算
     如 现在 arr1=[[0,0,0],[1,1,1],[2,2,2],[3,3,3]]  arr2=[1,2,3]
        那么当arr1+arr2时，由于两者shape不一致，所以就会按广播机制进行计算，最后结果就是
        [[1 2 3][2 3 4][3 4 5][4 5 6]]
        也就是说不足的地方自动补齐，相当于是
        [[0,0,0],[1,1,1],[2,2,2],[3,3,3]]+[[1,2,3],[1,2,3],[1,2,3],[1,2,3]]
        
  用numpy读写保存数组文件:
    np.save(file,arr) file为要保存的文件的名称，需要指定文件保存的路径，如果未设置，则保存到默认路径下面，文件扩张名是.npy
    如 np.save("../tmp/save_arr"，arr)
    将多个数组保存到一个文件中，可以用savez函数，其文件扩展名为npz
    如 np.savez("../tmp/save_arrz",arr1,arr2)

    读取文件获得数组 loaded_date=np.load("../tmp/save_arr.npy")
    load_date=np.load("../tmp/save_arrz.npz") 假设里面包含两个数组，那么数组1为load_date['arr_0'] 数组2为load_date['arr_1']

    实际的数据分析任务中，可能更多的是使用文本格式的数据，比如txt或csv格式，因此会用到savetxt,loadtxt函数
    savetxt: np.savetxt(file,arr,fmt="%d",delimiter=',',newline='\n',header='',footer='',comments='# ')
    第三个参数表示保存为整数，第四个参数为数据分隔符，一般只需要用到前4个参数
    如 np.savetxt('../tmp/arr.txt',arr,fmt="%d",delimiter=",")
       np.loadtxt('../tmp/arr.txt',delimiter=",")  读入的时候也需要指定分隔符
    genformtxt: 和loadtxt函数相似，只不过它面向的结构化数组和缺失数据
    如 np.genfromtxt('../tmp/arr.txt',delimiter=","),因为names参数默认第一行为数据的列名，所以数据从第二行开始


  生成随机数组：
      np.random.seed(42) #设置随机种子
      arr=np.random.randint(1,10,size=10) #生成一个一维数组
      arr=np.random.randint(1,10,size=(3,3)) #生成3行3列的随机数组

      sort()：数组排序，默认不填参数的话，按横向排序，如 arr.sort() 
      需要时，可以指定axis参数，使其可以按指定轴对数据进行排序
      arr.sort(axis=1) 按横向排序 ，arr.sort(axis=0) 按纵向排序

  数组去重:
    unique函数：排除数组中重复的数据，找出唯一值，并进行排序后返回结果
    如 arr=[5,5,4,8,1,3,3,5,2,1,9] 进行去重 np.unique(arr) 后返回的结果就是 [1,2,3,4,5,8,9]
    这个函数功能相当于 python 自带的set()函数，set(arr)的效果是相同的

  数组数据重复：
    用numpy生成的数组如果要实现数组数据的重复需要额外的函数，但python自身的数组，可以直接乘以需要重复的遍数就可以了
    如 arr=[1,2,3]  arr*3=[1,2,3,1,2,3,1,2,3]
    而numpy生成的数组若相乘，则代表数组内的各个元素乘以该乘数，因此需要额外的函数来实现

    tile函数：实现数组数据的重复 ，如np.tile(arr,3) 第二个参数代表的是数组重复的次数

    repeat函数：np.repeat(arr,repeats,axis=none) 第二个参数代表的是数组重复的次数，第三个参数代表的是按横向还是纵向重复； 
    如 arr=[[4 5 6][4 2 5][5 1 2]]  有两种写法，但效果是相同的 arr.repeat(2,axis=0)  np.repeat(arr,2,axis=0)
      生成的数组是[[4 5 6][4 5 6][4 2 5][4 2 5][5 1 2][5 1 2]]
      若是要纵向重复则 arr.repeat(2,axis=1) 生成的数组是[[4 4 5 5 6 6][4 4 2 2 5 5][5 5 1 1 2 2]]

  统计函数：
    所有的统计函数在针对二维数组计算的时候都需要注意轴的概念，当axis为0时，横向生成纵向计算 当axis为1时，纵向生成横向计算
    但在axis参数不在，默认时，函数不按照任一轴向计算，而是计算一个总值
    sum 和计算：
      如 arr=[[4 5 6][4 2 5][5 1 2]] np.sum(arr) 生成的结果是 34  arr.sum(axis=0)生成的结果是 [13 8 13]
         arr.sum(axis=1)生成的结果是 [15 11 8]
    mean 计算数组平均值:
      如 np.mean(arr) 生成的结果是 3.77  arr.mean(axis=0) 生成的结果是 [4.3 2.7 4.3] arr.mean(axis=1) 生成的结果是 [5 3.7 2.7]
    std 计算数组标准差 ：np.std(arr)
    var 计算数组方差: np.var(arr)
    min 计算数组最小值: np.min(arr)
    max 计算数组最大值： np.max(arr)
    
    cumsum 计算所有元素的累计和 arr=[2 3 4] np.cumsum(arr) 生成的结果是 [2 5 9]
    cumprod 计算所有元素的累计积 np.cumprod(arr) 生成的结果是 [2 6 24]



Matplotlib 数据可视化
  import matplotlib.pyplot as plt
  绘图常用函数：
    plt.tile 在当前图形中添加标题
    plt.xlabel 在当前图形中添加x轴名称
    plt.ylabel 在当前图形中添加y轴名称
    plt.xlim  指定当前图形x轴的范围，只能确定一个数值区间
    plt.ylim 指定当前图形y轴的范围，只能确定一个数值区间
    plt.xticks 指定x轴刻度的数目与取值
    plt.yticks 指定y轴刻度的数目与取值
    plt.savefig 保存绘制的图形
    plt.show 在本机显示图形
    plt.plot(arr) 根据数组数据绘制线表 plt.plot(arr,arr**2) 第二个参数可以填写表达式
    plt.scatter(arr[0],arr[1],marker='o',c='red') 第一个参数表示x轴对应的数据，第二个参数表示y轴对应的数据 
    plt.plot(x,y,linestyle='--')  折线图
    plt.plot(x,y,linestyle='--',marker='o') 点线图
    plt.plot(x,y,'b--') 颜色和线条样式可以放在一个参数里
  直方图:
    plt.bar(xarr,yarr,width=0.1,align="center") xarr代表的是x轴上的数据 ,yarr代表的是y轴上的数据，width代表的是方柱的宽度
    需要注意的是如果想要在一张图中表示多个不同的直方图，就需要在x轴的数据上加上方柱的宽度
    比如，现在要表示三根方柱，这时第一根方柱不变 plt.bar(xarr,yarr,width=0.1)
    第二根方柱就需要加上方柱宽度了 plt.bar(xarr+0.1,yarr,width=0.1) 要注意的是 xarr必须是np.array对象，直接用python自带数组
    的话，在pyhon3中数组是一个迭代对象，数组是无法直接加减的，只有np.array生成的对象才能直接像上面这样加减，加上的必须是方柱的宽，
    也就是说在x轴上的标点横移了0.1，正好是方柱的宽度，这样就不会和第一根方柱重叠了，当然，需要和第一根方柱隔开一点距离的话，那就
    再多加一点
    第三根方柱就是plt.bar(xarr+0.2,yarr,width=0.1) 因为要避开第一第二方柱，所以需要在第二方柱的基础上再加上0.1

    #在方柱上方显示数值
    def autolabel(rects):
        # attach some text labels
        for rect in rects:
            height = rect.get_height()
            plt.text(rect.get_x() + rect.get_width()/2., 1.01*height,
                    '%d' % int(height),
                    ha='center', va='bottom')    
  饼图:
    plt.pie(arr,explode=None,labels=None,autopct=None) 一般只要定下这四个值就可以了
    arr是各项的总值数组，explode表示指定项距离饼图圆心为n个距离，labels指定每一项的距离 ，这三个参数需要的都是数组
    autopct 指定数值的显示方式，比如是整数还是浮点数
    比如，label=['eq1','eq2','eq3','eq4','基準客数']sum_arr=[83.8,80,81.8,99.2,116.6]explode=[0.01,0.01,0.01,0.01,0.01]
      plt.pie(sum_arr,explode=explode,labels=label,autopct='%1.1f%%')
    另一个需要注意的点是绘制饼图的时候一定要重新设置画布，因为默认的画布不是正方形，所以绘制的拼图会有些变形
    plt.figure(figsize=(6,6)) 像这样讲画布设定为一个正方形就不存在变形的问题了

  箱线图：
    它能提供有关数据位置和分散情况的关键信息，尤其是在比较不同特征的时候，更可表现其分散程度的差异，箱线图里利用数据中的5个统计量
    最小值，最大值，下四分位数，中位数和上四分位数 来描述数据，它可以粗略地看出数据是否具有对称性，分布的分散程度等信息
    分位数根据其将数列等分的形式不同可以分为中位数，四分位数，十分位数、百分位数等等。
    四分位数是将数列等分成四个部分的数，一个数列有三个四分位数，设下分位数、中分位数和上分位数分别为Q1 Q2 Q3
    Q1=(n+1)/4  Q2=(n+1)/2 Q3=3(n+1)/4  arr[Q1] arr[Q2] arr[Q3] 
    （n+1）恰好为4的倍数时，确定四分数较简单，如果（n+1）不为4的整数倍数，按上述分式计算出来的四分位数位置就带有小数，
    这时，有关的四分位数就应该是与该小数相邻的两个整数位置上的标志值的平均数

    plt.boxplot(arr,notch=None,sym=None,vert=None,labels=None,meanline=None)
    arr表示用于绘制箱线图的数据，这里要注意的是，如果你需要绘制几组不同的数据，你需要事先将几组数组合并到一个arr中
    notch 接收boolean 表示箱体是否有缺口，sym接收特定sting,用来指定异常点形状，vert接收boolean,表示图形是纵向还是横向
    labels 接收array 指定每一个箱线图的标签 ，meanline接收boolean 表示是否显示均值线

    例如：hz_arr=(list(arr[1]),list(arr[2]),list(arr[3]),list(arr[4]),list(arr[5])) 事先将数组数据串联成一个元组
         label=['第一周','第二周','第三周','第四周','第五周']
         plt.boxplot(hz_arr,notch=True,labels=label,meanline=True)



    RC参数：
      lines.linewidth 线条宽度，取0-10之间的数值，默认为1.5   plt.rcParams['lines.linewidth']=3
      lines.linestyle 线条样式，可取"-" "--" "-." ":" 4种，默认为"-"  plt.rcParams['lines.linestyle']='-.'
      lines.marker  线条上点的形状 可取"o" "D" "h" "," "."等20种，默认是None
      lines.markersize 点的大小 取0-10之间的数值，默认是1

      设置rc参数显示中文标题
      plt.rcParams['font.sans-serif']='SimHei'  #设置字体为SimHei显示中文
      plt.rcParams['axes.unicode_minus']=False  #设置正常显示符号