Numpy 的核心內(nèi)容是它的多維數(shù)組對象——ndarray（N-Dimensions Array）,，整個包幾乎都是圍繞這個對象展開,。Numpy 本身并沒有提供多么高級的數(shù)據(jù)結(jié)構(gòu)和分析功能,，但它是很多高級工具（如 pandas）構(gòu)建的基礎(chǔ),，在結(jié)構(gòu)和操作上具有統(tǒng)一性,，因此理解 Numpy 的數(shù)組及面向數(shù)組的計算有助于更加高效地使用諸如 pandas 之類的工具。

數(shù)據(jù)結(jié)構(gòu)

Numpy 的 ndarray 提供了一種將同質(zhì)數(shù)據(jù)塊解釋為多維數(shù)組對象的方式,。同質(zhì),，表示數(shù)組的元素必須都是相同的數(shù)據(jù)類型（如 int，float 等）,；解釋,，表示 ndarray 的數(shù)據(jù)塊其實是線性存儲的，并通過額外的元信息解釋為多維數(shù)組結(jié)構(gòu)：

下面是一個 3×4 的矩陣：（使用類似 3×4×2... 這種格式表示多維數(shù)組的結(jié)構(gòu)時,，從左向右的數(shù)字對應(yīng)表示由表及里的維度,，或稱為軸，按索引給軸編號后可稱為“軸 0”、“軸 1”等）

>>> foo
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
>>> foo.dtype
dtype('int32')
>>> foo.shape
(3, 4)
>>> foo.strides
(16, 4)

這個矩陣的形狀（shape）是（3,4）或 3×4,，即它有 3 個長度為 4 的一維數(shù)組,；它的 dtype 是 int32 表示它的單位元素是占 4 字節(jié)的整型；跨度（strides）元組指的是在某一維度下為了獲取到下一個元素需要“跨過”的字節(jié)數(shù),?？梢娍缍仁强梢杂?形狀+dtype 來確定的。顯然這種同質(zhì)的靜態(tài)數(shù)據(jù)結(jié)構(gòu)在進(jìn)行數(shù)值運(yùn)算時效率要比 Python 內(nèi)建的可以混雜動態(tài)類型的列表要快得多,。

dtype 支持的數(shù)字類型有：

上表中加粗的 bool_ , int_ , float_ , complex_ 都與 Python 的內(nèi)建類型 bool , int , float , complex 相同,，實際上使用 Python 的類型名稱（int,float 等）也是合法的,。intc , intp 的大小不定是取決于操作系統(tǒng)。

創(chuàng)建 ndarray

創(chuàng)建數(shù)組最簡單的方法是使用 array() 函數(shù)：(numpy 的公約簡稱為 np —— import numpy as np)

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

它接受一切序列類型對象,，并將其轉(zhuǎn)化為一個 ndarray 數(shù)組,，維度視序列的嵌套深度而定：

>>> np.array([1,2,3,4])
array([1, 2, 3, 4])
>>> np.array([[1,2],[3,4]])
array([[1, 2],
       [3, 4]])

數(shù)組的 dtype 會由系統(tǒng)自動推定，除非你顯式傳遞一個參數(shù)進(jìn)去,。（系統(tǒng)一般會默認(rèn)使用 int32 或 float64）

除 array() 函數(shù)外,，還有一些可以用于創(chuàng)建數(shù)組的便捷函數(shù)：

ones(shape, dtype=None, order='C') 和 ones_like(arr_instance, dtype=None, order='K', subok=True) 使用示例,，zeros_like 取一個 ndarray 為參數(shù)，并按它的 dtype 和形狀創(chuàng)建全 0 數(shù)組：

>>> foo = np.ones((3,4),dtype=np.int32)
>>> foo
array([[1, 1, 1, 1],
       [1, 1, 1, 1],
       [1, 1, 1, 1]])
>>> bar = np.zeros_like(foo)
>>> bar
array([[0, 0, 0, 0],
       [0, 0, 0, 0],
       [0, 0, 0, 0]])

