NumPy（Numeric Python）是一個用python實作的科學計算的擴展程式庫，包括：

1. 一個強大的N維陣列物件Array；
2. 比較成熟的（廣播）函式庫；
3. 用于整合C/C++和Fortran代碼的工具包；
4. 實用的線性代數、傅里葉變換和亂數生成函式，numpy和稀疏矩陣運算包scipy配合使用更加方便，

NumPy 提供了許多高級的數值編程工具，如：矩陣資料型別、矢量處理，以及精密的運算庫，專為進行嚴格的數字處理而產生，多為很多大型金融公司使用，以及核心的科學計算組織如：Lawrence Livermore，NASA用其處理一些本來使用C++，Fortran或Matlab等所做的任務，

1.Numpy基本操作

import numpy as np

1.1 串列轉為矩陣

array = np.array([
    [1,3,5],
    [4,6,9]
])

print(array)
[[1 3 5]
 [4 6 9]]

1.2 維度

print('number of dim:', array.ndim)
number of dim: 2

1.3 行數和列數

print('shape:',array.shape)
print('shape:',array.shape[0])
print('shape:',array.shape[1])
shape: (2, 3)
shape: 2
shape: 3

1.4 元素個數

print('size:',array.size)
size: 6

2.Numpy創建array

2.1 一維array創建

# 一維array
a = np.array([2,23,4], dtype=np.int32) # np.int默認為int32
print(a)
print(a.dtype)
[ 2 23  4]
int32

2.2 多維array創建

# 多維array
a = np.array([[2,3,4],
              [3,4,5]])
print(a) # 生成2行3列的矩陣
[[2 3 4]
 [3 4 5]]

2.3 創建全零陣列

a = np.zeros((3,4))
print(a) # 生成3行4列的全零矩陣
[[0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]]

2.4 創建全1資料

# 創建全一資料，同時指定資料型別
a = np.ones((3,4),dtype=np.int)
print(a)
[[1 1 1 1]
 [1 1 1 1]
 [1 1 1 1]]

2.5 創建全空陣列

# 創建全空陣列，其實每個值都是接近于零的數
a = np.empty((3,4))
print(a)
[[0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]]

2.6 創建連續陣列

# 創建連續陣列
a = np.arange(10,21,2) # 10-20的資料，步長為2
print(a)
[10 12 14 16 18 20]

2.7 reshape操作

# 使用reshape改變上述資料的形狀
b = a.reshape((2,3))
print(b)
[[10 12 14]
 [16 18 20]]

2.8 創建連續型資料

# 創建線段型資料
a = np.linspace(1,10,20) # 開始端1，結束端10，且分割成20個資料，生成線段
print(a)
[ 1.          1.47368421  1.94736842  2.42105263  2.89473684  3.36842105
  3.84210526  4.31578947  4.78947368  5.26315789  5.73684211  6.21052632
  6.68421053  7.15789474  7.63157895  8.10526316  8.57894737  9.05263158
  9.52631579 10.        ]

2.9 linspace的reshape操作

# 同時也可以reshape
b = a.reshape((5,4))
print(b)
[[ 1.          1.47368421  1.94736842  2.42105263]
 [ 2.89473684  3.36842105  3.84210526  4.31578947]
 [ 4.78947368  5.26315789  5.73684211  6.21052632]
 [ 6.68421053  7.15789474  7.63157895  8.10526316]
 [ 8.57894737  9.05263158  9.52631579 10.        ]]

3.Numpy基本運算

3.1 一維矩陣運算

# 一維矩陣運算
a = np.array([10,20,30,40])
b = np.arange(4)
print(a,b)
[10 20 30 40] [0 1 2 3]

c = a - b
print(c)
[10 19 28 37]

print(a*b) 
print(a.dot(b))# 若用a.dot(b),則為點乘，各維之和
[  0  20  60 120]
200

# 在Numpy中，想要求出矩陣中各個元素的乘方需要依賴雙星符號 **，以二次方舉例，即：
c = b**2
print(c)
[0 1 4 9]

