文章目錄

• 0 寫在前面
• 1 ndarray：一種多維數組對象
• • 1.1 numpy.random.randn(d0,d1, ...,dn) 函數介紹
  • 1.2 numpy.random.seed() 函數介紹
  • 1.3 創建 ndarray
  • • 1.3.1 np.array()
    • 1.3.2 np.zeros()和np.ones()
    • 1.3.3 np.empty()
    • 1.3.4 np.arange()
    • 1.3.5 函數總結
  • 1.4 ndarray的數據類型
  • • 1.4.1 np.astype()
• 2 NumPy數組的運算
• • 2.1 基本的索引和切片
  • 2.2 切片索引
• 3 布爾型索引
• 4 花式索引
• 5 數組轉置和軸對換

0 寫在前面

1. ndarray，是一個具有矢量算術運算和復雜廣播能力的快速，且節省空間的多維數組；
2. 搞明白具體的性能差距，考察一個包含一百萬整數的數組，和一個等價的Python列表。
3. ndarray，是一個通用的同構數據多維容器，也就是說，所有的元素必須是相同類型的。每一個數組都有一個shape（表示各維度大小的元組）和一個dtype（一個用於說明數組數據類型的對象）

import numpy as np
my_arr = np.arange(1000000)
my_list = list(range(1000000))
%time for _ in range(10): my_arr2 = my_arr * 2
Wall time: 21.7 ms
%time for _ in range(10): my_list2 = [x * 2 for x in my_list]
Wall time: 855 ms

• 基於NumPy的算法要比純Python快10到100倍（甚至更快），並且使用的內存更少。

1 ndarray：一種多維數組對象

1.1 numpy.random.randn(d0,d1, …,dn) 函數介紹

• rand() 函數，會根據指定的維度，生成[0,1) 之間的數據；
• dn 表示每個維度
• 返回值為指定維度的 array

代碼：

import numpy as np
data = np.random.randn(2, 3)
print(data)

輸出：

[[-0.98166625 -0.75308133 1.02950877]
[ 0.92072303 -0.98693389 -0.68642432]]

1.2 numpy.random.seed() 函數介紹

• 使得隨機數據可預測
• 當設置相同的seed時，那麼每次生成的隨機數相同；如果不設置seed，則每次會生成不同的隨機數。

1.3 創建 ndarray

1.3.1 np.array()

• 創建數組最簡單的辦法就是使用array函數。它接受一切序列型的對象（包括其他數組），然後返回一個NumPy數組。
• 以一個列表的轉換為例：

In [19]: data1 = [6, 7.5, 8, 0, 1]
In [20]: arr1 = np.array(data1)
In [21]: arr1
Out[21]: array([ 6. , 7.5, 8. , 0. , 1. ])

• 嵌套序列（比如由一組等長列表組成的列表）將會被轉換為一個多維數組：

In [22]: data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
In [23]: arr2 = np.array(data2)
In [24]: arr2
Out[24]:
array([[1, 2, 3, 4],
[5, 6, 7, 8]])

• Numpy數組有兩個屬性：ndim和shape

In [22]: data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
In [23]: arr2 = np.array(data2)
In [24]: arr2
Out[24]:
array([[1, 2, 3, 4],
[5, 6, 7, 8]])
In [25]: arr2.ndim
Out[25]: 2
In [26]: arr2.shape
Out[26]: (2, 4)

1.3.2 np.zeros()和np.ones()

• 需要傳入的是，創建數組的指定長度或形狀。

In [22]: data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
In [23]: arr2 = np.array(data2)
In [24]: arr2
Out[24]:
array([[1, 2, 3, 4],
[5, 6, 7, 8]])

1.3.3 np.empty()

• empty可以創建一個沒有任何具體值的數組，因此只需要傳入一個表示形狀的元組即可。

In [31]: np.empty((2, 3, 2))
Out[31]:
array([[[ 0., 0.],
[ 0., 0.],
[ 0., 0.]],
[[ 0., 0.],
[ 0., 0.],
[ 0., 0.]]])

注意：認為np.empty會返回全0數組的想法是不安全的。很多情況下（如前所示），它返回的都是一些未初始化的垃圾值。

1.3.4 np.arange()

• arange是Python內置函數range的數組版：

In [32]: np.arange(15)
Out[32]: array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14])

1.3.5 函數總結

由於NumPy關注的是數值計算，因此，如果沒有特別指定，數據類型基本都是float64（浮點數）。

1.4 ndarray的數據類型

前面說了，ndarray默認是 float64

