01 numpy庫(一)

01-numpy

NumPy(Numerical Python) 是 Python 語言的一個擴展程序庫，支持大量的維度數組與矩陣運算，此外也針對數組運算提供大量的數學函數庫。

NumPy 是一個運行速度很是快的數學庫，主要用於數組計算，包含：
    1. 一個強大的N維數組對象 ndarray
    2. 廣播功能函數
    3. 整合 C/C++/Fortran 代碼的工具
    4. 線性代數、傅里葉變換、隨機數生成等功能

02-數據屬性

NumPy的主要對象是同種元素的多維數組。它是一個元素表（一般是數字），都是相同的類型，由正整數元組索引。在NumPy維度中稱爲軸。

例如，3D空間中的點的座標具備一個軸。該軸有3個元素，因此咱們說它的長度爲3。
而[[ 1., 0., 0.], [ 0., 1., 2.]]則有兩個軸，第一個軸的長度爲2，第二個軸的長度爲3。

Numpy數組類的名字叫作ndarray，常常簡稱爲array。
要注意將numpy.array與標準Python庫中的array.array區分開，後者只處理一維數組，而且功能簡單。[1, 2, 1]

NumPy的數組類被調用ndarray。也被稱爲 array。
請注意，numpy.array這與標準Python庫類不一樣array.array，後者只處理一維數組並提供較少的功能。

ndarray對象的屬性是：
· ndarray.ndim：數組的軸數(維度)
· ndarray.shape：數組的形狀(大小)。這是一個整數元組。好比對於n行m列的矩陣，其shape形狀就是(n,m)。而shape元組的長度則偏偏是上面的ndim值，也就是軸數。
· ndarray.size：數組中全部元素的個數。這剛好等於shape中元素的乘積n*m。
· ndarray.dtype：數組中元素的數據類型。除了標準的Python類型，Numpy還提供一些自有的類型。如 numpy.int32, numpy.int16, numpy.float64。
· ndarray.itemsize：數組中每一個元素的大小(以字節爲單位)。好比float64類型有itemsize爲8（=64/8），而complex32的itemsize爲4（=32/8）。
· ndarray.data：包含數組實際元素的緩衝區。一般咱們不須要使用這個屬性，由於咱們將使用索引工具訪問數組中的元素。
· ndarray.flags: 數組對象的一些狀態指示或標籤

 

什麼是數組的維度？
NumPy 數組的維數稱爲秩（rank），一維數組的秩爲 1，二維數組的秩爲 2，以此類推。

在 NumPy中，每個線性的數組稱爲是一個軸（axis），也就是維度（dimensions）。
好比說，二維數組至關因而兩個一維數組，其中第一個一維數組中每一個元素又是一個一維數組。
因此一維數組就是 NumPy 中的軸（axis），第一個軸至關因而底層數組，第二個軸是底層數組裏的數組。而軸的數量——秩，就是數組的維數。

怎麼能看出數組的軸數？
簡單來說：就是看數組 嵌套了幾層中括號 []。

建立一個 ndarray 只需調用 NumPy 的 array 函數便可：

numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)

# 案例
>>> import numpy as np
>>> a = np.arange(15).reshape(3, 5)
>>> a
array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14]])
>>> a.shape
(3, 5)
>>> a.ndim
2
>>> a.dtype.name
'int64'
>>> a.itemsize
8
>>> a.size
15
>>> type(a)
<type 'numpy.ndarray'>
>>> b = np.array([6, 7, 8])
>>> b
array([6, 7, 8])
>>> type(b)
<type 'numpy.ndarray'>

03-數據類型

numpy 支持的數據類型比 Python 內置的類型要多不少，基本上能夠和 C 語言的數據類型對應上，其中部分類型對應爲 Python 內置的類型。下表列舉了經常使用 NumPy 基本類型。 

名稱                 描述
bool_           布爾型數據類型（True 或者 False）
int_            默認的整數類型（相似於 C 語言中的 long，int32 或 int64）
intc            與 C 的 int 類型同樣，通常是 int32 或 int 64
intp            用於索引的整數類型（相似於 C 的 ssize_t，通常狀況下仍然是 int32 或 int64）
int8            字節（-128 to 127）
int16           整數（-32768 to 32767）
int32           整數（-2147483648 to 2147483647）
int64           整數（-9223372036854775808 to 9223372036854775807）
uint8           無符號整數（0 to 255）
uint16          無符號整數（0 to 65535）
uint32          無符號整數（0 to 4294967295）
uint64          無符號整數（0 to 18446744073709551615）
float_          float64 類型的簡寫
float16         半精度浮點數，包括：1 個符號位，5 個指數位，10 個尾數位
float32         單精度浮點數，包括：1 個符號位，8 個指數位，23 個尾數位
float64         雙精度浮點數，包括：1 個符號位，11 個指數位，52 個尾數位
complex_        complex128 類型的簡寫，即 128 位複數
complex64       複數，表示雙 32 位浮點數（實數部分和虛數部分）
complex128      複數，表示雙 64 位浮點數（實數部分和虛數部分）

