Python_數據分析_numpy模塊

numpy可以說是Python運用於人工智能和科學計算的一個重要基礎，關於庫的引入不做贅述，主要分享一些總結的numpy庫的用法。

1. numpy數組對象

Numpy中的多維數組稱爲ndarray，這是Numpy中最常見的數組對象。ndarray對象通常包含兩個部分：

• ndarray數據本身
• 描述數據的元數據

Numpy數組的優勢

• Numpy數組通常是由相同種類的元素組成的，即數組中的數據項的類型一致。這樣有一個好處，由於知道數組元素的類型相同，所以能快速確定存儲數據所需空間的大小。
• Numpy數組能夠運用向量化運算來處理整個數組，速度較快；而Python的列表則通常需要藉助循環語句遍歷列表，運行效率相對來說要差。
• Numpy使用了優化過的C API，運算速度較快

2 numpy數組（ndarray）的創建

2.1 array()

通過array方式創建，向array中傳入一個list實現

import numpy as np

array1 = np.array([1, 2, 3])
array2 = np.array([[1, 2, 3],
                   [4, 5, 6],
                   [7, 8, 9]])

print(array1)
print(array2)

[Runing] ============
[1 2 3]
[[1 2 3]
 [4 5 6]
 [7 8 9]]

2.2 arange()

通過arange創建數組：下例中創建一個0~1間隔爲0.1的行向量，從0開始，不包括1，第二個例子通過對齊廣播方式生成一個多維的數組。

import numpy as np

array1 = np.arange(0, 1, 0.1)
array2 = np.arange(1, 70, 10).reshape(-1, 1) + np.arange(0, 7)
array3 = np.arange(24).reshape(2,3,4)

print(array1)
print(array2)
print(arrat3)

[Running]=======
[0.  0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]

[[ 1  2  3  4  5  6  7]
 [11 12 13 14 15 16 17]
 [21 22 23 24 25 26 27]
 [31 32 33 34 35 36 37]
 [41 42 43 44 45 46 47]
 [51 52 53 54 55 56 57]
 [61 62 63 64 65 66 67]]
 
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]]])

2.3 linspace()&logspace()

通過linspace函數創建數組：下例中創建一個0~1間隔爲1/9的行向量（按等差數列形式生成），從0開始，包括1.
通過logspace函數創建數組：下例中創建一個1~100，有20個元素的行向量（按等比數列形式生成），其中0表示10^{0=1，2表示10}2=100，從1開始，包括100

import numpy as np

array1 = np.linspace(0, 1, 10)
array2 = np.logspace(0, 2, 20)

print(array1)
print(array2)

[Running]===========
[0.         0.11111111 0.22222222 0.33333333 0.44444444 0.55555556
 0.66666667 0.77777778 0.88888889 1.        ]
[  1.           1.27427499   1.62377674   2.06913808   2.6366509
   3.35981829   4.2813324    5.45559478   6.95192796   8.8586679
  11.28837892  14.38449888  18.32980711  23.35721469  29.76351442
  37.92690191  48.32930239  61.58482111  78.47599704 100.        ]

2.4 生成特殊數列

• ones、ones_like，根據形狀創建一個全1的數組、後者可以複製其他數組的形狀
• zeros、zeros_like，類似上面，全0
• empty、empty_like，創建新數組、只分配空間
• eye、identity，創建對角線爲1的對角矩陣
  注意要指定數組的規模（用一個元組指定），同時要指定元素的類型，否則會報錯。這部分函數較簡單，不進行測試

2.5 生成隨機數組

簡單使用隨機數生成數組和arange（）方法生成類似，更多生成方法可以更詳細的查找閱讀。

import numpy as np
from numpy.random import randn

arr = randn(12).reshape(3, 4)
print(arr)

[Running]========
 [[ 0.98655235  1.20830283 -0.72135183  0.40292924]
  [-0.05059849 -0.02714873 -0.62775486  0.83222997]
  [-0.84826071 -0.29484606 -0.76984902  0.09025059]]
 

3. dtype

Numpy的全部數據類型如下：

每一種數據類型都有相應的數據轉換函數，創建數組是可以用dtype進行說明

import numpy as np

array1 = np.ones((2, 3), dtype = 'float')
array2 = np.array([1. ,2. ,3. ], dtype = 'int32')

print(array1)
print(array2)

[Running] =========
[[1. 1. 1.]
 [1. 1. 1.]]
 
[1 2 3]

4. ndarray()屬性

4.1 dtype屬性

ndarray數組的數據類型，數據類型的種類，前面已描述。
需要注意的是，複數的虛部符號爲j，且不能轉化爲float數據類型

4.2 ndim屬性

ndim用來描述數組的維度，需要注意的是這個屬性比較實用二維數組，當數組維度是三維時，只能返回倒數第二個維度。

import numpy as np

array1 = np.ones(24).reshape(2,3,4)
array2 = np.ones(8).reshape(2,4)

print(array1.ndim)
print(array2.ndim)

【Running】========
3
2

4.3 shape屬性

