1. 程式人生 > >python進階之資料分析與展示(二)

python進階之資料分析與展示(二)

資料分析之表示

NumPy庫入門


資料的維度

  • 一維資料

    • 一維資料由對等關係的有序或無序資料構成,採用線性方式組織。
    • 例如:3.1413, 3.1398, 3.1404, 3.1401, 3.1349, 3.1376。
    • 對應列表、陣列和集合等概念。
  • 列表和陣列區別

    • 列表
      • 資料型別可以不同:[3.1413, ‘pi’, 3.1404, [3.1401, 3.1349], ‘3.1376’]。
    • 陣列
      • 資料型別必須相同:[3.1413, 3.1398, 3.1404, 3.1401, 3.1349, 3.1376]。
  • 二維資料

    • 二維資料由多個一維資料構成,是一維資料的組合形式。
    • 表格是典型的二維資料,其中,表頭是二維資料的一部分。
  • 多維資料

    • 多維資料由一維或二維資料在新維度上擴充套件形成。
  • 高維資料

    • 高維資料僅利用最基本的二元關係展示資料間的複雜結構

    • 例如:鍵值對

      {
          "firstname": "Tian",
          "lastname": "Song",
          "address": {
                      "streetAddr": "中關村南大街5號",
                      "city": "北京",
                      "zipcode": "100081"
                     },
          "prof": ["Computer System", "Security"]
      }
      
  • 資料維度的Python表示

    • 資料維度是資料的組織形式。
    • 一維資料:列表和集合型別。
      • 有序:[3.1398, 3.1349, 3.1376]。
      • 無序:{3.1398, 3.1349, 3.1376}。
    • 二維資料:列表型別。
      • [ [3.1398, 3.1349, 3.1376], [3.1413, 3.1404, 3.1401] ]。
    • 多維資料:列表型別。
    • 高維資料:字典型別或資料表示格式JSON、 XML和YAML格式。
      • dict = { “firstname”: “Tian”, “lastname”: “Song”, }

NumPy的陣列物件:ndarray

  • NumPy

    • NumPy是一個開源的Python科學計算基礎庫,包含:
      • 一個強大的N維陣列物件 ndarray。
      • 廣播功能函式。
      • 整合C/C++/Fortran程式碼的工具。
      • 線性代數、傅立葉變換、隨機數生成等功能。
    • NumPy是SciPy、 Pandas等資料處理或科學計算庫的基礎。
  • NumPy的引用

    • 儘管別名可以省略或更改,建議使用約定的別名。
    • 引入模組的別名:import numpy as np。
  • N維陣列物件:ndarray

    • 陣列物件可以去掉元素間運算所需的迴圈,使一維向量更像單個數據。
    • 設定專門的陣列物件,經過優化,可以提升這類應用的運算速度。
    • 科學計算中,一個維度所有資料的型別往往相同。
    • 陣列物件採用相同的資料型別,有助於節省運算和儲存空間。
    • ndarray是一個多維陣列物件,由兩部分構成:
      • 實際的資料。
      • 描述這些資料的元資料(資料維度、資料型別等)。
    • ndarray陣列一般要求所有元素型別相同(同質),陣列下標從0開始。
  • ndarray例項

    In [1]: import numpy as np  # In[], Out[]是IPython提示符。
    
    In [2]: a = np.array([[0, 1, 2, 3, 4], [9, 8, 7, 6, 5]])
    # np.array()生成一個ndarray陣列。
    
    In [3]: a
    Out[3]:
    array([[0, 1, 2, 3, 4],       # np.array()輸出成[]形式,元素由空格分割。
           [9, 8, 7, 6, 5]])
    
    In [4]: print(a)      
    [[0 1 2 3 4]
     [9 8 7 6 5]]
    
  • 軸(axis)是儲存資料的維度,秩(rank)是軸的數量。

  • ndarray物件的屬性

    • .ndim
      • 秩,即軸的數量或維度的數量。
    • .shape
      • ndarray物件的尺度,對於矩陣,n行m列。
    • .size
      • ndarray物件元素的個數,相當於.shape中n*m的值。
    • .dtype
      • ndarray物件的元素型別。
    • .itemsize
      • ndarray物件中每個元素的大小,以位元組為單位。

