【python資料分析（2）】Numpy通用函數

1.數組形狀：.T/.reshape()/.resize()

1）

.T

方法：轉置，例如原shape為(3,4)/(2,3,4)，轉置結果為(4,3)/(4,3,2) → 是以一維數組轉置後結果不變

2）

numpy.reshape(a, newshape, order='C')

：為數組提供新形狀，而不更改其資料，是以元素數量需要一緻！！

3）

numpy.resize(a, new_shape)：

傳回具有指定形狀的新數組，如有必要可重複填充所需數量的元素。

注意了：.T/.reshape()/.resize()都是生成新的數組！！！

import numpy as np

ar1 = np.arange(10)
ar2 = np.ones((5,2))
print(ar1,'\n',ar1.T)
print(ar2,'\n',ar2.T)
print('————————————')


ar3 = ar1.reshape(2,5)      			# 用法1：直接将已有數組改變形狀             
ar4 = np.zeros((4,6)).reshape(3,8)   	# 用法2：生成數組後直接改變形狀
ar5 = np.reshape(np.arange(12),(3,4))   # 用法3：參數内添加數組，目标形狀
print(ar1,'\n',ar3)
print(ar4)
print(ar5)
print('————————————')

ar6 = np.resize(np.arange(5),(3,4))
print(ar6)
           

–> 輸出的結果為：

[0 1 2 3 4 5 6 7 8 9] 
 [0 1 2 3 4 5 6 7 8 9]
[[ 1.  1.]
 [ 1.  1.]
 [ 1.  1.]
 [ 1.  1.]
 [ 1.  1.]] 
 [[ 1.  1.  1.  1.  1.]
 [ 1.  1.  1.  1.  1.]]
————————————
[0 1 2 3 4 5 6 7 8 9] 
 [[0 1 2 3 4]
 [5 6 7 8 9]]
[[ 0.  0.  0.  0.  0.  0.  0.  0.]
 [ 0.  0.  0.  0.  0.  0.  0.  0.]
 [ 0.  0.  0.  0.  0.  0.  0.  0.]]
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
————————————
[[0 1 2 3]
 [4 0 1 2]
 [3 4 0 1]]
           

2.數組的複制

copy()

方法生成數組及其資料的完整拷貝

回憶python的指派邏輯：指向記憶體中生成的一個值 → 這裡ar1和ar2指向同一個值，是以ar1改變，ar2一起改變

ar1 = np.arange(10)
ar2 = ar1
print(ar2 is ar1)
ar1[2] = 9
print(ar1,ar2)

ar3 = ar1.copy()
print(ar3 is ar1)
ar1[0] = 9
print(ar1,ar3)
           

–> 輸出的結果為：

True
[0 1 9 3 4 5 6 7 8 9] [0 1 9 3 4 5 6 7 8 9]
False
[9 1 9 3 4 5 6 7 8 9] [0 1 9 3 4 5 6 7 8 9]
           

3.數組類型轉換

a.astype()：

轉換數組類型

注意：養成好習慣，數組類型用

np.int32

，而不是直接

int32

ar1 = np.arange(10,dtype=float)
print(ar1,ar1.dtype)
print('————————————')

ar2 = ar1.astype(np.int32)
print(ar2,ar2.dtype)
print(ar1,ar1.dtype)
           

–> 輸出的結果為：

[0. 1. 2. 3. 4. 5. 6. 7. 8. 9.] float64
————————————
[0 1 2 3 4 5 6 7 8 9] int32
[0. 1. 2. 3. 4. 5. 6. 7. 8. 9.] float64
           

4.數組堆疊

1）

numpy.hstack(tup)：

水準（按列順序）堆疊數組

a = np.arange(5)    				 # a為一維數組，5個元素
b = np.arange(5,9)	    			 # b為一維數組,4個元素
ar1 = np.hstack((a,b))  			 # 注意:((a,b))，這裡形狀可以不一樣
print(a,a.shape)
print(b,b.shape)
print(ar1,ar1.shape)
a = np.array([[1],[2],[3]])   		 # a為二維數組，3行1列
b = np.array([['a'],['b'],['c']]) 	 # b為二維數組，3行1列
ar2 = np.hstack((a,b)) 				 # 注意:((a,b))，這裡形狀必須一樣
print(a,a.shape)
print(b,b.shape)
print(ar2,ar2.shape)
           

