【python學習】最全Numpy教程

1. Numpy概述

NumPy（Numerical Python的簡稱）是Python數值計算最重要的基礎包。大多數提供科學計算的包都是用NumPy的數組作為構建基礎。

1.1.1. Why NumPy?

1.一個強大的N維數組對象ndarray，具有矢量算術運算和復雜廣播能力的快速且節省空間的多維數組

2.用于集成由C、C++、Fortran等語言類庫的C語言 API

3.線性代數、隨機數生成以及傅里葉變換功能。

4.用于對整組數據進行快速運算的標準數學函數（無需編寫循環）,支持大量的數據運算

5.是眾多機器學習框架的基礎庫

Tips：Python的面向數組計算可以追溯到1995年，Jim Hugunin創建了Numeric庫。接下來的10年，許多科學編程社區紛紛開始使用Python的數組編程，但是進入21世紀，庫的生態系統變得碎片化了。2005年，Travis Oliphant從Numeric和Numarray項目整了出了NumPy項目，進而所有社區都集合到了這個框架下。

NumPy之于數值計算特別重要的原因之一，是因為它可以高效處理大數組的數據。這是因為：

NumPy是在一個連續的內存塊中存儲數據，獨立于其他Python內置對象。NumPy的C語言編寫的算法庫可以操作內存，而不必進行類型檢查或其它前期工作。比起Python的內置序列，NumPy數組使用的內存更少。 NumPy可以在整個數組上執行復雜的計算，而不需要Python的for循環。

我們來直觀感受一下numpy的運行速度：

# 導入numpy # 我們將依照標準的Numpy約定，即總是使用import numpy as np # 當然你也可以為了不寫np, 而直接在代碼中使用from numpy import *, # 但是建議你最好還是不要養成這樣的壞習慣。 import numpy as np # 生成一個numpy對象， 一個包含一百萬整數的數組 np_arr = np.arange(1000000) # 一個等價的Python列表： py_list = list(range(1000000))

對各個序列分別平方操作（%time是ipython的特殊功能，用于測試語句運行的時間需要安裝ipython， pip install ipython)

%time for _ in range(10): np_arr2 = np_arr ** 2

CPU times: user 13.1 ms, sys: 5.62 ms, total: 18.8 ms Wall time: 17.7 ms

%time for _ in range(10): py_list2 = [x ** 2 for x in py_list]

CPU times: user 3.06 s, sys: 173 ms, total: 3.24 s Wall time: 3.25 s 由上述代碼可以看出，基于NumPy的算法要比純Python快10到100倍（甚至更快），并且使用的內存更少

2. 創建ndarray

NumPy最重要的一個特點就是ndarray(N-dimensional array)，即N維數組），該對象是一個快速而靈活的大數據集容器。你可以利用這種數組對整塊數據執行一些數學運算，其語法跟標量元素之間的運算一樣。

# 創建numpy數組的方式 import numpy as np

np.__version__

'1.15.2'

nparr = np.array([i for i in range(10)]) nparr

array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

array([[11, 22, 33, 44], [10, 20, 30, 40]])

2.1.1. arange創建數組

arange函數是python內置函數range函數的數組版本.

# 產生0-9共10個元素 ndarray = np.arange(10) ndarray

array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

# 產生從10-19共10個元素 ndarray1 = np.arange(10, 20)

# 產生10 12 14 16 18, 2為step ndarray2 = np.arange(10, 20, 2) ndarray2

array([10, 12, 14, 16, 18])

# ndarray2的形狀 ndarray2.shape

(5,)

2.1.2. 其他創建numpy數組的方式

使用zeros和zeros_like創建數組

用于創建數組，數組元素默認值是0. 注意:zeros_linke函數只是根據傳入的ndarray數組的shape來創建所有元素為0的數組，并不是拷貝源數組中的數據.

ndarray4 = np.zeros(10) ndarray5 = np.zeros((3, 3)) ndarray6 = np.zeros_like(ndarray5) # 按照 ndarray5 的shape創建數組 # 打印數組元素類型 print("以下為數組類型:") print('ndarray4:', type(ndarray4)) print('ndarray5:', type(ndarray5)) print('ndarray6:', type(ndarray6)) print("-------------") print("以下為數組元素類型:") print('ndarray4:', ndarray4.dtype) print('ndarray5:', ndarray5.dtype) print('ndarray6:', ndarray6.dtype) print("-------------") print("以下為數組形狀:") print('ndarray4:', ndarray4.shape) print('ndarray5:', ndarray5.shape) print('ndarray6:', ndarray6.shape)

以下為數組類型: ndarray4: ndarray5: ndarray6: ------------- 以下為數組元素類型: ndarray4: float64 ndarray5: float64 ndarray6: float64 ------------- 以下為數組形狀: ndarray4: (10,) ndarray5: (3, 3) ndarray6: (3, 3)