# Numpy中具有很多的數學函式工具
c = np.sin(a)
print(c)
[-0.54402111  0.91294525 -0.98803162  0.74511316]

# 布爾型
print(b<2)
[ True  True False False]

a = np.array([1,1,4,3])
b = np.arange(4)
print(a==b)
[False  True False  True]

3.2 多維矩陣運算

a = np.array([[1,1],[0,1]])
b = np.arange(4).reshape((2,2))
print(a)
[[1 1]
 [0 1]]
print(b)
[[0 1]
 [2 3]]

# 多維度矩陣乘法
# 第一種乘法方式:
c = a.dot(b)
print(c)
[[2 4]
 [2 3]]

# 第二種乘法:
c = np.dot(a,b)
print(c)
[[2 4]
 [2 3]]
# 多維矩陣乘法不能直接使用'*'號

a = np.random.random((2,4))
print(a)
[[0.47963593 0.15801515 0.25886847 0.74290887]
 [0.78781928 0.00950545 0.13431407 0.29972804]]
 
print(np.sum(a))
2.8707952592476946
print(np.sum(a,0))  # 對列求和
[1.26745521 0.1675206  0.39318254 1.04263691]
print(np.sum(a,1))  # 對行求和
[1.63942841 1.23136685]

print(np.min(a))
0.009505447212577067
print(np.max(a))
0.7878192846594083

# 如果你需要對行或者列進行查找運算，就需要在上述代碼中為 axis 進行賦值，
# 當axis的值為0的時候，將會以列作為查找單元，
# 當axis的值為1的時候，將會以行作為查找單元，
print("sum=",np.sum(a,axis=1))
sum= [1.63942841 1.23136685]
print("min=",np.min(a,axis=0))
min= [0.47963593 0.00950545 0.13431407 0.29972804]
print("max=",np.max(a,axis=1))
max= [0.74290887 0.78781928]

3.3 基本計算

A = np.arange(2,14).reshape((3,4))
print(A)
[[ 2  3  4  5]
 [ 6  7  8  9]
 [10 11 12 13]]
 
# 最小元素索引
print(np.argmin(A)) # 0
# 最大元素索引
print(np.argmax(A)) # 11
# 求整個矩陣的均值
print(np.mean(A)) # 7.5
print(np.average(A)) # 7.5
print(A.mean()) # 7.5
# 中位數
print(np.median(A)) # 7.5

# 累加
print(np.cumsum(A))
[ 2  5  9 14 20 27 35 44 54 65 77 90]
# 累差運算
B = np.array([[3,5,9],
              [4,8,10]])
print(np.diff(B))
[[2 4]
 [4 2]]
 
# 回傳陣列a中非零元素的索引值陣列
C = np.array([[0,5,9],
              [4,0,10]])
# 索引值陣列的每一個array均是從一個維度上來描述其索引值，
# 比如，如果a是一個二維陣列，則索引值陣列有兩個array，第一個array從行維度來描述索引值；第二個array從列維度來描述索引值，
print(np.nonzero(B))
(array([0, 0, 0, 1, 1, 1], dtype=int64), array([0, 1, 2, 0, 1, 2], dtype=int64))
print(np.nonzero(C))
(array([0, 0, 1, 1], dtype=int64), array([1, 2, 0, 2], dtype=int64))

# 仿照串列排序
A = np.arange(14,2,-1).reshape((3,4)) # -1表示反向遞減一個步長
print(A)
[[14 13 12 11]
 [10  9  8  7]
 [ 6  5  4  3]]

print(np.sort(A))
[[11 12 13 14]
 [ 7  8  9 10]
 [ 3  4  5  6]]

# 矩陣轉置
print(np.transpose(A))
print(A.T)
[[14 10  6]
 [13  9  5]
 [12  8  4]
 [11  7  3]]

# clip(Array,Array_min,Array_max) 限制范圍函式
# 將Array_min<X<Array_max X表示矩陣A中的數，如果滿足上述關系，則原數不變，
# 否則，如果X<Array_min，則將矩陣中X變為Array_min;
# 如果X>Array_max，則將矩陣中X變為Array_max.
print(np.clip(A,5,9))
[[9 9 9 9]
 [9 9 8 7]
 [6 5 5 5]]