ndarray陣列的元素型別

  • ndarray的元素型別

    • bool:布林型別,True或False。
    • intc:與C語言中的int型別一致,一般是int32或int64。
    • intp:用於索引的整數,與C語言中ssize_t一致,int32或int64。
    • int8:位元組長度的整數,取值:[‐128, 127]。
    • int16:16位長度的整數,取值: [‐32768, 32767]。
    • int32:32位長度的整數,取值: [ 2 31 , 2 31 1 ‐2^{31}, 2^{31}‐1 ]。
    • int64:64位長度的整數,取值: [ 2 63 , 2 63 1 ‐2^{63}, 2^{63}‐1 ]。
    • uint8:8位無符號整數,取值:[0, 255]。
    • uint16:16位無符號整數,取值:[0, 65535]。
    • uint32:32位無符號整數,取值:[ 0 , 2 32 1 0, 2^{32}‐1 ]。
    • uint64:32位無符號整數,取值:[ 0 , 2 64 1 0, 2^{64}‐1 ]。
    • float16:16位半精度浮點數,取值1位符號位,5位指數,10位尾數。(符號)尾數* 1 0 10^{指數}
    • float32:32位半精度浮點數,取值1位符號位,8位指數,23位尾數。
    • float64:64位半精度浮點數,取值1位符號位,11位指數,52位尾數。
    • complex64:複數型別,實部和虛部都是32位浮點數。
    • complex128:複數型別,實部和虛部都是64位浮點數。實部(.real) + j虛部(.imag)。
  • Python語法僅支援整數、浮點數和複數3種類型。科學計算涉及資料較多,對儲存和效能都有較高要求,對元素型別精細定義,有助於NumPy合理使用儲存空間並優化效能,對元素型別精細定義,有助於程式設計師對程式規模有合理評估。

  • 非同質的ndarray物件

    • ndarray陣列可以由非同質物件構成。
    • 非同質ndarray元素為物件型別。
    • 非同質ndarray物件無法有效發揮NumPy優勢,儘量避免使用。

ndarray陣列的建立

  • 從Python中的列表、元組等型別建立ndarray陣列。
    • x = np.array(list/tuple)。

    • x = np.array(list/tuple, dtype=np.float32)。

    • 當np.array()不指定dtype時,NumPy將根據資料情況關聯一個dtype型別。

      In [1]: import numpy as np
      
      In [2]: x = np.array([0, 1, 2, 3])  # 從列表型別建立
      
      In [3]: print(x)
      [0 1 2 3]
      
      In [4]: x = np.array((4, 5, 6, 7))  # 從元組型別建立
      
      In [5]: print(x)
      [4 5 6 7]
      
      In [6]: x = np.array([[1, 2], [9, 8], (0.1, 0.2)])  # 從列表和元組混合型別建立
      
      In [7]: print(x)
      [[ 1.   2. ]
       [ 9.   8. ]
       [ 0.1  0.2]]
      
  • 使用NumPy中函式建立ndarray陣列,如: arange, ones, zeros等。
    • np.arange(n)
      • 類似range()函式,返回ndarray型別,元素從0到n‐1。
    • np.ones(shape)
      • 根據shape生成一個全1陣列,shape是元組型別。
    • np.zeros(shape)
      • 根據shape生成一個全0陣列,shape是元組型別。
    • np.full(shape, val)
      • 根據shape生成一個數組,每個元素值都是val。
    • np.eye(n)
      • 建立一個正方的n*n單位矩陣,對角線為1,其餘為0。
    • np.ones_like(a)
      • 根據陣列a的形狀生成一個全1陣列。
    • np.zeros_like(a)
      • 根據陣列a的形狀生成一個全0陣列。
    • np.full_like(a, val)
      • 根據陣列a的形狀生成一個數組,每個元素值都是val。
      
      In [1]: import numpy as np
      
      In [2]: np.arange(10)
      Out[2]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
      
      In [3]: np.ones((3, 6))
      Out[3]:
      array([[ 1.,  1.,  1.,  1.,  1.,  1.],
             [ 1.,  1.,  1.,  1.,  1.,  1.],
             [ 1.,  1.,  1.,  1.,  1.,  1.]])
      
      In [4]: np.zeros((3, 6), dtype = np.int32)
      Out[4]:
      array([[0, 0, 0, 0, 0, 0],
             [0, 0, 0, 0, 0, 0],
             [0, 0, 0, 0, 0, 0]])
      
      In [5]: np.eye(5)
      Out[5]:
      array([[ 1.,  0.,  0.,  0.,  0.],
             [ 0.,  1.,  0.,  0.,  0.],
             [ 0.,  0.,  1.,  0.,  0.],
             [ 0.,  0.,  0.,  1.,  0.],
             [ 0.,  0.,  0.,  0.,  1.]])
      
      In [6]: x = np.ones((2, 3, 4))
      
      In [7]: print(x)
      [[[ 1.  1.  1.  1.]
        [ 1.  1.  1.  1.]
        [ 1.  1.  1.  1.]]
      
       [[ 1.  1.  1.  1.]
        [ 1.  1.  1.  1.]
        [ 1.  1.  1.  1.]]]
      
      In [8]: x.shape
      Out[8]: (2, 3, 4)
      
  • 使用NumPy中其他函式建立ndarray陣列
    • np.linspace()
      • 根據起止資料等間距地填充資料,形成陣列。
    • np.concatenate()
      • 將兩個或多個數組合併成一個新的陣列。
      In [1]: import numpy as np
      
      In [2]: a = np.linspace(1, 10, 4)
      
      In [3]: a
      Out[3]: array([  1.,   4.,   7.,  10.])
      
      In [4]: b = np.linspace(1, 10, 4, endpoint = False)
      
      In [5]: b
      Out[5]: array([ 1.  ,  3.25,  5.5 ,  7.75])
      
      In [6]: c = np.concatenate((a, b))
      
      In [7]: c
      Out[7]: array([ 1.  ,  3.25,  5.5 ,  7.75,  1.  ,  3.25,  5.5 ,  7.75])
      