ones和ones_like創建數組

# 用于創建所有元素都為1的數組.ones_like用法同zeros_like用法. # 創建數組，元素默認值是0 ndarray7 = np.ones(10) ndarray7

array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1.])

ndarray8 = np.ones((3, 3))

ndarray9 = np.ones_like(ndarray5) # 按照 ndarray5 的shape創建數組 ndarray9

array([[1., 1., 1.], [1., 1., 1.], [1., 1., 1.]])

empty和empty_like創建數組

ndarray10 = np.empty(5) ndarray11 = np.empty((2, 3)) ndarray12 = np.empty_like(ndarray11) ndarray12

array([[7.e-323, 0.e+000, 0.e+000], [0.e+000, 6.e-323, 0.e+000]])

eye創建對角矩陣數組

該函數用于創建一個N*N的矩陣，對角線為1，其余為0.

ndarray13 = np.eye(5) ndarray13

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

np.full((3, 5), 666)

array([[666, 666, 666, 666, 666], [666, 666, 666, 666, 666], [666, 666, 666, 666, 666]])

3. ndarray的數據類型及索引

3.1.1. ndarray的數據類型

dtype（數據類型）是一個特殊的對象，它含有ndarray將一塊內存解釋為特定數據類型所需的信息：

In [33]: arr1 = np.array([1, 2, 3], dtype=np.float64) In [34]: arr2 = np.array([1, 2, 3], dtype=np.int32) In [35]: arr1.dtype Out[35]: dtype('float64') In [36]: arr2.dtype Out[36]: dtype('int32')

dtype是NumPy靈活交互其它系統的源泉之一。多數情況下，它們直接映射到相應的機器表示，這使得“讀寫磁盤上的二進制數據流”以及“集成低級語言代碼（如C、Fortran）”等工作變得更加簡單。數值型dtype的命名方式相同：一個類型名（如float或int），后面跟一個用于表示各元素位長的數字。標準的雙精度浮點值（即Python中的float對象）需要占用8字節（即64位）。因此，該類型在NumPy中就記作float64