數組對象的尺度，對於矩陣，即n行m列,shape是一個元組（tuple），相比於ndim屬性，反映的更全面。

import numpy as np

array1 = np.ones(24).reshape(2,3,4)
array2 = np.ones(8).reshape(2,4)

print(array1.shape)
print(array2.shape)

【Running】=========
(2, 3, 4)
(2, 4)

4.4 size屬性

size屬性是數組中保存元素的數量

import numpy as np

array1 = np.ones(24).reshape(2,3,4)
array2 = np.ones(8).reshape(2,4)

print(array1.size)
print(array2.size)

【Running】=======
24
8

4.5 itemsize屬性

itemsize屬性返回數組中各個元素所佔用的字節數大小。

import numpy as np

array1 = np.ones(24).reshape(2,3,4)
array2 = np.ones(8).reshape(2,4)

print(array1.itemsize)
print(array2.itemsize)

【Running】==========
8
8

4.6 nbytes屬性

如果想知道整個數組所需的字節數量，可以使用nbytes屬性。其值等於數組的size屬性值乘以itemsize屬性值。

import numpy as np

array1 = np.ones(24).reshape(2,3,4)
array2 = np.ones(8).reshape(2,4)

print(array1.nbytes)
print(array2.nbytes)

【Running】===========
192
64

4.7 T屬性

import numpy as np

array1 = np.arange(24).reshape(4,6)

print(array1)
print(array1.T)

【Running】=======
[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]]
[[ 0  6 12 18]
 [ 1  7 13 19]
 [ 2  8 14 20]
 [ 3  9 15 21]
 [ 4 10 16 22]
 [ 5 11 17 23]]

4.8 real&imag屬性

real和imag分別返回數組的實部和虛部，這裏不進行舉例說明。

4.9 flat屬性

flat屬性，返回一個numpy.flatiter對象，即可迭代的對象。

import numpy as np

array1 = np.arange(6).reshape(2,3)
f = array1.flat

print(array1)
for i in f:
	print(i)

【Running】==========
[[0 1 2]
 [3 4 5]]
0
1
2
3
4
5

flat屬性生成迭代器後，能夠進行一些賦值和索引操作

import numpy as np

array1 = np.array([[11, 12, 13, 14],
	               [21, 22, 23, 24],
	               [31, 32, 33, 34]])
array1.flat = 7
print(array1)
【Running】=======
[[7 7 7 7]
 [7 7 7 7]
 [7 7 7 7]]

import numpy as np

array1 = np.array([[11, 12, 13, 14],
	               [21, 22, 23, 24],
	               [31, 32, 33, 34]])
f = array1.flat
print(f[[1,4]])
【Running】==========
[12 21]

import numpy as np

array1 = np.array([[11, 12, 13, 14],
	               [21, 22, 23, 24],
	               [31, 32, 33, 34]])
f = array1.flat
f[[1,5]] = 7
print(array1)
【Running】=======
[[11  7 13 14]
 [21  7 23 24]
 [31 32 33 34]]

5. adarray切片與索引

adarray的索引和列表相似，有幾個維度就可用幾個維度來引用

import numpy as np

array1 = np.array([1, 2, 3, 4])

array2 = np.array([[11, 12, 13, 14],
	               [21, 22, 23, 24],
	               [31, 32, 33, 34]])

print(array1[2])     # 一維數組索引
print(array2[0][0])  # 二維數組索引
print(array2[0])     # 二維數組索引行
print(array2.T[0])   # 二維數組索引列

【Running】===========
3
11
[11 12 13 14]
[11 21 31]

6. shape變化

6.1 形狀變換

6.1.1 shape & resize

shape 和 resize都能改變數組的維度，resize是將原本的數組改變，shape是改變單次視圖

import numpy as np

array1 = np.array([[11, 12, 13, 14],
	               [21, 22, 23, 24],
	               [31, 32, 33, 34]])

print(array1.reshape(2,6))
array1.resize(4,3)
print(array1)

【Running】============
[[11 12 13 14 21 22]
 [23 24 31 32 33 34]]
[[11 12 13]
 [14 21 22]
 [23 24 31]
 [32 33 34]]

6.1.2 ravel() & flatten()

ravel() 和 flatten()，都是講多維數組轉爲一維數組。兩者的區別在於返回拷貝（copy）還是返回視圖（view），flatten()返回一份拷貝，需要分配新的內存空間，對拷貝所做的修改不會影響原始矩陣，而ravel()返回的是視圖（view），會影響原始矩陣。

import numpy as np

array1 = np.array([[11, 12, 13, 14],
	               [21, 22, 23, 24],
	               [31, 32, 33, 34]])

print(array1.flatten())
array1.flatten()[0] = 0
print(array1)

print(array1.ravel())
array1.ravel()[0] = 0
print(array1)

【Running】===========
[11 12 13 14 21 22 23 24 31 32 33 34]
[[11 12 13 14]
 [21 22 23 24]
 [31 32 33 34]]
[11 12 13 14 21 22 23 24 31 32 33 34]
[[ 0 12 13 14]
 [21 22 23 24]
 [31 32 33 34]]