參數(shù)中的 order='C' ,，order='F' 指的是元素在內(nèi)存中的排序,，C 代表 C 順序，指行優(yōu)先,；F 代表 Fortran 順序,，指列優(yōu)先。

在 pandas 中盡量不要使用 np.empty(),，這個函數(shù)創(chuàng)建的數(shù)組里面是有值的,，除非你確定創(chuàng)建的這個數(shù)組能被完全賦值，否則后面運(yùn)算起來很麻煩,，這些“空值”的布爾類型是 True,，而且 dropna() 方法刪不掉。想創(chuàng)建空的 Series ,，可以使用 Series(np.nan,index=???) 這樣,。

ndarray 對象的屬性

.reshape(shape)

此方法用于改變數(shù)組的形狀。雖然我覺得既然 ndarray 對象的數(shù)據(jù)塊都是線性存儲的,，按說調(diào)用 .reshape() 方法的話只需要改一下數(shù)據(jù)頭中的 shape 屬性就可以了啊,，但實際上不是這樣子的！a.reshape(shape, order='C') 方法會返回一個新數(shù)組,，而不是直接改變調(diào)用者的形狀,。

>>> foo = np.arange(9)
>>> bar = foo.reshape((3,3))
>>> bar
array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])
>>> foo
array([0, 1, 2, 3, 4, 5, 6, 7, 8])

.astype(dtype)

這是一個用于轉(zhuǎn)換數(shù)組 dtype 的方法，從前面的 ndarray 數(shù)據(jù)結(jié)構(gòu)可以猜到,，這種轉(zhuǎn)換必然需要創(chuàng)建一個新數(shù)組,。如果轉(zhuǎn)換過程因為某種原因而失敗了，就會引發(fā)一個 TypeError 異常,。另外,，如 np.int32() 這樣把 dtype 當(dāng)做函數(shù)來用也是可行的，但更推薦 .astype() 方法：

>>> bar.astype(float)
array([[ 0.,  1.,  2.],
       [ 3.,  4.,  5.],
       [ 6.,  7.,  8.]])

本例中使用 Python 內(nèi)建的 float 當(dāng)做 dtype 傳了進(jìn)去,，也是可行的哦,，當(dāng)對數(shù)據(jù)大小不敏感時就可以這么做。

.transpose(*axes)

轉(zhuǎn)置方法返回的是原數(shù)組的視圖（不復(fù)制）,。因為我對多維數(shù)組也搞不太懂,，就只舉個二維數(shù)組的例子吧（不給 axes 參數(shù)）：

>>> foo = np.arange(8).reshape(2,4)
>>> foo
array([[0, 1, 2, 3],
       [4, 5, 6, 7]])
>>> foo.transpose()
array([[0, 4],
       [1, 5],
       [2, 6],
       [3, 7]])
>>> foo.T
array([[0, 4],
       [1, 5],
       [2, 6],
       [3, 7]])

數(shù)組的 .T 屬性是軸對換的快捷方式。一般在計算矩陣點積時比較方便：np.dot(arr,att.T),。嗯,，簡單的乘法（星號）是廣播運(yùn)算，點積需要使用 dot() 函數(shù),。

.sort()

ndarray 的 .sort(axis=-1, kind='quicksort', order=None) 方法可用于給數(shù)組在指定軸向上排序,。比如一個 （4，3,，2）的數(shù)組,，它的對應(yīng)軸向分別為（2,，1，0）,，方法默認(rèn)的 axis=-1 代表最外層維度,，如 “表” 里的 “行”。

>>> a = np.array([[1,4], [3,1]])
>>> a
array([[1, 4],
       [3, 1]])
>>> np.sort(a,0)
array([[1, 1],
       [3, 4]])
>>> np.sort(a,1)
array([[1, 4],
       [1, 3]])

這里使用了外部函數(shù) np.sort() 是為了在演示過程中不會影響到原數(shù)組,。np.sort() 函數(shù)總是返回一份拷貝,，而 .sort() 方法則會更改原數(shù)組。

統(tǒng)計方法