ndarray陣列的變換

  • 對於建立後的ndarray陣列,可以對其進行維度變換和元素型別變換。
  • ndarray陣列的維度變換
    • .reshape(shape)
      • 不改變陣列元素,返回一個shape形狀的陣列,原陣列不變。
    • .resize(shape)
      • 與.reshape()功能一致,但修改原陣列。
    • .swapaxes(ax1, ax2)
      • 將陣列n個維度中兩個維度進行調換。
    • .flatten()
      • 對陣列進行降維,返回摺疊後的一維陣列,原陣列不變。
      In [1]: import numpy as np
      
      In [2]: a = np.ones((2, 3, 4), dtype = np.int32)
      
      In [3]: a
      Out[3]:
      array([[[1, 1, 1, 1],
              [1, 1, 1, 1],
              [1, 1, 1, 1]],
      
             [[1, 1, 1, 1],
              [1, 1, 1, 1],
              [1, 1, 1, 1]]])
      
      In [4]: a.reshape((3, 8))
      Out[4]:
      array([[1, 1, 1, 1, 1, 1, 1, 1],
             [1, 1, 1, 1, 1, 1, 1, 1],
             [1, 1, 1, 1, 1, 1, 1, 1]])
      
      In [5]: a.resize((3, 8))
      
      In [6]: a
      Out[6]:
      array([[1, 1, 1, 1, 1, 1, 1, 1],
             [1, 1, 1, 1, 1, 1, 1, 1],
             [1, 1, 1, 1, 1, 1, 1, 1]])
      
      In [7]: b = a.flatten()
      
      In [8]: b
      Out[8]:
      array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
             1])
      
  • ndarray陣列的型別變換
    • astype()方法一定會建立新的陣列(原始資料的一個拷貝),即使兩個型別一致。

    • new_a = a.astype(new_type)。

      In [1]: import numpy as np
      
      In [2]: a = np.ones((2, 3, 4), dtype = np.int32)
      
      In [3]: a
      Out[3]:
      array([[[1, 1, 1, 1],
              [1, 1, 1, 1],
              [1, 1, 1, 1]],
      
             [[1, 1, 1, 1],
              [1, 1, 1, 1],
              [1, 1, 1, 1]]])
      
      In [4]: b = a.astype(np.float)
      
      In [5]: b
      Out[5]:
      array([[[ 1.,  1.,  1.,  1.],
              [ 1.,  1.,  1.,  1.],
              [ 1.,  1.,  1.,  1.]],
      
             [[ 1.,  1.,  1.,  1.],
              [ 1.,  1.,  1.,  1.],
              [ 1.,  1.,  1.,  1.]]])
      
  • ndarray陣列向列表的轉換
    • ls = a.tolist()。

      In [1]: import numpy as np
      
      In [2]: a = np.ones((2, 3, 4), dtype = np.int32)
      
      In [3]: a
      Out[3]:
      array([[[1, 1, 1, 1],
              [1, 1, 1, 1],
              [1, 1, 1, 1]],
      
             [[1, 1, 1, 1],
              [1, 1, 1, 1],
              [1, 1, 1, 1]]])
      
      In [4]: a.tolist()
      Out[4]:
      [[[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]],
       [[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]]]
      