Tips：記不住這些NumPy的dtype也沒關系，新手更是如此。通常只需要知道你所處理的數據的大致類型是浮點數、復數、整數、布爾值、字符串，還是普通的Python對象即可。當你需要控制數據在內存和磁盤中的存儲方式時（尤其是對大數據集），那就得了解如何控制存儲類型。 你可以通過ndarray的astype方法明確地將一個數組從一個dtype轉換成另一個dtype： ```In [37]: arr = np.array([1, 2, 3, 4, 5])

In [38]: arr.dtype Out[38]: dtype(‘int64’)

In [39]: float_arr = arr.astype(np.float64)

In [40]: float_arr.dtype Out[40]: dtype(‘float64’)

在本例中，整數被轉換成了浮點數。如果將浮點數轉換成整數，則小數部分將會被截取刪除：

In [41]: arr = np.array([3.7, -1.2, -2.6, 0.5, 12.9, 10.1])

In [42]: arr Out[42]: array([ 3.7, -1.2, -2.6, 0.5, 12.9, 10.1])

In [43]: arr.astype(np.int32) Out[43]: array([ 3, -1, -2, 0, 12, 10], dtype=int32)

如果某字符串數組表示的全是數字，也可以用astype將其轉換為數值形式：

In [44]: numericstrings = np.array([‘1.25’, ‘-9.6’, ‘42’], dtype=np.string)

In [45]: numeric_strings.astype(float) Out[45]: array([ 1.25, -9.6 , 42. ])

> 注意：使用numpy.string_類型時，一定要小心，因為NumPy的字符串數據是大小固定的，發生截取時，不會發出警告。pandas提供了更多非數值數據的便利的處理方法 如果轉換過程因為某種原因而失敗了（比如某個不能被轉換為float64的字符串），就會引發一個ValueError。這里，我比較懶，寫的是float而不是np.float64；NumPy很聰明，它會將Python類型映射到等價的dtype上。 數組的dtype還有另一個屬性：

注意：使用numpy.string_類型時，一定要小心，因為NumPy的字符串數據是大小固定的，發生截取時，不會發出警告。pandas提供了更多非數值數據的便利的處理方法

如果轉換過程因為某種原因而失敗了（比如某個不能被轉換為float64的字符串），就會引發一個ValueError。這里，我比較懶，寫的是float而不是np.float64；NumPy很聰明，它會將Python類型映射到等價的dtype上。

數組的dtype還有另一個屬性：

In [46]: int_array = np.arange(10)

In [47]: calibers = np.array([.22, .270, .357, .380, .44, .50], dtype=np.float64)

In [48]: int_array.astype(calibers.dtype) Out[48]: array([ 0., 1., 2., 3., 4., 5., 6., 7., 8., 9.])

你還可以用簡潔的類型代碼來表示dtype：

In [49]: empty_uint32 = np.empty(8, dtype=‘u4’)

In [50]: empty_uint32 Out[50]: array([ 0, 1075314688, 0, 1075707904, 0, 1075838976, 0, 1072693248], dtype=uint32)

Tips ：調用astype總會創建一個新的數組（一個數據的備份），即使新的dtype與舊的dtype相同。

NumPy數組的運算

數組很重要，因為它使你不用編寫循環即可對數據執行批量運算。NumPy用戶稱其為矢量化（vectorization）。大小相等的數組之間的任何算術運算都會將運算應用到元素級：（不需要循環即可對數據進行批量運算，叫做矢量化運算. 不同形狀的數組之間的算數運算，叫做廣播,后面會介紹）

In [51]: arr = np.array([[1., 2., 3.], [4., 5., 6.]])

In [52]: arr Out[52]: array([[ 1., 2., 3.], [ 4., 5., 6.]])

In [53]: arr * arr Out[53]: array([[ 1., 4., 9.], [ 16., 25., 36.]])

In [54]: arr - arr Out[54]: array([[ 0., 0., 0.], [ 0., 0., 0.]])

數組與標量的算術運算會將標量值傳播到各個元素：

In [55]: 1 / arr Out[55]: array([[ 1. , 0.5 , 0.3333], [ 0.25 , 0.2 , 0.1667]])

In [56]: arr ** 0.5 Out[56]: array([[ 1. , 1.4142, 1.7321], [ 2. , 2.2361, 2.4495]])

大小相同的數組之間的比較會生成布爾值數組：

In [57]: arr2 = np.array([[0., 4., 1.], [7., 2., 12.]])

In [58]: arr2 Out[58]: array([[ 0., 4., 1.], [ 7., 2., 12.]])

In [59]: arr2 > arr Out[59]: array([[False, True, False], [ True, False, True]], dtype=bool)

# 數組索引和切片 Numpy數組的索引是一個內容豐富的主題，因為選取數據子集或單個元素的方式有很多。一維數組很簡單。從表面上看，它們和Python列表的功能差不多。 ### 數組索引和切片基本用法 import numpy as np

# 小x可以表示成數學中的向量 x = np.arange(10) x

array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

# 大X表示矩陣 X = np.arange(15).reshape((3, 5)) X

# 大X表示矩陣 X = np.arange(15).reshape((3, 5)) X

二維數組

下圖說明了二維數組的索引方式。軸0作為行，軸1作為列。

三維數組

# 訪問x中值是1的元素 x[1]

3

# 賦值 損失了精度，截斷操作 x[1] = 3.64

x

array([0, 3, 2, 3, 4, 5, 6, 7, 8, 9]) # 切片

x[1:4]

array([3, 2, 3])

# 按照先行后列的訪問方式 X[1][4]

9

# 第二種寫法，推薦， 逗號前面是行索引，后面是列索引 X[1,4]

9

X[1,4] = 33

X

array([[ 0, 1, 2, 3, 4], [ 5, 6, 7, 8, 33], [10, 11, 12, 13, 14]])

X[1,4] = 33 X

array([[ 0, 1, 2, 3, 4], [ 5, 6, 7, 8, 33], [10, 11, 12, 13, 14]])

numpy的特殊之處

當把一個數字值賦值給一個切片時，該值會自動傳播到整個選區。跟列表的區別在于，數組切片是原始數組的視圖，這意味著數據不會被賦值，視圖上的任何修改都會直接反應到源數組上.

大家可能對此感到不解，由于Numpy被設計的目的是處理大數據，如果Numpy將數據復制來復制去的話會產生何等的性能和內存問題.

如果要得到一個切片副本的話，必須顯式進行復制操作.

# 切片賦值 x[3:6] = 12 x array([ 0, 3, 2, 12, 12, 12, 6, 7, 8, 9]) arr_slice = x[3:6] # 對切片的值進行修改，也會體現到原數組身上 arr_slice[0] = 999 arr_slice array([999, 666, 666]) arr_slice[:] =666 x array([ 0, 3, 2, 666, 666, 666, 6, 7, 8, 9]) # 如果你還是想要數組切片的拷貝而不是一份視圖的話，可以進行如下操作 X[:2, 2:4].copy() array([[2, 3], [7, 8]])

3.1.2. Fancy indexing花式索引

花式索引是一個NumPy術語，它指的是利用整數數組進行索引

arr = np.empty((8, 4))

for i in range(8): arr[i] = i

arr

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

# 為了以特定順序選取行子集，只需傳入一個用于指定順序的整數列表或ndarray即可 arr[[4, 3, 0, 6]]

array([[4., 4., 4., 4.], [3., 3., 3., 3.], [0., 0., 0., 0.], [6., 6., 6., 6.]])

# 這段代碼確實達到我們的要求了！使用負數索引將會從末尾開始選取行 arr[[-3, -5, -7]]

# 這段代碼確實達到我們的要求了！使用負數索引將會從末尾開始選取行 arr[[-3, -5, -7]]

# 一次傳入多個索引數組會有一點特別。它返回的是一個一維數組，其中的元素對應各個索引元組 arr = np.arange(32).reshape((8, 4)) arr

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], [24, 25, 26, 27], [28, 29, 30, 31]])

arr[[1, 5, 7, 2], [0, 3, 1, 2]]

arr[[1, 5, 7, 2], [0, 3, 1, 2]]

最終選出的是元素(1,0)、(5,3)、(7,1)和(2,2)。無論數組是多少維的，花式索引總是一維的。

這個花式索引的行為可能會跟某些用戶的預期不一樣，選取矩陣的行列子集應該是矩形區域的形式才對。下面是得到該結果的一個辦法：

arr[[1, 5, 7, 2]][:, [0, 3, 1, 2]]

array([[ 4, 7, 5, 6], [20, 23, 21, 22], [28, 31, 29, 30], [ 8, 11, 9, 10]])

記住，花式索引跟切片不一樣，它總是將數據復制到新數組中。

3.1.3. 布爾型索引

來看這樣一個例子，假設我們有一個用于存儲數據的數組以及一個存儲姓名的數組（含有重復項）。在這里，我將使用numpy.random中的randn函數生成一些正態分布的隨機數據：

names = np.array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe']) names

array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'], dtype='

array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'], dtype='

array([[ 0.37370083, -0.33013143, -1.92042758, 0.61234423], [-1.33734942, 0.29967533, 0.24341654, -1.17391872], [-2.28175004, 0.03064196, -1.17277248, 0.174594 ], [-0.5281719 , -0.2502034 , -0.88710013, -1.49036329], [-0.72162151, 0.48662607, -2.25498875, 0.84092399], [-0.58559699, -1.82182432, 1.73469502, 0.54399163], [ 0.14997894, 1.72946463, 1.47252027, -1.79768056]])

假設每個名字都對應data數組中的一行，而我們想要選出對應于名字"Bob"的所有行。跟算術運算一樣，數組的比較運算（如==）也是矢量化的。因此，對names和字符串"Bob"的比較運算將會產生一個布爾型數組：

names == 'Bob' array([ True, False, False, True, False, False, False])

這個布爾型數組可用于數組索引：

data[names == 'Bob'] # 實際上選的是第1行和第4行的篩選 array([[ 0.37370083, -0.33013143, -1.92042758, 0.61234423], [-0.5281719 , -0.2502034 , -0.88710013, -1.49036329]]) # 如果布爾型數組的長度不對，布爾型選擇就會出錯，因此一定要小心。 # 下面的例子，我選取了names == 'Bob'的行，并索引了列： data[names == 'Bob', 2:] array([[-1.92042758, 0.61234423], [-0.88710013, -1.49036329]]) # 要選擇除"Bob"以外的其他值，既可以使用不等于符號（!=），也可以通過~對條件進行否定： names != 'Bob' array([False, True, True, False, True, True, True]) data[~(names == 'Bob')] array([[-1.33734942, 0.29967533, 0.24341654, -1.17391872], [-2.28175004, 0.03064196, -1.17277248, 0.174594 ], [-0.72162151, 0.48662607, -2.25498875, 0.84092399], [-0.58559699, -1.82182432, 1.73469502, 0.54399163], [ 0.14997894, 1.72946463, 1.47252027, -1.79768056]])

使用布爾類型數組設置值是一種經常用到的手段

import numpy as np ndarray1 = np.arange(5) ndarray1 array([0, 1, 2, 3, 4]) ndarray2 = np.arange(16).reshape((4, 4)) ndarray2 array([[ 0, 1, 2, 3], [ 4, 5, 6, 7], [ 8, 9, 10, 11], [12, 13, 14, 15]]) names = np.array(['aaa', 'bbb', 'ccc', 'ddd']) names array(['aaa', 'bbb', 'ccc', 'ddd'], dtype=' 2] = 8 ndarray1 array([0, 1, 2, 8, 8]) # 將ndarray2的aaa這一行所有的元素設置為0 ndarray2[names == 'aaa'] = 0 # 將ndarray2的bbb這一行2位置往后所有的元素設置為1 ndarray2[names == 'bbb', 2:] = 666 ndarray2 array([[ 0, 0, 0, 0], [ 4, 5, 666, 666], [ 8, 9, 10, 11], [ 12, 13, 14, 15]]) # 將ndarray2的ccc ddd這2行所有的元素設置為2 ndarray2[(names == 'ccc') | (names == 'ddd')] = 999 ndarray2 array([[ 0, 0, 0, 0], [ 4, 5, 666, 666], [999, 999, 999, 999], [999, 999, 999, 999]])

4. 數組函數

4.1.1. 通用函數：快速的元素級數組函數

通用函數（即universal function）是一種對ndarray中的數據執行元素級運算的函數。你可以將其看做簡單函數（接受一個或多個標量值，并產生一個或多個標量值）的矢量化包裝器。 許多ufunc都是簡單的元素級變體，如sqrt和exp：

常用一元ufunc:

常用二元ufunc:

import numpy as np ndarray1 = np.array([3.5, 1.7, 2.2, -7.8, np.nan, 4.6, -3.4]) ndarray1 array([ 3.5, 1.7, 2.2, -7.8, nan, 4.6, -3.4]) # abs 計算整數、浮點數的絕對值。 np.abs(ndarray1) array([3.5, 1.7, 2.2, 7.8, nan, 4.6, 3.4]) # square計算各元素的平方根。相當于arr ** 0.5 np.square(ndarray1) array([12.25, 2.89, 4.84, 60.84, nan, 21.16, 11.56]) # sign 計算各元素的正負號,1(正數)、0（零）、-1(負數) np.sign(ndarray1) array([ 1., 1., 1., -1., nan, 1., -1.]) # ceil 計算各元素的celling值，即大于該值的最小整數。 np.ceil(ndarray1) array([ 4., 2., 3., -7., nan, 5., -3.]) # floor 計算各元素的floor值，即小于等于該值的最大整數。 np.floor(ndarray1) array([ 3., 1., 2., -8., nan, 4., -4.]) # rint 將各元素值四舍五入到最近的整數，保留dtype np.rint(ndarray1) array([ 4., 2., 2., -8., nan, 5., -3.]) # isnan 返回一個表示“那些是NaN（這不是一個數字）”的布爾類型數組. np.isnan(ndarray1) array([False, False, False, False, True, False, False])

二元運算符

ndarray2 = np.random.randint(1, 20, (4, 5)) ndarray3 = np.random.randint(-10, 10, (4, 5)) ndarray3 = np.where(ndarray3 == 0, 1, ndarray3) # add 將數組中對應的元素相加. np.add(ndarray2, ndarray3) array([[15, 10, 6, 24, 5], [ 8, 4, 6, -6, 9], [ 9, 9, 4, 16, 12], [ 9, 16, 14, 1, 5]]) # subtract 從第一個數組中減去第二個數組中的元素. np.subtract(ndarray2, ndarray3) array([[17, 22, -2, 6, -1], [26, 6, 20, 10, -3], [25, 5, 22, 20, 8], [13, 14, -2, 7, 11]]) # maximum、fmax 從兩個數組中取出最大值。fmax將忽略NaN np.maximum(ndarray2, ndarray3) array([[16, 16, 4, 15, 3], [17, 5, 13, 2, 6], [17, 7, 13, 18, 10], [11, 15, 8, 4, 8]]) # mod 元素級的求模計算.相當于Python模運算符``x1％x2``，并且與除數x2具有相同的符號. np.mod(ndarray2, ndarray3) array([[ 0, -2, 2, 6, 2], [-1, 0, -1, -6, 3], [-7, 1, -5, 0, 0], [-1, 0, 6, -2, -1]]) # copysign 將第二個數組中的值的符號復制給第一個數組中的值. np.copysign(ndarray2, ndarray3) array([[-16., -16., 2., 15., 2.], [-17., -5., -13., -2., 3.], [-17., 7., -13., -18., 10.], [-11., 15., 6., -4., -8.]]) # greater、greater_equal 執行元素級的運算比較，最終產生布爾類型數組。 np.greater(ndarray2, ndarray3) array([[ True, True, False, True, False], [ True, True, True, True, False], [ True, True, True, True, True], [ True, True, False, True, True]])

可以通過數組上的一組數學函數對整個數組或某些數據進行統計計算。 基本的數組統計方法:

多維數組默認統計全部維度，axis參數可以按指定軸心統計，值為0則按列統計，值為1則按行統計。

import numpy as np ndarray1 = np.random.randint(1, 10, (4, 5)) ndarray1 array([[4, 7, 3, 3, 4], [6, 6, 1, 3, 4], [8, 8, 8, 2, 8], [8, 9, 8, 3, 7]])

sum求元素和

# 0-列 1-行 # sum-計算所有元素和 np.sum(ndarray1) 110 # sum-計算每一列的元素和 np.sum(ndarray1, axis=0) array([26, 30, 20, 11, 23]) # sum-計算每一行的元素和 np.sum(ndarray1, axis=1) array([21, 20, 34, 35])

argmax求最大值索引

# argmax-默認情況下按照一維數組索引 np.argmax(ndarray1) 16 # argmax-統計每一列最大 np.argmax(ndarray1, axis=0) array([2, 3, 2, 0, 2]) # argmax-統計每一行最大 np.argmax(ndarray1, axis=1) array([1, 0, 0, 1])

mean求平均數 # mean-求所有元素的平均值 np.mean(ndarray1) 5.5 # mean-求每一列元素的平均值 np.mean(ndarray1, axis=0) array([6.5 , 7.5 , 5. , 2.75, 5.75]) # mean-求每一行元素的平均值 np.mean(ndarray1, axis=1) array([4.2, 4. , 6.8, 7. ]) cumsum求元素累計和 # cumsum-前面元素的累計和 np.cumsum(ndarray1) array([ 4, 11, 14, 17, 21, 27, 33, 34, 37, 41, 49, 57, 65, 67, 75, 83, 92, 100, 103, 110]) # cumsum-每一列元素的累計和 np.cumsum(ndarray1, axis=0) array([[ 4, 7, 3, 3, 4], [10, 13, 4, 6, 8], [18, 21, 12, 8, 16], [26, 30, 20, 11, 23]]) # cumsum-每一行元素的累計和 np.cumsum(ndarray1, axis=1) array([[ 4, 11, 14, 17, 21], [ 6, 12, 13, 16, 20], [ 8, 16, 24, 26, 34], [ 8, 17, 25, 28, 35]]) 4.1.3. all和any函數 import numpy as np # 判斷兩個數組元素是否相等 ndarray1 = np.arange(6).reshape((2, 3)) ndarray2 = np.arange(6).reshape((2, 3)) ndarray2 array([[0, 1, 2], [3, 4, 5]]) ndarray3 = np.array([[ 0, 1, 2], [ 8, 9, 10]]) ndarray3 array([[ 0, 1, 2], [ 8, 9, 10]]) (ndarray1 == ndarray2).all() True (ndarray1 == ndarray3).all() False (ndarray1 == ndarray3).any() True

4.1.4. 添加和刪除函數

reshape：有返回值，即不對原始多維數組進行修改； resize：無返回值，即會對原始多維數組進行修改； import numpy as np ndarray1 = np.arange(4) ndarray2 = np.arange(4) ndarray2 array([0, 1, 2, 3]) ndarray3 = np.arange(12).reshape((3, 4)) ndarray3 array([[ 0, 1, 2, 3], [ 4, 5, 6, 7], [ 8, 9, 10, 11]])

append數組中追加元素 # 數組追加一個數值元素 print(ndarray1) np.append(ndarray1, 100) [0 1 2 3] array([ 0, 1, 2, 3, 100]) # 在一維數組后追加一維數組 print(ndarray2) np.append(ndarray1, ndarray2) [0 1 2 3] array([0, 1, 2, 3, 0, 1, 2, 3]) # 在二維數組后追加標量元素 print(ndarray3) np.append(ndarray3, 100) [[ 0 1 2 3] [ 4 5 6 7] [ 8 9 10 11]] array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 100]) # append總是返回一維數組 np.append(ndarray1, ndarray3) array([ 0, 1, 2, 3, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]) concatenate合并兩個數組元素 ndarray4 = np.arange(12).reshape((3, 4)) ndarray4 array([[ 0, 1, 2, 3], [ 4, 5, 6, 7], [ 8, 9, 10, 11]]) # 合并兩個一維數組 np.concatenate((ndarray1, ndarray2)) array([0, 1, 2, 3, 0, 1, 2, 3]) # 合并兩個二維數組 np.concatenate((ndarray3, ndarray4), axis=0) array([[ 0, 1, 2, 3], [ 4, 5, 6, 7], [ 8, 9, 10, 11], [ 0, 1, 2, 3], [ 4, 5, 6, 7], [ 8, 9, 10, 11]]) # 合并兩個二維數組 np.concatenate((ndarray3, ndarray4), axis=1) array([[ 0, 1, 2, 3, 0, 1, 2, 3], [ 4, 5, 6, 7, 4, 5, 6, 7], [ 8, 9, 10, 11, 8, 9, 10, 11]]) delete刪除一行或者一列數組元素 ndarray5 = np.arange(20).reshape((4, 5)) ndarray5 array([[ 0, 1, 2, 3, 4], [ 5, 6, 7, 8, 9], [10, 11, 12, 13, 14], [15, 16, 17, 18, 19]]) # 刪除第0行元素 np.delete(ndarray5, 0, axis=0) array([[ 5, 6, 7, 8, 9], [10, 11, 12, 13, 14], [15, 16, 17, 18, 19]]) # 刪除第2列元素 np.delete(ndarray5, 1, axis=1) array([[ 0, 2, 3, 4], [ 5, 7, 8, 9], [10, 12, 13, 14], [15, 17, 18, 19]]) # 刪除第0、2、3列元素 np.delete(ndarray5, [0, 2, 3], axis=1) array([[ 1, 4], [ 6, 9], [11, 14], [16, 19]]) # 使用np.s_[::]創建切片對象 # 刪除從1、2列元素 np.delete(ndarray5, np.s_[1:3], axis=1) array([[ 0, 3, 4], [ 5, 8, 9], [10, 13, 14], [15, 18, 19]]) insert插入元素 # 在第2個位置插入元素100 ndarray6 = np.arange(4) print(ndarray6) np.insert(ndarray6, 1, 100) [0 1 2 3] array([ 0, 100, 1, 2, 3]) # 在第3個位置插入兩個元素10、20 np.insert(ndarray6, 2, [10, 20]) array([ 0, 1, 10, 20, 2, 3]) # 在第2行插入一行元素 np.insert(ndarray6, 1, np.array([100, 200, 300, 400]), axis=0) array([ 0, 100, 200, 300, 400, 1, 2, 3]) # 在第3列插入一列元素 ndarray7 = np.arange(12).reshape((3, 4)) np.insert(ndarray7, 2, np.array([100, 200, 300]), axis=1) array([[ 0, 1, 100, 2, 3], [ 4, 5, 200, 6, 7], [ 8, 9, 300, 10, 11]])

5. 唯一化和集合函數

Numpy提供了一些針對一維ndarray的基本集合運算。最常用的就是np.unique了，它用于找出數組中的唯一值并返回已排序的結果。

唯一化 import numpy as np names = np.array(['aaa', 'bbb', 'ccc', 'aaa', 'ddd', 'eee', 'ccc']) ndarray1 = np.random.randint(1, 5, 10) ndarray2 = np.random.randint(1, 5, (3, 4)) ndarray1 array([3, 4, 3, 3, 2, 1, 3, 3, 3, 2]) ndarray2 array([[4, 2, 3, 4], [1, 2, 3, 1], [3, 4, 4, 2]]) np.unique(names) array(['aaa', 'bbb', 'ccc', 'ddd', 'eee'], dtype='

5.1.1. 隨機數生成函數

numpy.random模塊對Python內置的random進行了補充。我們使用numpy.random可以很方便根據需要產生大量樣本值。而python內置的random模塊則一次生成一個樣本值.

下圖簡單回憶一下均勻分布和正態分布

import numpy as np ndarray1 = np.arange(10) np.random.permutation(5) array([0, 1, 3, 4, 2]) np.random.permutation(ndarray1) array([5, 8, 4, 2, 6, 1, 0, 7, 9, 3]) np.random.shuffle(ndarray1) ndarray1 array([7, 3, 0, 6, 8, 1, 9, 5, 4, 2]) np.random.randint(10, 20) 12 np.random.randint(10, 20, 20) array([13, 12, 15, 11, 19, 16, 14, 19, 18, 17, 12, 13, 10, 13, 16, 10, 12, 14, 18, 12]) np.random.randint(10, 20, (3, 4)) array([[19, 13, 14, 15], [16, 18, 16, 13], [17, 16, 18, 10]])

6. 數組排序函數

對一維數組排序 import numpy as np ndarray1 = np.random.randint(1, 10, (1, 5)) ndarray1 array([[4, 6, 7, 5, 4]]) ndarray1.sort() ndarray1 array([[4, 4, 5, 6, 7]]) 對二維數組排序 ndarray2 = np.random.randint(1, 10, (5, 5)) ndarray2 array([[8, 1, 3, 3, 7], [9, 3, 5, 5, 8], [4, 7, 9, 6, 1], [9, 4, 1, 2, 8], [8, 7, 6, 6, 4]]) # 對每行數據進行排序 ndarray2.sort() ndarray2 array([[1, 3, 3, 7, 8], [3, 5, 5, 8, 9], [1, 4, 6, 7, 9], [1, 2, 4, 8, 9], [4, 6, 6, 7, 8]]) # 對每列數據進行排序 ndarray2.sort(axis=0) ndarray2 array([[1, 2, 3, 7, 8], [1, 3, 4, 7, 8], [1, 4, 5, 7, 9], [3, 5, 6, 8, 9], [4, 6, 6, 8, 9]]) ndarray3 = np.sort(ndarray2) # 返回排序副本，源數據不變 ndarray3 array([[1, 2, 3, 7, 8], [1, 3, 4, 7, 8], [1, 4, 5, 7, 9], [3, 5, 6, 8, 9], [4, 6, 6, 8, 9]]) argsort函數(很重要) argsort函數返回的是數組值從小到大的索引值 import numpy as np x = np.arange(10) x array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) np.random.shuffle(x) x array([3, 7, 9, 5, 6, 1, 0, 2, 4, 8]) np.argsort(x) array([6, 5, 7, 0, 8, 3, 4, 1, 9, 2])

7. 廣播

廣播（broadcasting）指的是不同形狀的數組之間的算術運算的執行方式。它是一種非常強大的功能，但也容易令人誤解，即使是經驗豐富的老手也是如此。將標量值跟數組合并時就會發生最簡單的廣播：

import numpy as np arr = np.arange(5) arr array([0, 1, 2, 3, 4]) arr * 4 array([ 0, 4, 8, 12, 16])

這里我們說：在這個乘法運算中，標量值4被廣播到了其他所有的元素上。

看一個例子，我們可以通過減去列平均值的方式對數組的每一列進行距平化處理。這個問題解決起來非常簡單：

arr = np.random.randn(4, 3) arr array([[ 1.14072113e+00, -3.75330408e-01, 1.07997253e+00], [ 2.92296713e-01, 5.19115583e-01, 1.29876898e+00], [-1.12729644e+00, 1.30713095e+00, -4.75432622e-01], [-2.30075456e-01, 2.16281589e+00, 1.92077343e-03]]) arr.mean(0) array([0.01891149, 0.903433 , 0.47630741]) demeaned = arr - arr.mean(0) demeaned array([[ 1.12180965, -1.27876341, 0.60366511], [ 0.27338522, -0.38431742, 0.82246156], [-1.14620793, 0.40369794, -0.95174004], [-0.24898694, 1.25938289, -0.47438664]]) demeaned.mean(0) array([-6.93889390e-18, 0.00000000e+00, -2.77555756e-17])

下圖形象地展示了該過程。用廣播的方式對行進行距平化處理會稍微麻煩一些。幸運的是，只要遵循一定的規則，低維度的值是可以被廣播到數組的任意維度的（比如對二維數組各列減去行平均值）。

廣播原則

畫張圖并想想廣播的原則。再來看一下最后那個例子，假設你希望對各行減去那個平均值。由于arr.mean(0)的長度為3，所以它可以在0軸向上進行廣播：因為arr的后緣維度是3，所以它們是兼容的。根據該原則，要在1軸向上做減法（即各行減去行平均值），較小的那個數組的形狀必須是(4,1)：

arr array([[ 1.14072113e+00, -3.75330408e-01, 1.07997253e+00], [ 2.92296713e-01, 5.19115583e-01, 1.29876898e+00], [-1.12729644e+00, 1.30713095e+00, -4.75432622e-01], [-2.30075456e-01, 2.16281589e+00, 1.92077343e-03]]) row_means = arr.mean(1) row_means array([ 0.61512108, 0.70339376, -0.0985327 , 0.64488707]) row_means.shape (4,) row_means.reshape((4, 1)) array([[ 0.61512108], [ 0.70339376], [-0.0985327 ], [ 0.64488707]]) demeaned = arr - row_means.reshape((4, 1)) demeaned array([[ 0.52560005, -0.99045149, 0.46485144], [-0.41109705, -0.18427818, 0.59537522], [-1.02876373, 1.40566365, -0.37689992], [-0.87496253, 1.51792882, -0.6429663 ]]) demeaned.mean(1) array([ 0.00000000e+00, -3.70074342e-17, 5.55111512e-17, 0.00000000e+00])

下圖說明了該運算的過程

二維數組在軸1上的廣播

下圖展示了另外一種情況，這次是在一個三維數組上沿0軸向加上一個二維數組。 三維數組在軸0上的廣播

Numpy Python 數據結構

版權聲明：本文內容由網絡用戶投稿，版權歸原作者所有，本站不擁有其著作權，亦不承擔相應法律責任。如果您發現本站中有涉嫌抄襲或描述失實的內容，請聯系我們jiasou666@gmail.com 處理，核實后本網站將在24小時內刪除侵權內容。

版權聲明：本文內容由網絡用戶投稿，版權歸原作者所有，本站不擁有其著作權，亦不承擔相應法律責任。如果您發現本站中有涉嫌抄襲或描述失實的內容，請聯系我們jiasou666@gmail.com 處理，核實后本網站將在24小時內刪除侵權內容。