–> 輸出的結果為：

[0 1 2 3 4] (5,)
[5 6 7 8] (4,)
[0 1 2 3 4 5 6 7 8] (9,)
[[1]
 [2]
 [3]] (3, 1)
[['a']
 ['b']
 ['c']] (3, 1)
[['1' 'a']
 ['2' 'b']
 ['3' 'c']] (3, 2)
           

2）

numpy.vstack(tup)：

垂直（按列順序）堆疊數組

a = np.arange(5)    
b = np.arange(5,10)
ar1 = np.vstack((a,b))
print(a,a.shape)
print(b,b.shape)
print(ar1,ar1.shape)
a = np.array([[1],[2],[3]])   
b = np.array([['a'],['b'],['c'],['d']])   
ar2 = np.vstack((a,b))  # 這裡形狀可以不一樣
print(a,a.shape)
print(b,b.shape)
print(ar2,ar2.shape)
           

–> 輸出的結果為：

[0 1 2 3 4] (5,)
[5 6 7 8 9] (5,)
[[0 1 2 3 4]
 [5 6 7 8 9]] (2, 5)
[[1]
 [2]
 [3]] (3, 1)
[['a']
 ['b']
 ['c']
 ['d']] (4, 1)
[['1']
 ['2']
 ['3']
 ['a']
 ['b']
 ['c']
 ['d']] (7, 1)
           

3）

numpy.stack(arrays, axis=0)：

沿着新軸連接配接數組的序列，形狀必須一樣！

解釋axis參數的意思，假設兩個數組[1 2 3]和[4 5 6]，shape均為(3,0)

axis=0：[[1 2 3] [4 5 6]]，shape為(2,3)

axis=1：[[1 4] [2 5] [3 6]]，shape為(3,2)

a = np.arange(5)    
b = np.arange(5,10)
ar1 = np.stack((a,b))
ar2 = np.stack((a,b),axis = 1)
print(a,a.shape)
print(b,b.shape)
print(ar1,ar1.shape)
print(ar2,ar2.shape)
           

–> 輸出的結果為：

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

5.數組拆分

1）

numpy.hsplit(ary, indices_or_sections)：

将數組水準（逐列）拆分為多個子數組 → 按列拆分

2）

numpy.vsplit(ary, indices_or_sections)：

:将數組垂直（行方向）拆分為多個子數組 → 按行拆

ar = np.arange(16).reshape(4,4)
ar1 = np.hsplit(ar,2)
print(ar)
print(ar1,type(ar1))

ar2 = np.vsplit(ar,4)
print(ar2,type(ar2))
           

–> 輸出的結果為：

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]]
 
[array([[ 0,  1],
       [ 4,  5],
       [ 8,  9],
       [12, 13]]), array([[ 2,  3],
       [ 6,  7],
       [10, 11],
       [14, 15]])] <class 'list'>
       
[array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8,  9, 10, 11]]), array([[12, 13, 14, 15]])] <class 'list'>
           

6.數組簡單運算

ar = np.arange(6).reshape(2,3)
print(ar + 10)  	 # 加法
print(ar * 2)  		 # 乘法
print(1 / (ar+1)) 	 # 除法
print(ar ** 0.5)  	 # 幂
# 與标量的運算

print(ar.mean()) 	 # 求平均值
print(ar.max())  	 # 求最大值
print(ar.min())  	 # 求最小值
print(ar.std()) 	 # 求标準差
print(ar.var())  	 # 求方差
print(ar.sum(), np.sum(ar,axis = 0))  # 求和，np.sum() → axis為0，按列求和；axis為1，按行求和
print(np.sort(np.array([1,4,3,2,5,6])))  # 排序
           

–> 輸出的結果為：

[[10 11 12]
 [13 14 15]]
[[ 0  2  4]
 [ 6  8 10]]
[[ 1.          0.5         0.33333333]
 [ 0.25        0.2         0.16666667]]
[[ 0.          1.          1.41421356]
 [ 1.73205081  2.          2.23606798]]
2.5
5
0
1.70782512766
2.91666666667
15 [3 5 7]
[1 2 3 4 5 6]