4.Numpy索引與切片

4.1 整數索引和切片的基本使用

A = np.arange(3,15)
print(A)
[ 3  4  5  6  7  8  9 10 11 12 13 14]
# 索引
print(A[3]) # 6

B = A.reshape(3,4)
print(B)
[[ 3  4  5  6]
 [ 7  8  9 10]
 [11 12 13 14]]
print(B[2])
[11 12 13 14]
print(B[0][2]) # 5
print(B[0,2]) # 5

# list切片操作
print(B[1,1:3]) # [8 9] 1:3表示1-2不包含3
for row in B:
    print(row)
[3 4 5 6]
[ 7  8  9 10]
[11 12 13 14]

# 如果要列印列，則進行轉置即可
for column in B.T:
    print(column)
[ 3  7 11]
[ 4  8 12]
[ 5  9 13]
[ 6 10 14]

# 多維轉一維
A = np.arange(3,15).reshape((3,4))
print(A)
[[ 3  4  5  6]
 [ 7  8  9 10]
 [11 12 13 14]]
print(A.flatten())   # flat是一個迭代器，本身是一個object屬性
[ 3  4  5  6  7  8  9 10 11 12 13 14]

切片取值方式（對應顏色是取出來的結果）：

4.2 花式（陣列）索引的基本使用

demo_arr = np.empty((4, 4))               # 創建一個空陣列
print(demo_arr[0])
[6.23042070e-307 1.89146896e-307 1.37961302e-306 1.05699242e-307]

for i in range(4):
    demo_arr[i] = np.arange(i, i + 4)   # 動態地為陣列添加元素
demo_arr
array([[0., 1., 2., 3.],
       [1., 2., 3., 4.],
       [2., 3., 4., 5.],
       [3., 4., 5., 6.]])

demo_arr[[0, 2]]        # 獲取索引為[0,2]的元素(0、2行）
array([[0., 1., 2., 3.],
       [2., 3., 4., 5.]])

demo_arr[[1, 3], [1, 2]]     # 獲取索引為(1,1)和(3,2)的元素
array([2., 5.])

4.3 布爾型

# 存盤學生姓名的陣列
student_name = np.array(['Tom', 'Lily', 'Jack', 'Rose'])
student_name
array(['Tom', 'Lily', 'Jack', 'Rose'], dtype='<U4')
# 存盤學生成績的陣列
student_score = np.array([[79, 88, 80], [89, 90, 92], [83, 78, 85], [78, 76, 80]])
student_score
array([[79, 88, 80],
       [89, 90, 92],
       [83, 78, 85],
       [78, 76, 80]])

# 對student_name和字串“Jack”通過運算子產生一個布爾型陣列
student_name == 'Jack'
array([False, False,  True, False])

# 將布爾陣列作為索引應用于存盤成績的陣列student_score，回傳的資料是True值對應的行
student_score[student_name=='Jack']
array([[83, 78, 85]])
student_score[student_name=='Jack', :1]
array([[83]])

5.Numpy array合并

5.1 陣列合并

A = np.array([1,1,1])
B = np.array([2,2,2])
# vertical stack 上下合并,對括號的兩個整體操作，
C = np.vstack((A,B)) 
print(C)  
[[1 1 1]
 [2 2 2]]
print(A.shape,B.shape,C.shape)# 從shape中看出A,B均為擁有3項的陣列(數列)
(3,) (3,) (2, 3)
# horizontal stack左右合并
D = np.hstack((A,B))
print(D)
[1 1 1 2 2 2]
print(A.shape,B.shape,D.shape)
(3,) (3,) (6,)
# 對于A,B這種，為陣列或數列，無法進行轉置，需要借助其他函式進行轉置

5.2 陣列轉為矩陣

print(A[np.newaxis,:]) # [1 1 1]變為[[1 1 1]]
print(A[np.newaxis,:].shape) # (3,)變為(1, 3)
print(A[:,np.newaxis])
[[1]
 [1]
 [1]]

