NumPy基本介紹
NumPy（Numerical Python）是高性能科學計算和數據分析的基礎包。其提供了以下基本功能：
- ndarray：一種具有矢量算術運算和復雜廣播能力的快速且節省空間的多維數組。
- 對整體數組進行快速的標准數學運算。
- 線性代數、隨級數生成以及傅里葉變換功能。
- 提供簡易的C API，可方便的將數據傳遞給由低級語言編寫的外部庫，外部庫也能以NumPy數組的形勢將數據返回給Python。
對於數據分析，需要關心以下幾點：
- 數據整理和清理、子集構造和過濾、轉換等快速的矢量化數組運算。
- 常用數組算法，如排序、唯一化、集合運算等。
- 高效的描述統計和數據聚合/摘要運算。
官方說明文檔：What is NumPy? — NumPy v1.21 Manual
以下代碼的前提：import numpy as np
1 NumPy的ndarray：一種多維數組對象
官方API使用說明：The N-dimensional array (ndarray) — NumPy v1.21 Manual
ndarray（N-dimensional array，N維數組對象）：是一個快速靈活的大數據集容器。可以利用這種數組對整塊數據執行一些數學運算，其語法跟標量元素之間的運算一樣。
1 >>> from numpy import array
2 >>> data = array([[0.926, -0.246, -0.8856], [0.5639, 0.2379, 0.9104]])
3 >>> print (data * 10)
4 [[ 9.26 -2.46 -8.856]
5 [ 5.639 2.379 9.104]]
6 >>> data.shape
7 (2, 3)
8 >>> data.dtype
9 dtype('float64')
10 >>>
ndarray是一個通用的同構數據多維數組，也就是所，其中的所有元素必須是相同類型的。每個數組都有一個shape（一個表示各維度大小的元組）和一個dtype（一個用於說明數組數據類型的對象）。
1.1 創建ndarray
創建數組最簡單的辦法是使用array()函數。它接受一切序列型的對象（包括其他數組），然后產生一個新的含有傳入數據的NumPy數組。嵌套序列將會被轉換為一個多維數組。
1 >>> from numpy import array
2 >>> data1 = [6, 7.5, 9, 0, 1]
3 >>> arr1 = array(data1)
4 >>> arr1
5 array([6. , 7.5, 9. , 0. , 1. ])
6 >>> data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
7 >>> arr2 = array(data2)
8 >>> arr2
9 array([[1, 2, 3, 4],
10 [5, 6, 7, 8]])
11 >>> arr2.ndim
12 2
13 >>> arr2.shape
14 (2, 4)
15 >>>
np.array之外，還有一些函數也可以創建數組，比如zeros和ones分別創建指定長度或形狀的全0或全1數組。empty可以創建一個沒有任何具體值的數組，返回的是一些未初始化的垃圾值。
1 >>> import numpy as np
2 >>> np.zeros(10)
3 array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])
4 >>> np.zeros((2, 3))
5 array([[0., 0., 0.],
6 [0., 0., 0.]])
7 >>> np.ones(5)
8 array([1., 1., 1., 1., 1.])
9 >>> np.ones((2, 3))
10 array([[1., 1., 1.],
11 [1., 1., 1.]])
12 >>> np.empty((2, 3, 2))
13 array([[[6.23042070e-307, 3.56043053e-307],
14 [1.37961641e-306, 6.23039354e-307],
15 [6.23053954e-307, 9.34609790e-307]],
16
17 [[8.45593934e-307, 9.34600963e-307],
18 [1.86921143e-306, 6.23061763e-307],
注：np.empty任務返回全0數組是不安全的，它返回的都是一些未初始化的垃圾值。
arange()是python內置函數range的數組版本。
1 >>> np.arange(10)
2 array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
下表是數組創建函數：
| 函數 | 說明 |
|---|---|
| array | 將輸入數據（列表、元組、數組或其他序列類型）轉換為ndarray |
| arange | 類似於內置的range，但返回的是一個ndarray而不是列表 |
| ones、ones_like | 根據指定的形狀和dtype創建一個全1數組。ones_like以另一個數組為參數，並根據其形狀和dtype創建一個全1數組 |
| zeros、zeros_like | 類似於ones和ones_like，只不過產生的是全0數組 |
| empty、empty_like | 創建新數組，只分配內存空間但不填充任何值，返回的數值都是一些垃圾值 |
| eye、identity | 創建一個正方的NxN單位矩陣（對角線為1，其余為0） |
1.2 ndarray的數據類型
dtype（數據類型）是一個特殊的對象，它含有ndarray將一塊內存解釋為特定數據類型所需要的信息。
1 >>> arr1 = np.array([1, 2, 3], dtype=np.float64)
2 >>> arr2 = np.array([1, 2, 3], dtype=np.int32)
3 >>> arr1.dtype
4 dtype('float64')
5 >>> arr2.dtype
6 dtype('int32')
NumPy的數據類型：
| 類型 | 類型代碼 | 說明 |
|---|---|---|
| int8、uint8 | i1、u1 | 有符號和無符號的8位（1個字節）整型 |
| int16、uint16 | i2、u2 | 有符號和無符號的16位（2個字節）整型 |
| int32、uint32 | i4、u4 | 有符號和無符號的32位（4個字節）整型 |
| int64、uint64 | i8、u8 | 有符號和無符號的64位（8個字節）整型 |
| float16 | f2 | 半精度浮點數 |
| float32 | f4或f | 標准的單精度浮點數，與C的float兼容 |
| float64 | f8或d | 標准的雙精度浮點數，與C的double和python的float對象兼容 |
| float128 | f16或g | 擴展精度浮點數 |
| complex64、complex128、complex256 | c8、c16、c32 | 分別用兩個32位、64位或128位浮點數表示的復數 |
| bool | ? | 存儲True和Fasle值的布爾類型 |
| object | O | python對象類型 |
| string_ | S | 固定長度的字符串類型（每個字符1個字節）。例如要創建一個長度位10的字符串，應使用S10 |
| unicode_ | U | 固定長度的Unicode類型（字節數由平台決定）跟字符串的定義方式一樣 |
可通過ndarray的astype方法顯式轉換其dtype。
1 >>> arr = np.array([1, 2, 3, 4, 5])
2 >>> arr.dtype
3 dtype('int32')
4 >>> float_arr = arr.astype(np.float64)
5 >>> float_arr.dtype
6 dtype('float64')
如果將浮點型轉換為整型，則小數部分將會被截斷。
1 >>> arr = np.array([1.2, 2.3, 3.4])
2 >>> arr.astype(np.int32)
3 array([1, 2, 3])
如果某字符串表示的全是數字，可以用astype將其轉換為數值形式。
1 >>> num_strings = np.array(['1.2', '2.2'], dtype=np.string_)
2 >>> num_strings.astype(float)
3 array([1.2, 2.2])
1.3 數組和標量之間的運算
數組不需要編寫循環即可對數據執行批量處理，這通常叫做矢量化（vectorization）。大小相等的數組之間的任何算術運算都會將運算應用到元素級。
1 >>> arr = np.array([[1., 2., 3.], [4., 5., 6.]])
2 >>> arr
3 array([[1., 2., 3.],
4 [4., 5., 6.]])
5 >>> arr * arr
6 array([[ 1., 4., 9.],
7 [16., 25., 36.]])
8 >>> arr - arr
9 array([[0., 0., 0.],
10 [0., 0., 0.]])
11 >>> 1 / arr
12 array([[1. , 0.5 , 0.33333333],
13 [0.25 , 0.2 , 0.16666667]])
14 >>>
不同大小的數組之間的運算叫做廣播。
1.4 基本的索引和切片
（1）一維數組和python列表功能類似：
1 >>> arr = np.arange(10)
2 >>> arr
3 array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
4 >>> arr[5]
5 5
6 >>> arr[5:8]
7 array([5, 6, 7])
8 >>> arr[5:8] = 12 # 自動“廣播”到整個選區
9 >>> arr
10 array([ 0, 1, 2, 3, 4, 12, 12, 12, 8, 9])
11 >>>
跟列表的最重要的區別在於：數組切片是原始數組的視圖，這意味着數據不會被復制，視圖上的任何修改都會字節反映到源數組上。
1 >>> arr
2 array([ 0, 1, 2, 3, 4, 12, 12, 12, 8, 9])
3 >>> arr_slice = arr[5:8]
4 >>> arr_slice[1] = 12345
5 >>> arr
6 array([ 0, 1, 2, 3, 4, 12, 12345, 12, 8,
7 9])
8 >>> arr_slice[:] = 64
9 >>> arr
10 array([ 0, 1, 2, 3, 4, 64, 64, 64, 8, 9])
（2）高維度數組
在一個二維數組中，各索引位置上的元素不再是標量而是一維數組。
1 >>> arr2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
2 >>> arr2d[2]
3 array([7, 8, 9])
4 >>> arr2d[0][2]
5 3
6 >>> arr2d[0, 2] #0行第二個元素
7 3
在高維數組中，如果省略了后面的索引，則返回對象會是一個維度低一點的ndarray（它含有高一級維度上的所有數據）。
1 >>> arr3d = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])
2 >>> arr3d
3 array([[[ 1, 2, 3],
4 [ 4, 5, 6]],
5
6 [[ 7, 8, 9],
7 [10, 11, 12]]])
8 >>> arr3d[0]
9 array([[1, 2, 3],
10 [4, 5, 6]])
11 >>> old_values = arr3d[0].copy()
12 >>> arr3d[0] = [42]
13 >>> arr3d
14 array([[[42, 42, 42],
15 [42, 42, 42]],
16
17 [[ 7, 8, 9],
18 [10, 11, 12]]])
19 >>> arr3d[0] = old_values
20 >>> arr3d
21 array([[[ 1, 2, 3],
22 [ 4, 5, 6]],
23
24 [[ 7, 8, 9],
25 [10, 11, 12]]])
26 >>> arr3d[1, 0]
27 array([7, 8, 9])
28 >>> arr3d[1, 0, 1]
29 8
1.5 切片索引
ndarray的切片語法和python列表的一維對象類似。
高維度可以在一個或多個軸上進行切片，也可以跟整數索引混合使用。高維數組中切片是沿着一個軸向選取元素的。
1 >>> arr
2 array([ 0, 1, 2, 3, 4, 64, 64, 64, 8, 9])
3 >>> arr[1:6]
4 array([ 1, 2, 3, 4, 64])
5 >>> arr2d
6 array([[1, 2, 3],
7 [4, 5, 6],
8 [7, 8, 9]])
9 >>> arr2d[:2]
10 array([[1, 2, 3],
11 [4, 5, 6]])
12 >>> arr2d[:2, 1:]
13 array([[2, 3],
14 [5, 6]])
15 >>> arr2d[1, :2]
16 array([4, 5])
17 >>> arr2d[2, :1]
18 array([7])
19 >>> arr2d[:, :1]
20 array([[1],
21 [4],
22 [7]])
二維數組切片示例如下：
>>> x = array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
>>> x
array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
>>> x[:2, 1:]
array([[2, 3],
[5, 6]])
>>> x[:2, 1:].shape
(2, 2)
>>> x[2]
array([7, 8, 9])
>>> x[2, :]
array([7, 8, 9])
>>> x[2:, :]
array([[7, 8, 9]])
>>> x[:, :2]
array([[1, 2],
[4, 5],
[7, 8]])
>>> x[1, :2]
array([4, 5])
>>> x[1:2, :2]
array([[4, 5]])
>>>
1.6 布爾型索引
使用一個例子進行說明：假設有一個用於存儲數據的數組和一個存儲姓名的數組。
1 >>> names = np.array(['bob', 'joe', 'will', 'bob', 'will', 'joe', 'joe'])
2 >>> data = np.random.randn(7, 4) #正態分布的隨機數據
3 >>> names
4 array(['bob', 'joe', 'will', 'bob', 'will', 'joe', 'joe'], dtype='<U4')
5 >>> data
6 array([[-0.3246959 , 0.03063124, -0.07431197, -0.9655177 ],
7 [ 0.04598137, -0.62187278, 0.46909509, -0.26366901],
8 [-1.52794074, 1.08687233, -1.84679164, 0.65460423],
9 [ 0.51445349, -0.27982821, 0.81788033, 0.82924586],
10 [ 0.32757133, -0.82471501, -2.76623431, -0.52545958],
11 [ 1.78816606, 0.12328895, 0.53822894, 1.58932956],
12 [ 0.55363975, 0.17329085, 0.03561944, -0.79536074]])
13 >>>
14 >>> names == 'bob' #數組的比較運算是矢量化的
15 array([ True, False, False, True, False, False, False])
16 >>> data = np.random.randn(7, 4)
17 >>> data[names == 'bob'] #布爾型數組用於數組索引
18 array([[ 0.90834313, -0.11373769, 0.13405157, 0.14890507],
19 [ 1.23918751, -0.25025211, -0.26848528, -0.19568496]])
20 >>> data
21 array([[ 0.90834313, -0.11373769, 0.13405157, 0.14890507],
22 [-1.43803588, 0.27400888, 0.95506627, -1.68159653],
23 [-1.11827716, -0.36084883, 1.59143787, 1.33349614],
24 [ 1.23918751, -0.25025211, -0.26848528, -0.19568496],
25 [-2.37793176, -0.11967421, -0.25341328, -0.15386212],
26 [-0.03628671, -1.3188123 , 0.17480482, -0.93195373],
27 [-0.55657692, -0.12547058, -0.31571666, 0.1365729 ]])
28 >>> data[names == 'bob', 2:] #可將布爾類型數組跟切片混合使用
29 array([[ 0.13405157, 0.14890507],
30 [-0.26848528, -0.19568496]])
31 >>> data[names == 'bob', 3]
32 array([ 0.14890507, -0.19568496])
33 >>> names != 'bob' #也可使用!=
34 array([False, True, True, False, True, True, True])
35 >>> data[~(names == 'bob')]
36 array([[-1.43803588, 0.27400888, 0.95506627, -1.68159653],
37 [-1.11827716, -0.36084883, 1.59143787, 1.33349614],
38 [-2.37793176, -0.11967421, -0.25341328, -0.15386212],
39 [-0.03628671, -1.3188123 , 0.17480482, -0.93195373],
40 [-0.55657692, -0.12547058, -0.31571666, 0.1365729 ]])
41 >>> mask = (names == 'bob') | (names == 'will')
42 >>> mask
43 array([ True, False, True, True, True, False, False])
44 >>> data[mask]
45 array([[ 0.90834313, -0.11373769, 0.13405157, 0.14890507],
46 [-1.11827716, -0.36084883, 1.59143787, 1.33349614],
47 [ 1.23918751, -0.25025211, -0.26848528, -0.19568496],
48 [-2.37793176, -0.11967421, -0.25341328, -0.15386212]])
49 >>> data[data < 0] = 0 #通過布爾值設置值
50 >>> data
51 array([[0.90834313, 0. , 0.13405157, 0.14890507],
52 [0. , 0.27400888, 0.95506627, 0. ],
53 [0. , 0. , 1.59143787, 1.33349614],
54 [1.23918751, 0. , 0. , 0. ],
55 [0. , 0. , 0. , 0. ],
56 [0. , 0. , 0.17480482, 0. ],
57 [0. , 0. , 0. , 0.1365729 ]])
58 >>> data[names != 'joe'] = 7
59 > >>> arr = np.empty((8, 4))
60 >>> for i in range(8): arr[i] = i
61 ...
62 >>> arr
63 array([[0., 0., 0., 0.],
64 [1., 1., 1., 1.],
65 [2., 2., 2., 2.],
66 [3., 3., 3., 3.],
67 [4., 4., 4., 4.],
68 [5., 5., 5., 5.],
69 [6., 6., 6., 6.],
70 [7., 7., 7., 7.]])
71 >>> arr[[4, 3, 0, 6]]
72 array([[4., 4., 4., 4.],
73 [3., 3., 3., 3.],
74 [0., 0., 0., 0.],
75 [6., 6., 6., 6.]])
76 >>> arr[[-3, -5, -7]]
77 array([[5., 5., 5., 5.],
78 [3., 3., 3., 3.],
79 [1., 1., 1., 1.]])>> data
80 array([[7. , 7. , 7. , 7. ],
81 [0. , 0.27400888, 0.95506627, 0. ],
82 [7. , 7. , 7. , 7. ],
83 [7. , 7. , 7. , 7. ],
84 [7. , 7. , 7. , 7. ],
85 [0. , 0. , 0.17480482, 0. ],
86 [0. , 0. , 0. , 0.1365729 ]])
87 >>>
1.7 花式索引
花式索引（Fancy indexing）是一個NumPy術語，它指的是利用整數數組進行索引。
1 >>> arr = np.empty((8, 4))
2 >>> for i in range(8): arr[i] = i
3 ...
4 >>> arr
5 array([[0., 0., 0., 0.],
6 [1., 1., 1., 1.],
7 [2., 2., 2., 2.],
8 [3., 3., 3., 3.],
9 [4., 4., 4., 4.],
10 [5., 5., 5., 5.],
11 [6., 6., 6., 6.],
12 [7., 7., 7., 7.]])
13 >>> arr[[4, 3, 0, 6]] #以特定順序選取行子繼，只需要傳入一個用於指定順序的整數列表或ndarray
14 array([[4., 4., 4., 4.],
15 [3., 3., 3., 3.],
16 [0., 0., 0., 0.],
17 [6., 6., 6., 6.]])
18 >>> arr[[-3, -5, -7]] #使用負數將從末尾開始選取行
19 array([[5., 5., 5., 5.],
20 [3., 3., 3., 3.],
21 [1., 1., 1., 1.]])
一次傳入多個索引數組有有一點特別，它返回的是一個一維數組，其中的元素對應各個索引元組。
1 >>> arr = np.arange(32).reshape((8, 4))
2 >>> arr
3 array([[ 0, 1, 2, 3],
4 [ 4, 5, 6, 7],
5 [ 8, 9, 10, 11],
6 [12, 13, 14, 15],
7 [16, 17, 18, 19],
8 [20, 21, 22, 23],
9 [24, 25, 26, 27],
10 [28, 29, 30, 31]])
11 >>> arr[[1, 5, 7, 2], [0, 3, 1, 2]] #最終選取的元素是(1, 0) (5, 3) (7, 1) (2, 2)
12 array([ 4, 23, 29, 10])
上面的代碼沒有達到我們想要的效果，我們想要的是選取矩陣的行列子集應該是矩陣區域的形式才對。
1 >>> arr
2 array([[ 0, 1, 2, 3],
3 [ 4, 5, 6, 7],
4 [ 8, 9, 10, 11],
5 [12, 13, 14, 15],
6 [16, 17, 18, 19],
7 [20, 21, 22, 23],
8 [24, 25, 26, 27],
9 [28, 29, 30, 31]])
10 >>> arr[[1, 5, 7, 2]][:, [0, 3, 1, 2]]
11 array([[ 4, 7, 5, 6],
12 [20, 23, 21, 22],
13 [28, 31, 29, 30],
14 [ 8, 11, 9, 10]])
另一個方式是使用np.ix_函數，它可以將兩個一維整型數組轉換為一個用於選取方形區域的索引器。
1 >>> arr
2 array([[ 0, 1, 2, 3],
3 [ 4, 5, 6, 7],
4 [ 8, 9, 10, 11],
5 [12, 13, 14, 15],
6 [16, 17, 18, 19],
7 [20, 21, 22, 23],
8 [24, 25, 26, 27],
9 [28, 29, 30, 31]])
10 >>> arr[np.ix_([1, 5, 7, 2], [0, 3, 1, 2])]
11 array([[ 4, 7, 5, 6],
12 [20, 23, 21, 22],
13 [28, 31, 29, 30],
14 [ 8, 11, 9, 10]])
花式索引跟切片不一樣，它總是將數據復制到新數組中。
1.8 數組轉置與軸對稱
轉置（transpose）是重塑的一種特殊方式，它返回的是源數據的視圖。數組還有一個特殊的T屬性（類似於矩陣的轉置）。
1 >>> arr = np.arange(15).reshape((3, 5))
2 >>> arr
3 array([[ 0, 1, 2, 3, 4],
4 [ 5, 6, 7, 8, 9],
5 [10, 11, 12, 13, 14]])
6 >>> arr.T
7 array([[ 0, 5, 10],
8 [ 1, 6, 11],
9 [ 2, 7, 12],
10 [ 3, 8, 13],
11 [ 4, 9, 14]])
np.dot可計算矩陣內積XTX。
1 >>> arr = np.array([[1, 2, 3], [4, 5, 6]])
2 >>> arr
3 array([[1, 2, 3],
4 [4, 5, 6]])
5 >>> np.dot(arr.T, arr)
6 array([[17, 22, 27],
7 [22, 29, 36],
8 [27, 36, 45]])
9 >>>