ndarray 對象還有一些統(tǒng)計方法,，可以對整個數(shù)組或某個軸向上的數(shù)據(jù)進(jìn)行統(tǒng)計計算（軸向數(shù)字越大代表的維度越高,，從 0 開始計數(shù)）。這些方法同時也可以當(dāng)做頂級函數(shù)使用,。例如：

>>> arr = np.arange(12).reshape(3,4)
>>> arr
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
>>> arr.sum()
66
>>> np.sum(arr)
66
>>> arr.mean(0)
array([ 4.,  5.,  6.,  7.])
>>> arr.mean(1)
array([ 1.5,  5.5,  9.5])
>>> arr.mean(2)
Traceback (most recent call last):
  File "<pyshell#35>", line 1, in <module>
    arr.mean(2)
    items *= arr.shape[ax]
IndexError: tuple index out of range

基本的數(shù)組統(tǒng)計方法有：

用于布爾型數(shù)組的方法

有兩個方法 .any() 和 .all() 可以用于判斷某個數(shù)組中是否存在或全部為 True,。這兩個方法也同樣支持 axis 軸向參數(shù)：

>>> arr = np.arange(12).reshape(3,4)
>>> arr
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
>>> arr.all(1)
array([False,  True,  True], dtype=bool)
>>> arr.any()
True

數(shù)組之間的運(yùn)算

形狀相同的數(shù)組之間的運(yùn)算都會應(yīng)用到元素級：

lang：python
>>> foo = np.arange(6).reshape((2,3))
>>> bar = np.arange(5,-1,-1).reshape((2,3))
>>> bar
array([[5, 4, 3],
       [2, 1, 0]])
>>> foo
array([[0, 1, 2],
       [3, 4, 5]])
>>> foo + bar
array([[5, 5, 5],
       [5, 5, 5]])
>>> foo * bar
array([[0, 4, 6],
       [6, 4, 0]])

真正的問題在于不同大小的數(shù)組間運(yùn)算時會發(fā)生什么。廣播（broadcasting）指的是不同形狀的數(shù)組之間的算數(shù)運(yùn)算的執(zhí)行方式,，這也是 Numpy 的核心內(nèi)容之一,。

廣播遵循的原則為：如果兩個數(shù)組的后緣維度（trailing dimension，即從末尾開始算起的維度）的軸長度相符或其中一方的長度為 1,，則認(rèn)為它們是廣播兼容的,。廣播會在缺失和（或）長度為 1 的維度上進(jìn)行。

嗯,，反正我是沒看明白 ╮(╯▽╰)╭ ,。自己的理解是，系統(tǒng)會在可能的條件下把形狀不同的數(shù)組補(bǔ)完成相同的形狀,，例：

>>> foo = np.arange(5)
>>> foo
array([0, 1, 2, 3, 4])
>>> foo * 5
array([ 0,  5, 10, 15, 20])

這里系統(tǒng)就會自動把 5 補(bǔ)完成 array([5, 5, 5, 5, 5]),。

索引和切片

ndarray 的索引和切片語法與 Python 的列表相似。都是通過如 [0],，[0:5:2] 這樣的方括號 + 冒號來完成,。比較不同之處在于為了方便對多維數(shù)組切片，ndarray 對象還支持使用逗號間隔的多維切片方法：[0,3],，[0,3:9:2],。

普通索引

>>> foo = np.arange(12)
>>> foo
array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])
>>> foo[:5]
array([0, 1, 2, 3, 4])
>>> foo[:5]=0
>>> foo
array([ 0,  0,  0,  0,  0,  5,  6,  7,  8,  9, 10, 11])
>>> bar = foo[:5]
>>> bar[0] = 1024
>>> foo
array([1024,  0,  0,  0,  0,  5,  6,  7,  8,  9, 10, 11])

注意這里，為了節(jié)省內(nèi)存,，對 ndarray 的切片操作獲得的都是對原數(shù)組的引用,，因此對該引用的更改操作都會反映到原數(shù)組上。如果你想復(fù)制出一段副本,，就應(yīng)當(dāng)使用 .copy() 方法：