ndarray陣列的操作

  • 陣列的索引和切片
    • 索引:獲取陣列中特定位置元素的過程。

    • 切片:獲取陣列元素子集的過程。

    • 一維陣列的索引和切片:與Python的列表類似。

      In [1]: import numpy as np
      
      In [2]: a = np.array([9, 8, 7, 6, 5])
      
      In [3]: a[2]
      Out[3]: 7
      
      In [4]: a[1:4:2]  
      # 起始編號: 終止編號(不含): 步長,3元素冒號分割。
      # 編號0開始從左遞增,或‐1開始從右遞減
      Out[4]: array([8, 6])
      
    • 多維陣列的索引:

      In [1]: import numpy as np
      
      In [2]: a = np.arange(24).reshape((2, 3, 4))
      
      In [3]: a
      Out[3]:
      array([[[ 0,  1,  2,  3],
              [ 4,  5,  6,  7],
              [ 8,  9, 10, 11]],
      
             [[12, 13, 14, 15],
              [16, 17, 18, 19],
              [20, 21, 22, 23]]])
      
      In [4]: a[1, 2, 3]  # 每個維度一個索引值,逗號分割
      Out[4]: 23
      
      In [5]: a[0, 1, 2]
      Out[5]: 6
      
      In [6]: a[-1, -2, -3]
      Out[6]: 17
      
    • 多維陣列的切片:

      In [1]: import numpy as np
      
      In [2]: a = np.arange(24).reshape((2, 3, 4))
      
      In [3]: a
      Out[3]:
      array([[[ 0,  1,  2,  3],
              [ 4,  5,  6,  7],
              [ 8,  9, 10, 11]],
      
             [[12, 13, 14, 15],
              [16, 17, 18, 19],
              [20, 21, 22, 23]]])
      
      In [4]: a[:, 1, -3]     # 選取一個維度用:
      Out[4]: array([ 5, 17])
      
      In [5]: a[:, 1:3, :]      # 每個維度切片方法與一維陣列相同
      Out[5]:
      array([[[ 4,  5,  6,  7],
              [ 8,  9, 10, 11]],
      
             [[16, 17, 18, 19],
              [20, 21, 22, 23]]])
      
      In [6]: a[:, :, ::2]    # 每個維度可以使用步長跳躍切片
      Out[6]:
      array([[[ 0,  2],
              [ 4,  6],
              [ 8, 10]],
      
             [[12, 14],
              [16, 18],
              [20, 22]]])
      

