Python3数据分析入门实战_01 写在开头 +Numpy 入门

Python3数据科学入门与实战

写在开头，关于Python，我所了解的只是基础语法和一些简单类库的使用，此次开篇教程学习目的是为了去了解关于数据分析、相关类库的学习使用。

多说一句，关于使用Python进行数据分析是不是需要对Python编程语法非常精通的问题。我想说：精通Python语法编程固然是好事，但是刚需是使用它做数据分析，而数据分析只需要对相关数据分析库上手学习即可，像Numpy、Pandas等这些库。我也知道Python可以做Web开发，轻量级的Flask、Django框架也很好用。但是现状是做数据分析，所以对Python高级编程技巧、语法底层研究等操作大可不必，基础语法上手就好，剩下的就是去主要学习这些数据分析库的灵活使用了。

Anaconda： 数据科学平台(Platform)

• conda：Package和Environment管理
  • Environment管理：
    • 创建env：conda create --name envname python=3.4
    • 激活env：(source) activate envname
    • 退出env：(source) deactivate envname
    • 删除env：conda remove --name envname --all
  • Package管理：
    • 安装package：conda install numpy
    • 查看环境中已安装package：conda list -n envname
    • 删除package：conda remove -n envname numpy

Jupyter Notebook：数据科学常用IDE

数据科学五个最佳Python库

• Numpy：
  • 矩阵、快速高效、矢量数学运算
  • 高效索引Index，不需要循环
  • 开源跨平台
• Scipy：
  • 依赖于Numpy
  • 专为科学和工程设计
  • 常用科学计算：线型代数、傅里叶变换、信号图像处理
• Pandas
  • 依赖于Numpy，结构化数据分析利器
  • 高级数据结构：Time-Series、DataFrame、Panel
  • 强大的数据索引和处理能力
• Matplotlib
  • Python 2D绘图领域使用最广泛的套件
  • 通过mplot3d可以绘制3D图
• Scikit-learn
  • 机器学习Python模块，建立在Scipy之上
  • 提供常用机器学习算法：聚类、回归
  • 简单易学的API接口
  • TensorFlow：机器学习框架，Google 开源

Numpy

• 关于矩阵：
  • 矩形的数组，即二维数组
  • 向量：指的是1xN、Nx1的矩阵
  • 标量：指的是1x1的矩阵
  • 数组：N维的数组，矩阵的延伸
  • 特殊矩阵：
    • 全0全1矩阵
    • 单位矩阵：NxN阶矩阵，主对角线元素均为1
      • 任何矩阵与单位矩阵做相乘运算，结果均为原矩阵。(类比：任何数乘1均为任何数)
  • 矩阵运算：
    • 加减法：行和列对应元素相加减
    • 乘法：
      • 数组乘法(点乘)：数组乘法(点乘)是对应元素之间做乘法
      • 矩阵乘法：
        • 设A为MxP的矩阵，B为PxN的矩阵，MxN的矩阵C为矩阵A、B的乘积，记为C=AB。
          