>>> bar = foo[:5].copy()
>>> bar[:] = 1
>>> foo
array([1024,  0,  0,  0,  0,  5,  6,  7,  8,  9, 10, 11])

也許你會對這里的 foo[:] 感興趣,，這代表切全部的片,，不可以使用 foo = 1 這樣的賦值語句，這等于給 foo 重新指向一個新的內(nèi)存地址,，而非對切片元素進(jìn)行操作,。

前面提到的使用逗號在多維度下的切片方法：

>>> foo = np.arange(12).reshape(3,4)
>>> foo
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
>>> foo[0,1]
1
>>> foo[0,::2]
array([0, 2])

這種切片方法可以看做是一種語法糖，因為最標(biāo)準(zhǔn)的對多維數(shù)組的切片方法應(yīng)該是下面這樣子的,，包括 Python 原本對嵌套列表的切片方法也是這樣子的：

>>> foo
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
>>> foo[0][1]
1
>>> foo[0][::2]
array([0, 2])

即 foo[0,1] 與 foo[0][1] 效果相同，這種實現(xiàn)可以節(jié)省時間,，但不如原始方法更直觀一點,。只要記住對多維數(shù)組的單層切片總是切的最外層維度這點，操作起來就不容易亂,。

布爾型索引

布爾型索引指的是使用一個布爾型數(shù)組而非 [::] 作為切片手段,，操作會將被切片對象中對應(yīng)于布爾型數(shù)組中 True 元素位置的元素返回，并總是返回一個新的副本,。

>>> foo = np.arange(12).reshape(3,4)
>>> bar = foo.copy()
>>> bar%2==0
array([[ True, False,  True, False],
       [ True, False,  True, False],
       [ True, False,  True, False]], dtype=bool)
>>> foo[bar%2==0]
array([ 0,  2,  4,  6,  8, 10])

本例中一個值得注意之處在于 bar%2==0 這個表達(dá)式,，在 Python 的標(biāo)準(zhǔn)語法中對一個列表和一個整型應(yīng)用取余操作是非法的，你必須使用循環(huán)（如 for）遍歷列表的單個元素才行,。但 numpy 很貼心地通過廣播解決了這個問題,，吊不吊！

花式索引

花式索引（fancy indexing）是一個 Numpy 術(shù)語,，它指的是利用整數(shù)數(shù)組進(jìn)行索引,，這里的整數(shù)數(shù)組起到了index的作用。

>>> foo = np.empty((8,4),int)
>>> for i in range(8):
        foo[i] = i


>>> foo
array([[0, 0, 0, 0],
       [1, 1, 1, 1],
       [2, 2, 2, 2],
       [3, 3, 3, 3],
       [4, 4, 4, 4],
       [5, 5, 5, 5],
       [6, 6, 6, 6],
       [7, 7, 7, 7]])
>>> foo[[7,2,5]]
array([[7, 7, 7, 7],
       [2, 2, 2, 2],
       [5, 5, 5, 5]])
>>> foo[[7,2,5],[0,2,2]]
array([7, 2, 5])

上例中 foo[[7,2,5],[0,2,2]] 處兩個列表索引之間的逗號,，所起的作用與上面普通索引處的作用相同,，均為在更低一級維度上索引之用。

通用函數(shù)

通用函數(shù)（即 ufunc）是一種對 ndarray 執(zhí)行元素級運(yùn)算的函數(shù),。通用函數(shù)依據(jù)參數(shù)的數(shù)量不同,，可分為一元（unary）函數(shù)和二元（binary）函數(shù)。（參數(shù)一般都是 ndarray 對象）

一元函數(shù)

二元函數(shù)

三元函數(shù)

這里的三元函數(shù)只有一個,，而且不是接受 3 個數(shù)組參數(shù)的意思。它其實是一個條件運(yùn)算函數(shù),，即 foo if cond else bar 這個表達(dá)式的 numpy 版——where(condition, [x, y])

>>> arr = np.arange(12).reshape(3,4)
>>> arr
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
>>> np.where(arr%2==0,1,0)
array([[1, 0, 1, 0],
       [1, 0, 1, 0],
       [1, 0, 1, 0]])