6.1.3 轉置

前面描述了數組轉置的屬性（T），也可以通過transpose()函數來實現

import numpy as np

array1 = np.array([[11, 12, 13, 14],
	               [21, 22, 23, 24],
	               [31, 32, 33, 34]])

print(array1.transpose())

【Running】============
[[11 21 31]
 [12 22 32]
 [13 23 33]
 [14 24 34]]

6.2 堆疊數組

6.2.1 hstack() & column_stack()

hstack()是水平堆疊，即將兩個數組水平連接，進行水平堆疊時要注意有相同的行

import numpy as np

array1 = np.array([[11, 12, 13, 14],
	               [21, 22, 23, 24],
	               [31, 32, 33, 34]])
array2 = array1 * 2
print(np.hstack((array1,array2)))

【Running】=================
[[11 12 13 14 22 24 26 28]
 [21 22 23 24 42 44 46 48]
 [31 32 33 34 62 64 66 68]]

6.2.2 vstack() & row_stack()

vstack()是垂直疊加

import numpy as np

array1 = np.array([[11, 12, 13, 14],
	               [21, 22, 23, 24],
	               [31, 32, 33, 34]])
array2 = array1 * 2
print(np.vstack((array1,array2)))

【Running】=========
[[11 12 13 14]
 [21 22 23 24]
 [31 32 33 34]
 [22 24 26 28]
 [42 44 46 48]
 [62 64 66 68]]

6.2.3 concatenate()

通過設置axis的值來設置疊加方向，axis=1時，沿水平方向疊加；axis=0時，沿垂直方向疊加

import numpy as np

array1 = np.array([[11, 12, 13, 14],
	               [21, 22, 23, 24],
	               [31, 32, 33, 34]])
array2 = array1 * 2
print(np.concatenate((array1,array2),axis=1))
print(np.concatenate((array1,array2),axis=0))

【Running】===========
[[11 12 13 14 22 24 26 28]
 [21 22 23 24 42 44 46 48]
 [31 32 33 34 62 64 66 68]]
[[11 12 13 14]
 [21 22 23 24]
 [31 32 33 34]
 [22 24 26 28]
 [42 44 46 48]
 [62 64 66 68]]

6.2.4 dstack()

dstack()是深度疊加，即增加一個維度，如兩個（2，3）進行深度疊加後得到（2，3，2）的數組

import numpy as np

array1 = np.array([[11, 12, 13, 14],
	               [21, 22, 23, 24],
	               [31, 32, 33, 34]])
array2 = array1 * 2
print(np.dstack((array1,array2)))
print(np.dstack((array1,array2)).shape)

【Running】=================
[[[11 22]
  [12 24]
  [13 26]
  [14 28]]

 [[21 42]
  [22 44]
  [23 46]
  [24 48]]

 [[31 62]
  [32 64]
  [33 66]
  [34 68]]]
(3, 4, 2)

6.3 數組拆分

數組的拆分與疊加類似，有 hsplit()、vsplit()、dsplit() 以及split()函數，前三個分別對應橫向拆分，縱向拆分和深度拆分，split中輸入axis參數，axis=1時，沿水平方向拆分；axis=0時，沿垂直方向拆分。

7. 數組類型轉換

7.1 tolist()

tolist()能將數組轉換成list

import numpy as np

array1 = np.array([[11, 12, 13, 14],
	               [21, 22, 23, 24],
	               [31, 32, 33, 34]])

print(array1.tolist())

【Running】================
[[11, 12, 13, 14], [21, 22, 23, 24], [31, 32, 33, 34]]

7.2 astype()

astype()能將數組轉換成指定類型

import numpy as np

array1 = np.array([[11, 12, 13, 14],
	               [21, 22, 23, 24],
	               [31, 32, 33, 34]])

print(array1.astype(float))

【Running】=================
[[11. 12. 13. 14.]
 [21. 22. 23. 24.]
 [31. 32. 33. 34.]]

8. numpy常用統計函數

請注意函數在使用時需要指定axis軸的方向，若不指定，默認統計整個數組。

• np.sum()，返回求和
• np.mean()，返回均值
• np.max()，返回最大值
• np.min()，返回最小值
• np.ptp()，數組沿指定軸返回最大值減去最小值，即（max-min）
• np.std()，返回標準偏差（standard deviation）
• np.var()，返回方差（variance）
• np.cumsum()，返回累加值
• np.cumprod()，返回累乘積值

9. 數組的廣播

當數組跟一個標量進行數學運算時，標量需要根據數組的形狀進行擴展，然後執行運算。這個擴展的過程稱爲“廣播（broadcasting）”
如我們前面用到的乘法

import numpy as np

array1 = np.array([[11, 12, 13, 14],
	               [21, 22, 23, 24],
	               [31, 32, 33, 34]])
array2 = array1 + 5
array3 = array1 * 2
print(array2)
print(array3)

【Running】=============
[[16 17 18 19]
 [26 27 28 29]
 [36 37 38 39]]
[[22 24 26 28]
 [42 44 46 48]
 [62 64 66 68]]