5.3 多個矩陣合并

# concatenate的第一個例子
A = A[:,np.newaxis] # 陣列轉為矩陣
B = B[:,np.newaxis] # 陣列轉為矩陣
print(A)
[[1]
 [1]
 [1]]
print(B)
[[2]
 [2]
 [2]]

# axis=0縱向合并
C = np.concatenate((A,B),axis=0)
print(C)
[[1]
 [1]
 [1]
 [2]
 [2]
 [2]]
# axis=1橫向合并
C = np.concatenate((A,B),axis=1)
print(C)
[[1 2]
 [1 2]
 [1 2]]

# concatenate的第二個例子
a = b = np.arange(8).reshape(2,4)
print(a)
[[0 1 2 3]
 [4 5 6 7]]

# axis=0多個矩陣縱向合并
c = np.concatenate((a,b),axis=0)
print(c)
[[0 1 2 3]
 [4 5 6 7]
 [0 1 2 3]
 [4 5 6 7]]

# axis=1多個矩陣橫向合并
c = np.concatenate((a,b),axis=1)
print(c)
[[0 1 2 3 0 1 2 3]
 [4 5 6 7 4 5 6 7]]

6.Numpy array分割

A = np.arange(12).reshape((3,4))
print(A)
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]

6.1 等量分割

# 縱向分割 同橫向合并的axis
print(np.split(A, 2, axis=1))
# 等價于
print(np.hsplit(A,2)) 
[array([[0, 1],
       [4, 5],
       [8, 9]]), array([[ 2,  3],
       [ 6,  7],
       [10, 11]])]

# 橫向分割 同縱向合并的axis
print(np.split(A,3,axis=0))
# 等價于
print(np.vsplit(A,3))
[array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8,  9, 10, 11]])]

6.2 不等量分割

print(np.array_split(A,3,axis=1))
[array([[0, 1],
       [4, 5],
       [8, 9]]), array([[ 2],
       [ 6],
       [10]]), array([[ 3],
       [ 7],
       [11]])]

7. copy 與 ‘=’

7.1 ‘=’ 賦值方式會帶有關聯性

a = np.arange(4)
print(a) # [0 1 2 3]

b = a
c = a
d = b
a[0] = 11
print(a) # [11  1  2  3]
print(b) # [11  1  2  3]
print(c) # [11  1  2  3]
print(d) # [11  1  2  3]
print(b is a) # True
print(c is a) # True
print(d is a) # True

d[1:3] = [22,33]
print(a) # [11 22 33  3]
print(b) # [11 22 33  3]
print(c) # [11 22 33  3]

7.2 copy()賦值方式沒有關聯性

a = np.arange(4)
print(a) # [0 1 2 3]

b =a.copy() # deep copy
print(b) # [0 1 2 3]

a[3] = 44  # 此時a與b已經沒有關聯
print(a) # [ 0  1  2 44]
print(b) # [0 1 2 3]

8.廣播機制

numpy陣列間的基礎運算是一對一，也就是a.shape==b.shape，但是當兩者不一樣的時候，就會自動觸發廣播機制，如下例子：

from numpy import array
a = array([[ 0, 0, 0],
           [10,10,10],
           [20,20,20],
           [30,30,30]])
b = array([0,1,2])
print(a+b)
[[ 0  1  2]
 [10 11 12]
 [20 21 22]
 [30 31 32]]

# 這里以tile模擬上述操作，來回到a.shape==b.shape情況
# 對[0,1,2]行重復4次，列重復1次
b = np.tile([0,1,2],(4,1))
print(a+b)
[[ 0  1  2]
 [10 11 12]
 [20 21 22]
 [30 31 32]]

只有當兩個陣列的 trailing dimensions compatible （尾部維度兼容）時才會觸發廣播，否則報錯ValueError: frames are not aligned exception，

9.常用函式

9.1 np.bincount()

x = np.array([1, 2, 3, 3, 0, 1, 4])
np.bincount(x) # 統計索引出現次數
array([1, 2, 1, 2, 1], dtype=int64) # 索引0出現1次，1出現2次，2出現1次，3出現2次，4出現1次