數據類型對象(dtype)

數據類型對象是用來描述與數組對應的內存區域如何使用
· 數據的類型（整數，浮點數或者 Python 對象）
· 數據的大小（例如， 整數使用多少個字節存儲）
· 數據的字節順序（小端法或大端法）
· 在結構化類型的狀況下，字段的名稱、每一個字段的數據類型和每一個字段所取的內存塊的部分
· 若是數據類型是子數組，它的形狀和數據類型

numpy.dtype(object, align, copy)
· object - 要轉換爲的數據類型對象
· align - 若是爲 true，填充字段使其相似 C 的結構體。
· copy - 複製 dtype 對象 ，若是爲 false，則是對內置數據類型對象的引用

04-建立數組

ndarray 數組除了可使用底層 ndarray 構造器來建立外，也能夠經過如下幾種方式來建立。

使用array方法，並提供標準的Python列表或者元組做爲參數。此時，數組的類型將根據序列中元素的類型推導出來。

>>> import numpy as np
>>> a = np.array([2,3,4])
>>> a
array([2, 3, 4])
>>> a.dtype
dtype('int64')
>>> b = np.array([1.2, 3.5, 5.1])
>>> b.dtype
dtype('float64')

常見的錯誤是直接將多個數值做爲參數傳遞，正確的作法是將他們以列表或元組的方式傳遞，以下：

>>> a = np.array(1,2,3,4)    # 錯誤
>>> a = np.array([1,2,3,4])  # 正確

array函數會自動將二維或三維序列轉換爲對應的二維或三維數組。

>>> b = np.array([(1.5,2,3), (4,5,6)])
>>> b
array([[ 1.5,  2. ,  3. ],
       [ 4. ,  5. ,  6. ]])

也能夠在建立的時候，能夠顯式地指定數據的類型：

>>> c = np.array( [ [1,2], [3,4] ], dtype=complex )
>>> c
array([[ 1.+0.j,  2.+0.j],
       [ 3.+0.j,  4.+0.j]])

一般，數組的元素最初是未知的，但其大小是已知的。所以，NumPy提供了幾個函數來建立具備初始佔位符內容的數組。

函數zero建立一個都是0的數組，函數one建立一個都是1的數組，函數empty建立一個初始內容是0或者垃圾值的數組，這取決於內存當時的狀態。默認狀況下，建立的數組的數據類型爲float64。

>>> np.zeros( (3,4) )
array([[ 0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.]])
>>> np.ones( (2,3,4), dtype=np.int16 )                # 一樣能夠指定類型
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]]], dtype=int16)
>>> np.empty( (2,3) )                                 # 根據當前內存狀態的不一樣，可能會返回未初始化的垃圾數值，不安全。
array([[  3.73603959e-262,   6.02658058e-154,   6.55490914e-260],
       [  5.30498948e-313,   3.14673309e-307,   1.00000000e+000]])

>>> np.full((3,4), 2.22) # 建立一個所有由2.22組成的數組
array([[2.22, 2.22, 2.22, 2.22],
       [2.22, 2.22, 2.22, 2.22],
       [2.22, 2.22, 2.22, 2.22]])

爲了建立數字序列，NumPy提供了一個相似於range返回數組而不是列表的函數 arange 。

>>> np.arange( 10, 30, 5 )
array([10, 15, 20, 25])
>>> np.arange( 0, 2, 0.3 )        # 能夠接受浮點類型的參數，好比這裏的步長
array([ 0. ,  0.3,  0.6,  0.9,  1.2,  1.5,  1.8])

numpy.arange(start, stop, step, dtype)
· start：範圍的起始值，默認爲0
· stop： 範圍的終止值（不包含）
· step： 兩個值的間隔，默認爲1
· dtype： 返回ndarray的數據類型，若是沒有提供，則會使用輸入數據的類型。 

當arange函數使用浮點步長的時候，精度肯能出現問題。這種狀況下，咱們通常使用linspace函數，它的第三個參數指定在區間內均勻生成幾個數，至於步長，系統會自動計算。

>>> from numpy import pi  # 導入圓周率
>>> np.linspace( 0, 2, 9 )                 # 從0到2之間的9個數
array([ 0.  ,  0.25,  0.5 ,  0.75,  1.  ,  1.25,  1.5 ,  1.75,  2.  ])
>>> x = np.linspace( 0, 2*pi, 100 )        # 從0到2Π之間，生成100個數
>>> f = np.sin(x)

numpy.linspace(start, stop, num, endpoint, retstep, dtype)

· start： 序列的起始值
· stop： 序列的終止值，若是endpoint爲True，則終止值包含於序列中
· num： 要生成的等間隔樣例數量，默認爲50
· endpoint： 序列中是否包含stop值，默認爲Ture
· retstep： 若是爲True，返回樣例以及連續數字之間的步長
· dtype： 輸出ndarray的數據類型