1. 程式人生 > >Python3資料分析入門實戰_01 寫在開頭 +Numpy 入門

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])
          ----------------------------------