# 設定weights引數
w = np.array([0.3,0.5,0.7,0.6,0.1,-0.9,1])
np.bincount(x,weights=w)
array([ 0.1, -0.6,  0.5,  1.3,  1. ])
# 計算程序：
# x --->  [1, 2, 3, 3, 0, 1, 4]
# w --->  [0.3,0.5,0.7,0.6,0.1,-0.9,1] 
# 索引 0 出現在x中index=4位置，那么在w中訪問index=4的位置即可，w[4]=0.1
# 索引 1 出現在x中index=0與index=5位置，那么在w中訪問index=0與index=5的位置即可，然后將兩這個加和，計算得：w[0]+w[5]=-0.6

# bincount的另外一個引數為minlength，當所給的bin數量多于實際從x中得到的bin數量后，后面沒有訪問到的設定為0即可，
np.bincount(x,weights=w,minlength=7)
array([ 0.1, -0.6,  0.5,  1.3,  1. ,  0. ,  0. ])

9.2 np.argmax()

函式原型為：numpy.argmax(a, axis=None, out=None).
函式表示回傳沿軸 axis 最大值的索引，

x = [[1,3,3],
     [7,5,2]]
print(np.argmax(x))  
3	# 7最大，索引位置為3(這個索引按照遞增順序)

print(np.argmax(x,axis=0))	# axis=0表示按列操作，也就是對比當前列，找出最大值的索引
[1 1 0]
print(np.argmax(x,axis=1))	# axis=1表示按行操作，也就是對比當前行，找出最大值的索引
[1 0]

# 若碰到重復最大元素，回傳第一個最大值索引即可
x = np.array([1, 3, 2, 3, 0, 1, 0])
print(x.argmax()) # 1

9.3 上述合并實體

x = np.array([1, 2, 3, 3, 0, 1, 4])
print(np.argmax(np.bincount(x)))
1
# 計算程序：
# np.bincount(x) = [1, 2, 1, 2, 1]
# 回傳第一個最大值的index即可！2的index為1，所以回傳1

9.4 求取精度

# 取指定位置的精度
# decimals表示指定保留有效數的位數，當超過5就會進位(此時包含5)
np.around([-0.6,1.2798,2.357,9.67,13], decimals=0)	
array([-1.,  1.,  2., 10., 13.])
np.around([1.2798,2.357,9.67,13], decimals=1)
array([ 1.3,  2.4,  9.7, 13. ])

# -1表示看一位數進位即可，當超過5時候(不包含5)，才會進位
np.around([1,2,5,6,56], decimals=-1)
array([ 0,  0,  0, 10, 60])
# -2表示必須看兩位，超過50才會進位
np.around([1,2,5,50,56,190], decimals=-2)
array([  0,   0,   0,   0, 100, 200])

# 計算沿指定軸第N維的離散差值
x = np.arange(1 , 16).reshape((3 , 5))
print(x)
[[ 1  2  3  4  5]
 [ 6  7  8  9 10]
 [11 12 13 14 15]]
np.diff(x,axis=1) #默認axis=1
array([[1, 1, 1, 1],
       [1, 1, 1, 1],
       [1, 1, 1, 1]])
np.diff(x,axis=0) 
array([[5, 5, 5, 5, 5],
       [5, 5, 5, 5, 5]])

# 取整
np.floor([-0.6,-1.4,-0.1,-1.8,0,1.4,1.7])
array([-1., -2., -1., -2.,  0.,  1.,  1.])

# 取上限，即找到這個小數的最大整數
np.ceil([1.2,1.5,1.8,2.1,2.0,-0.5,-0.6,-0.3])
array([ 2.,  2.,  2.,  3.,  2., -0., -0., -0.])

# 查找
x = np.array([[1, 0],
       [2, -2],
     [-2, 1]])
print(x)
[[ 1  0]
 [ 2 -2]
 [-2  1]]
# 利用np.where實作小于0的值用0填充嗎，大于0的數不變
np.where(x>0,x,0)
array([[1, 0],
       [2, 0],
       [0, 1]])