但是可以用dtype進行指定：

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')

1.4.1 np.astype()

• 你可以通過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)

2 NumPy數組的運算

• 數組很重要，因為它使你不用編寫循環，也可以對數據執行批量運算。

• 大小相等的數組，之間的任何算術運算，都會應用到元素級。

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)

2.1 基本的索引和切片

• 簡單用法如下：

可以發現，如果將一個標量賦給一個切片的話，那麼這一段的切片內容都會發生改變；
而且數組切片是原始數組視圖，在視圖上的任何修改都會反映到原始數組上。

In [60]: arr = np.arange(10)
In [61]: arr
Out[61]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
In [62]: arr[5]
Out[62]: 5
In [63]: arr[5:8]
Out[63]: array([5, 6, 7])
In [64]: arr[5:8] = 12
In [65]: arr
Out[65]: array([ 0, 1, 2, 3, 4, 12, 12, 12, 8, 9])

如果不想對原數組進行操作，那麼幾一定要明確的進行復制操作。如：arr[5：8].copy()

• 在一個二維數組中，各索引位置上的元素不再是標量而是一維數組。

In [72]: arr2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
In [73]: arr2d[2]
Out[73]: array([7, 8, 9])

• 可以傳入一個以逗號隔開的索引列表來選取單個元素：

In [74]: arr2d[0][2]
Out[74]: 3
In [75]: arr2d[0, 2]
Out[75]: 3

2.2 切片索引

• ndarry的切片語法，跟Python列表的一維數組差不多：
• 注意 arr[1:6] 是左閉右開的。

In [88]: arr
Out[88]: array([ 0, 1, 2, 3, 4, 64, 64, 64, 8, 9])
In [89]: arr[1:6]
Out[89]: array([ 1, 2, 3, 4, 64])

• 對於之前的二維數組arr2d，其切片方式稍顯不同：
• 可以看出，這裡是沿著第0軸切片的，也就是說選取arr2d的前兩行。

In [90]: arr2d
Out[90]:
array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
In [91]: arr2d[:2]
Out[91]:
array([[1, 2, 3],
[4, 5, 6]])

• 傳入多個切片：

In [92]: arr2d[:2, 1:]
Out[92]:
array([[2, 3],
[5, 6]])

• 將整數索引和切片混合，可以得到低維度的切片：

In [93]: arr2d[1, :2]
Out[93]: array([4, 5])

In [94]: arr2d[:2, 2]
Out[94]: array([3, 6])

• 只有冒號 ： 表示選取整個軸。

In [95]: arr2d[:, :1]
Out[95]:
array([[1],
[4],
[7]])

3 布爾型索引

• 例子：首先定義一個存儲姓名的數組（7個名字），然後初始化一個7行的數組，每一行表示一個名字。

In [98]: names = np.array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'])
In [99]: data = np.random.randn(7, 4)
In [100]: names
Out[100]:
array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'],
dtype='<U4')
In [101]: data
Out[101]:
array([[ 0.0929, 0.2817, 0.769 , 1.2464],
[ 1.0072, -1.2962, 0.275 , 0.2289],
[ 1.3529, 0.8864, -2.0016, -0.3718],
[ 1.669 , -0.4386, -0.5397, 0.477 ],
[ 3.2489, -1.0212, -0.5771, 0.1241],
[ 0.3026, 0.5238, 0.0009, 1.3438],
[-0.7135, -0.8312, -2.3702, -1.8608]])

• 現在的需求是，根據Bob對應在數組中的索引，選出對應的隨機數據的對應行的數據。
• 可以看到，names == 'Bob' 會生成一個bool類型的數組。

In [102]: names == 'Bob'
Out[102]: array([ True, False, False, True, False, False, False], dtype=bool)

• 寫出來的代碼就如下所示：

In [103]: data[names == 'Bob']
Out[103]:
array([[ 0.0929, 0.2817, 0.769 , 1.2464],
[ 1.669 , -0.4386, -0.5397, 0.477 ]])

• 選取了names == 'Bob’的行，並索引了列：

In [104]: data[names == 'Bob', 2:]
Out[104]:
array([[ 0.769 , 1.2464],
[-0.5397, 0.477 ]])
In [105]: data[names == 'Bob', 3]
Out[105]: array([ 1.2464, 0.477 ])

• 選取這三個名字中的兩個需要組合應用多個布爾條件，使用&（和）、|（或）之類的布爾算術運算符即可：