• Numpy入门

  • 数组创建和访问

    import numpy as np
    # create from list
    list_1 = [1, 2, 3, 4]
    list_2 = [5, 6, 7, 8]
    # 通过列表创建数组
    array_1 = np.array(list_1) // array([1, 2, 3, 4])
    array_2 = np.array([list_1, list_2]) // array([[1, 2, 3, 4], [5, 6, 7, 8])
    # 返回数组的shape
    array_2.shape // (2, 4) 两行四列数组
    # 返回数组大小
    array_2.size // 8   元素大小为8
    # 返回数组元素数据类型
    array_2.dtype // dtype('int32') 
    # 数组元素数据类型不一致时，返回数据元素类型中精确度最高的数据类型
    array_3 = np.array([[1.0, 2, 3], [4.0, 5, 6]])
    array_3.dtype // dtype('float64')
    # 通过arange进行数组创建
    array_4 = np.arange(1, 10, 2) // 添加步长为2  array([1, 3, 5, 7, 9])
    # 创建一维全0矩阵
    np.zeros(5) // array([0., 0., 0., 0., 0.])
    # 创建2x3 全0矩阵
    np.zeros([2, 3]) // array([[0., 0., 0.], [0., 0., 0.]])
    # 创建2x2单位矩阵 主对角线为1 其他元素为0
    np.eye(2) // array([[1., 0.], [0., 1.]])
    # 访问元素
    a = np.arange(1, 10) // array([1, 2, 3, 4, 5, 6, 7, 8, 9])
    # 索引访问
    a[0] // 1
    # 子数组访问
    a[1:5] // array([2, 3, 4, 5])
    # 二维数组元素访问
    b = np.array([[1, 2, 3], [4, 5, 6]]) // array([[1, 2, 3], [4, 5, 6]])
    # 索引访问
    b[1][0] // 4 (b[1, 0]也可以访问到)
    # 切片操作
    c = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
    # 行：0-2行(不含2), 列：1列开始
    c[:2, 1:] //  array([[2, 3], [5, 6]])
    

  • 快速创建数组

    # randn 创建长度为10的一维数组，且数组元素满足正态分布
    np.random.randn(10)
    -------------------------------
    array([-0.33449844, -0.1490416 , -0.27399399,  1.0561671 , -0.40881947,
    -1.14842854, -0.57158135, -0.02221695,  0.11761491,  0.61686979])
    -------------------------------
    # randint 返回元素限制10以内，大小为2x3的矩阵
    np.random.randint(10, size=(2, 3))
    -------------------------------
    array([[0, 6, 4],
    [5, 0, 8]])
    -------------------------------
    # 生成长度为10的数组，也可以变换为多维数组 reshape() 方法
    np.random.randint(10, size=(10)) // array([3, 5, 2, 3, 0, 2, 5, 1, 8, 2])
    # 变换为多维数组 reshape() 方法
    np.random.randint(10, size=(10)).reshape(2, 5)
    -------------------------------
    array([[8, 4, 3, 1, 0],
    [8, 6, 2, 2, 2]])
    -------------------------------
    

  • 数组运算

    • 初始化数组

      a = np.random.randint(10, size=(20)).reshape(4, 5)
      -----------------------------
      array([[4, 6, 9, 6, 4],
      [7, 0, 7, 1, 5],
      [5, 7, 5, 5, 4],
      [9, 1, 7, 3, 2]])
      -----------------------------
      b = np.random.randint(10, size=(20)).reshape(4, 5)
      -----------------------------
      array([[5, 3, 6, 9, 1],
      [2, 1, 9, 2, 0],
      [8, 2, 5, 7, 9],
      [9, 4, 0, 9, 7]])
      -----------------------------
      

    • a + b

      array([[ 9,  9, 15, 15,  5],
      [ 9,  1, 16,  3,  5],
      [13,  9, 10, 12, 13],
      [18,  5,  7, 12,  9]])
      

    • a - b

      array([[-1,  3,  3, -3,  3],
      [ 5, -1, -2, -1,  5],
      [-3,  5,  0, -2, -5],
      [ 0, -3,  7, -6, -5]])
      

    • a * b

      array([[20, 18, 54, 54,  4],
      [14,  0, 63,  2,  0],
      [40, 14, 25, 35, 36],
      [81,  4,  0, 27, 14]])
      

    • a / b ：由于数组b 中存在元素0。因此，对上述结果做了INF处理，并报出警告。

      RuntimeWarning: divide by zero encountered in true_divide

      array([[0.8 , 2. , 1.5 , 0.66666667, 4. ],
      [3.5  , 0.  , 0.77777778, 0.5 , inf],
      [0.625 , 3.5 , 1. , 0.71428571, 0.44444444],
      [1.   , 0.25 , inf, 0.33333333, 0.28571429]])
      

  • 快速创建矩阵

    • mat() 进行矩阵创建

      np.mat([[1, 2, 3], [4, 5, 6]])
      -----------------------------
      matrix([[1, 2, 3],
      [4, 5, 6]])
      -----------------------------
      

    • 数组向矩阵转换

      np.mat(a)
      -----------------------------
      matrix([[4, 6, 9, 6, 4],
      [7, 0, 7, 1, 5],
      [5, 7, 5, 5, 4],
      [9, 1, 7, 3, 2]])
      -----------------------------
      

  • 矩阵运算

    • 初始化矩阵

      A = np.mat(a)
      -----------------------------
      matrix([[4, 6, 9, 6, 4],
      [7, 0, 7, 1, 5],
      [5, 7, 5, 5, 4],
      [9, 1, 7, 3, 2]])
      -----------------------------
      B = np.mat(b)
      -----------------------------
      matrix([[5, 3, 6, 9, 1],
      [2, 1, 9, 2, 0],
      [8, 2, 5, 7, 9],
      [9, 4, 0, 9, 7]])
      -----------------------------
      

    • A + B

      matrix([[ 9,  9, 15, 15,  5],
      [ 9,  1, 16,  3,  5],
      [13,  9, 10, 12, 13],
      [18,  5,  7, 12,  9]])
      

    • A - B

      matrix([[-1,  3,  3, -3,  3],
      [ 5, -1, -2, -1,  5],
      [-3,  5,  0, -2, -5],
      [ 0, -3,  7, -6, -5]])
      

    • A * B ：矩阵乘法(满足：mp – pn 相乘为 m*n矩阵)

      AA = np.mat(np.random.randint(10, size=(20)).reshape(4, 5))
      -----------------------------------------------------------
      matrix([[1, 4, 3, 6, 5],
      [7, 6, 4, 9, 0],
      [4, 4, 2, 1, 8],
      [0, 1, 6, 6, 2]])
      -----------------------------------------------------------
      BB = np.mat(np.random.randint(10, size=(20)).reshape(5, 4))
      -----------------------------------------------------------
      matrix([[6, 8, 2, 2],
      [0, 7, 4, 8],
      [7, 1, 6, 5],
      [9, 9, 6, 3],
      [2, 4, 8, 9]])
      -----------------------------------------------------------
      

    • AA * BB

      matrix([[ 91, 113, 112, 112],
      [151, 183, 116, 109],
      [ 63, 103, 106, 125],
      [100,  75,  92,  74]])
      

  • 数组常用函数

    • 数组初始化

      a = np.random.randint(10, size=(20)).reshape(4, 5)
      --------------------------------------------------
      array([[2, 2, 1, 2, 4],
      [9, 0, 7, 9, 8],
      [6, 7, 6, 8, 6],
      [2, 8, 1, 4, 8]])
      --------------------------------------------------
      

    • 元素去重保留唯一值

      np.unique(a)
      --------------------------------------------------
      array([0, 1, 2, 4, 6, 7, 8, 9])
      --------------------------------------------------
      

    • 数组求和(以列为单位)

      sum(a)
      --------------------------------------------------
      array([19, 17, 15, 23, 26])
      --------------------------------------------------
      

    • 具体行的和

      sum(a[0])
      --------------------------------------------------
      11
      --------------------------------------------------
      

    • 具体列的和

      sum(a[:,0])
      --------------------------------------------------
      19
      --------------------------------------------------
      

    • 最值

      a.max() # 数组最值
      max(a[0]) # 具体行最值
      ...
      

  • 数组的input和output

    • Python的pickle模块实现了基本的数据序列和反序列化。

    • 通过pickle模块的序列化操作能够将程序中运行的对象信息保存到文件中去，永久存储。

    • 通过pickle模块的反序列化操作，能够从文件中创建上一次程序保存的对象。

    • 基本接口：

      • pickle.dump(obj, file, [,protocol]) 将对象obj保存到文件file中去。
      • pickle.load(file) 从file中读取一个字符串，并将它重构为原来的Python对象。

    • 举个栗子：

      • 导入需要的库

        import pickle
        import numpy as np
        

      • 数组初始化

        x = np.arange(10)
        ----------------------
        array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
        ----------------------
        

      • 输出文件

        # 创建文件对象，文件名为：x.pkl，读写方式为：只写
        f = open('x.pkl', 'wb')
        # 将数组对象保存到文件对象中
        pickle.dump(x, f)
        # 查看文件, Linux、Mac系统下命令为 !ls
        !dir
        

      • 输入文件

        # 创建文件对象，文件名为：x.pkl，读写方式为：只读
        f = open('x.pkl', 'rb')
        # 从文件对象中读取字符串，并将其转换为数组对象
        pickle.load(f)
        

      • Numpy 中的 save 方法

        # 将数组对象保存成文件，后缀名为 .npy
        np.save('one_array', x)
        

      • Numpy 中的 load 方法

        # 读取文件
        np.load('one_array.npy')
        

      • Numpy 中的 savez 方法：压缩文件

        # 初始化数组y
        y = np.arange(20)
        ----------------------------------
        array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 
        15, 16,17, 18, 19])
        ----------------------------------
        # 压缩文件
        np.savez('two_array.npz', a=x,b=y)
        # 读取压缩文件
        np.load('two_array.npz')
        # 按索引读取数组内容
        c['a']
        ----------------------------------
        array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
        ----------------------------------
        c['b']
        ----------------------------------
        array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 
        15, 16,17, 18, 19])
        ----------------------------------