ndarray陣列的運算

  • 陣列與標量之間的運算

    • 陣列與標量之間的運算作用於陣列的每一個元素。
  • NumPy一元函式:對ndarray中的資料執行元素級運算的函式。

    • np.abs(x),np.fabs(x)
      • 計算陣列各元素的絕對值。
    • np.sqrt(x)
      • 計算陣列各元素的平方根。
    • np.square(x)
      • 計算陣列各元素的平方。
    • np.log(x),np.log10(x),np.log2(x)
      • 計算陣列各元素的自然對數、 10底對數和2底對數。
    • np.ceil(x),np.floor(x)
      • 計算陣列各元素的ceiling值 或 floor值。
    • np.rint(x)
      • 計算陣列各元素的四捨五入值。
    • np.modf(x)
      • 將陣列各元素的小數和整數部分以兩個獨立陣列形式返回。
    • np.cos(x),np.cosh(x),np.sin(x),np.sinh(x),np.tan(x),np.tanh(x)
      • 計算陣列各元素的普通型和雙曲型三角函式。
    • np.exp(x)
      • 計算陣列各元素的指數值。
    • np.sign(x
      • 計算陣列各元素的符號值, 1(+), 0, ‐1(‐)。
      In [1]: import numpy as np
      
      In [2]: a = np.arange(24).reshape((2, 3, 4))
      
      In [3]: np.square(a)    # 注意陣列a並沒有真正的被改變。
      Out[3]:
      array([[[  0,   1,   4,   9],
              [ 16,  25,  36,  49],
              [ 64,  81, 100, 121]],
      
             [[144, 169, 196, 225],
              [256, 289, 324, 361],
              [400, 441, 484, 529]]], dtype=int32)
      
      In [4]: a = np.sqrt(a)
      
      In [5]: a
      Out[5]:
      array([[[ 0.        ,  1.        ,  1.41421356,  1.73205081],
              [ 2.        ,  2.23606798,  2.44948974,  2.64575131],
              [ 2.82842712,  3.        ,  3.16227766,  3.31662479]],
      
             [[ 3.46410162,  3.60555128,  3.74165739,  3.87298335],
              [ 4.        ,  4.12310563,  4.24264069,  4.35889894],
              [ 4.47213595,  4.58257569,  4.69041576,  4.79583152]]])
      
      In [6]: np.modf(a)
      Out[6]:
      (array([[[ 0.        ,  0.        ,  0.41421356,  0.73205081],
               [ 0.        ,  0.23606798,  0.44948974,  0.64575131],
               [ 0.82842712,  0.        ,  0.16227766,  0.31662479]],
      
              [[ 0.46410162,  0.60555128,  0.74165739,  0.87298335],
               [ 0.        ,  0.12310563,  0.24264069,  0.35889894],
               [ 0.47213595,  0.58257569,  0.69041576,  0.79583152]]]),
       array([[[ 0.,  1.,  1.,  1.],
               [ 2.,  2.,  2.,  2.],
               [ 2.,  3.,  3.,  3.]],
      
              [[ 3.,  3.,  3.,  3.],
               [ 4.,  4.,  4.,  4.],
               [ 4.,  4.,  4.,  4.]]]))
      
  • NumPy二元函式

    • + ‐ * / **
      • 兩個陣列各元素進行對應運算。
    • np.maximum(x, y),np.fmax(),np.minimum(x,y),np.fmin()
      • 元素級的最大值/最小值計算。
    • np.mod(x,y)
      • 元素級的模運算。
    • np.copysign(x,y)
      • 將陣列y中各元素值的符號賦值給陣列x對應元素。
    • > < >= <= == !=
      • 算術比較,產生布爾型陣列。
      In [1]: import numpy as np
      
      In [2]: a = np.arange(24).reshape((2, 3, 4))
      
      In [3]: a
      Out[3]:
      array([[[ 0,  1,  2,  3],
              [ 4,  5,  6,  7],
              [ 8,  9, 10, 11]],
      
             [[12, 13, 14, 15],
              [16, 17, 18, 19],
              [20, 21, 22, 23]]])
      
      In [4]: b = np.sqrt(a)
      
      In [5]: b
      Out[5]:
      array([[[ 0.        ,  1.        ,  1.41421356,  1.73205081],
              [ 2.        ,  2.23606798,  2.44948974,  2.64575131],
              [ 2.82842712,  3.        ,  3.16227766,  3.31662479]],
      
             [[ 3.46410162,  3.60555128,  3.74165739,  3.87298335],
              [ 4.        ,  4.12310563,  4.24264069,  4.35889894],
              [ 4.47213595,  4.58257569,  4.69041576,  4.79583152]]])
      
      In [6]: np.maximum(a, b)    # 運算結果為浮點數
      Out[6]:
      array([[[  0.,   1.,   2.,   3.],
              [  4.,   5.,   6.,   7.],
              [  8.,   9.,  10.,  11.]],
      
             [[ 12.,  13.,  14.,  15.],
              [ 16.,  17.,  18.,  19.],
              [ 20.,  21.,  22.,  23.]]])
      
      In [7]: a > b
      Out[7]:
      array([[[False, False,  True,  True],
              [ True,  True,  True,  True],
              [ True,  True,  True,  True]],
      
             [[ True,  True,  True,  True],
              [ True,  True,  True,  True],
              [ True,  True,  True,  True]]], dtype=bool)