In [110]: mask = (names == 'Bob') | (names == 'Will')
In [111]: mask
Out[111]: array([ True, False, True, True, True, False, False], dtype=bool)
In [112]: data[mask]
Out[112]:
array([[ 0.0929, 0.2817, 0.769 , 1.2464],
[ 1.3529, 0.8864, -2.0016, -0.3718],
[ 1.669 , -0.4386, -0.5397, 0.477 ],
[ 3.2489, -1.0212, -0.5771, 0.1241]])

• 通過布爾型數組設置值是一種經常用到的手段。為了將data中的所有負值都設置為0，我們只需：

In [113]: data[data < 0] = 0
In [114]: data
Out[114]:
array([[ 0.0929, 0.2817, 0.769 , 1.2464],
[ 1.0072, 0. , 0.275 , 0.2289],
[ 1.3529, 0.8864, 0. , 0. ],
[ 1.669 , 0. , 0. , 0.477 ],
[ 3.2489, 0. , 0. , 0.1241],
[ 0.3026, 0.5238, 0.0009, 1.3438],
[ 0. , 0. , 0. , 0. ]])

• 通過一維布爾數組設置 整行或整列的值也很簡單：

In [115]: data[names != 'Joe'] = 7
In [116]: data
Out[116]:
array([[ 7. , 7. , 7. , 7. ],
[ 1.0072, 0. , 0.275 , 0.2289],
[ 7. , 7. , 7. , 7. ],
[ 7. , 7. , 7. , 7. ],
[ 7. , 7. , 7. , 7. ],
[ 0.3026, 0.5238, 0.0009, 1.3438],
[ 0. , 0. , 0. , 0. ]])

4 花式索引

花式索引，就是利用傳入整數數組進行索引。

In [117]: arr = np.empty((8, 4))
In [118]: for i in range(8):
.....: arr[i] = i
In [119]: arr
Out[119]:
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即可：

In [120]: arr[[4, 3, 0, 6]]
Out[120]:
array([[ 4., 4., 4., 4.],
[ 3., 3., 3., 3.],
[ 0., 0., 0., 0.],
[ 6., 6., 6., 6.]])

• 使用負數索引將會從末尾開始選取行：

In [121]: arr[[-3, -5, -7]]
Out[121]:
array([[ 5., 5., 5., 5.],
[ 3., 3., 3., 3.],
[ 1., 1., 1., 1.]])

• 如果傳入多個索引數組，返回的還是一個一維數組。

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

In [122]: arr = np.arange(32).reshape((8, 4))
In [123]: arr
Out[123]:
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]])
In [124]: arr[[1, 5, 7, 2], [0, 3, 1, 2]]
Out[124]: array([ 4, 23, 29, 10])

5 數組轉置和軸對換

• 轉置返回的是源數據的視圖。
• 數組不僅有transpose方法，還有一個特殊的 T 屬性。

In [126]: arr = np.arange(15).reshape((3, 5))
In [127]: arr
Out[127]:
array([[ 0, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9],
[10, 11, 12, 13, 14]])
In [128]: arr.T
Out[128]:
array([[ 0, 5, 10],
[ 1, 6, 11],
[ 2, 7, 12],
[ 3, 8, 13],
[ 4, 9, 14]])

• 在進行矩陣計算時，經常需要這個操作。比如說利用 np.dot 計算矩陣內積。

In [129]: arr = np.random.randn(6, 3)
In [130]: arr
Out[130]:
array([[-0.8608, 0.5601, -1.2659],
[ 0.1198, -1.0635, 0.3329],
[-2.3594, -0.1995, -1.542 ],
[-0.9707, -1.307 , 0.2863],
[ 0.378 , -0.7539, 0.3313],
[ 1.3497, 0.0699, 0.2467]])
In [131]: np.dot(arr.T, arr)
Out[131]:
array([[ 9.2291, 0.9394, 4.948 ],
[ 0.9394, 3.7662, -1.3622],
[ 4.948 , -1.3622, 4.3437]])

• 簡單的轉置可以使用.T，它其實就是進行軸對換而已。
• ndarray還有一個swapaxes方法，它需要接受一對軸編號。也是返回的源數據的視圖。

In [135]: arr
Out[135]:
array([[[ 0, 1, 2, 3],
[ 4, 5, 6, 7]],
[[ 8, 9, 10, 11],
[12, 13, 14, 15]]])
In [136]: arr.swapaxes(1, 2)
Out[136]:
array([[[ 0, 4],
[ 1, 5],
[ 2, 6],
[ 3, 7]],
[[ 8, 12],
[ 9, 13],
[10, 14],
[11, 15]]])