目錄
Numpy
說明：通常所說的"數組"，"Numpy數組"，"ndarray"基本上都是指同一個東西，即ndarray對象。
說明：本人純Python小白，最近剛學了Numpy數據分析，整理此博文，希望對大家有幫助。
Numpy常用函數以及用法
（1）創建ndarray數組
- 使用array函數
說明：他可以接收一切序列型的對象，然后產生一個新的含有傳入數據的Numpy數組。除非用dtype自定義類型，否則他會根據你傳入的數據類型自動幫你匹配合適的類型。
此類型規則為：如果有字符串，則優先字符串，如果沒有字符串而有復數類型，則系統默認幫你判定為復數類型。然后依次為浮點數和整數。即優先級為"字符串>復數>浮點數>整數"。
代碼如下：
import numpy as np
array = np.array(['Hello', 1+2j, 5.20, 5])
for i in array:
print(i, ':', type(i))
print('===============================')
array = np.array([1+2j, 5.20, 5])
for i in array:
print(i, ':', type(i))
print('===============================')
array = np.array([5.20, 5])
for i in array:
print(i, ':', type(i))
print('===============================')
array = np.array([5])
for i in array:
print(i, ':', type(i))
輸出結果為：
Hello : <class 'numpy.str_'>
(1+2j) : <class 'numpy.str_'>
5.2 : <class 'numpy.str_'>
5 : <class 'numpy.str_'>
===============================
(1+2j) : <class 'numpy.complex128'>
(5.2+0j) : <class 'numpy.complex128'>
(5+0j) : <class 'numpy.complex128'>
===============================
5.2 : <class 'numpy.float64'>
5.0 : <class 'numpy.float64'>
===============================
5 : <class 'numpy.int32'>
- 使用ones和zeros函數
除此之外，還可以使用ones函數和zeros函數來創建一個全是1或者全是0的數組，我們只需要傳遞給他們一個需要創建的數組的形狀即可。
代碼示例如下：
import numpy as np
array = np.ones((3, 3))
print(array)
print('=================')
array = np.zeros((3, 3))
print(array)
輸出結果：
[[1. 1. 1.]
[1. 1. 1.]
[1. 1. 1.]]
=================
[[0. 0. 0.]
[0. 0. 0.]
[0. 0. 0.]]
- empty函數
函數說明：empty函數可以創建一個沒有任何具體指的函數。我們在使用empty的時候只需要傳入一個表示形狀的元祖就可以了。值得注意的是，empty創建出來的數組初始值是不確定的隨機值。
例如：
import numpy as np
array = np.empty((3, 3))
print(array)
輸出結果如下（完全沒有規律）：
[[7.01573217e-322 0.00000000e+000 0.00000000e+000]
[0.00000000e+000 0.00000000e+000 1.14623230e-321]
[1.24610926e-306 1.61271680e-312 0.00000000e+000]
- arange函數
函數說明：arange函數用法與range函數類似。不同的是arange生成的是ndarray對象，即numpy數組。
例如運行如下代碼：
import numpy as np
array1 = np.arange(10)
print(array1, type(array1))
輸出結果如下：
[0 1 2 3 4 5 6 7 8 9] <class 'numpy.ndarray'>
- linspace函數
函數說明：此函數與arange函數有些相似。調用方法為 np.linspace(start= ,stop= ,num= ,endpoint= ,retstep= ,dtype= ,axis= )
參數說明：
-
start是數組起始數字
-
stop是數組結束數字
-
num（可選）控制結果中共有多少個元素
-
endpoint（可選）決定了中止值（stop）是否包含在內。若值為True，則包含stop，否則不包含。如果不寫默認是True
-
retstep（可選）默認是False，如果指定為True，則結果會返回步長以及序列數組，從而產生一個元組作為輸出
-
dtype（可選）為生成的數組的類型，可以自定義數據類型，不寫則按那個規則 字符串>復數>浮點數>整數
-
axis（可選）默認是0 。很多函數都會有這個參數，這是個軸的意思。具體定義如下圖：
運行如下代碼：
import numpy as np
array1 = np.linspace(1,10,10)
print(array1)
print('='*30)
array2 = np.linspace(start = 1, stop = 10, num = 10, endpoint=True, dtype=int, retstep=True)
print(array2)
輸出結果如下：
[ 1. 2. 3. 4. 5. 6. 7. 8. 9. 10.]
==============================
(array([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]), 1.0)
- logspace函數
函數說明：返回在對數刻度上均勻間隔的數字。此函數尚未理解
- full函數
函數說明：返回給定形狀，給定值的數組。
運行代碼：
import numpy as np
array = np.full(shape=(3, 3), fill_value=10, dtype=int)
print(array)
輸出結果如下：
[[10 10 10]
[10 10 10]
[10 10 10]]
- repeat函數
函數說明：建立每個元素重復N次的數組。
運行代碼：
import numpy as np
array = np.repeat(a=[1, 1, 2, 3], repeats=3, axis=0) # a的每個元素重復三次
print(array)
運行結果如下：
[1 1 1 1 1 1 2 2 2 3 3 3]
另外還有一些數組創建函數如下表所示：
| 函數 | 說明 |
|---|---|
| array | 將輸入數據（列表，元組，數組或者其他的序列類型）轉換為ndarray。要么推斷出dtype，要么在創建時即指定dtype。默認直接復制輸入數據 |
| asarray | 將輸入轉換為ndarray，如果輸入本身就是一個ndarray就不進行復制 |
| arange | 類似於內置的range，但返回的是一個ndarray而不是列表 |
| ones、ones_like | ones是根據指定的dtype和形狀創建一個全1數組，ones_like是根據給定的數組的形狀創建一個全1數組 |
| zeros、zeros_like | 與上類似，只不過是全0數組 |
| empty、empty_like | 與上類似，只不過數據是隨機的 |
| eye、identity | 創建一個N * N的單位矩陣，對角線元素為1，其余為0 |
| full、full_like | 創建一個給定形狀，給定值的數組 |
（2）操作數組
1. 數組屬性的獲取
| 調用方法 | 作用 |
|---|---|
| .ndim | 返回數組的維數 |
| .shape | 返回數組的形狀 |
| .size | 返回數組元素個數 |
| .dtype | 返回數組元素類型 |
| .itemsize | 返回數組元素字節大小 |
2. 數組屬性的操作
| 調用方法 | 作用 |
|---|---|
| .reshape | 改變數組形狀 |
| .all | 數組元素都是0返回True，否則返回False |
| .any | 數組元素有非0值返回True，否則返回False |
| .copy | 復制數組副本（並不是引用） |
| .astype | 改變數組元素數據類型 |
3. 數組的對接與分割
- vstack()函數
函數說明：vstack()函數可以實現數組的垂直對接。
運行代碼：
import numpy as np
array1 = np.zeros((2, 3), dtype=int)
array2 = np.ones((4, 3), dtype=int)
print(array1)
print('=' * 20)
print(array2)
print('=' * 20)
print(np.vstack((array1, array2)))
運行結果如下：
[[0 0 0]
[0 0 0]]
====================
[[1 1 1]
[1 1 1]
[1 1 1]
[1 1 1]]
====================
[[0 0 0]
[0 0 0]
[1 1 1]
[1 1 1]
[1 1 1]
[1 1 1]]
- hstack()
函數說明：hstack()函數可以實現數組元素的水平對接。
運行代碼：
import numpy as np
array1 = np.zeros((2, 6), dtype=int)
array2 = np.ones((2, 1), dtype=int)
print(array1)
print('=' * 20)
print(array2)
print('=' * 20)
print(np.hstack((array1, array2)))
運行結果如下：
[[0 0 0 0 0 0]
[0 0 0 0 0 0]]
====================
[[1]
[1]]
====================
[[0 0 0 0 0 0 1]
[0 0 0 0 0 0 1]]
- vsplit()
函數說明：vsplit(array, N)函數可以實現數組的垂直分割（就是分割的垂直，以水平方向分割垂直），array為需要分割的數組，N為分割數。
代碼示例如下：
import numpy as np
array1 = np.array(([1, 2, 3], [4, 5, 6], [7, 8, 9]), dtype=int)
print(array1)
print('=' * 30)
print(np.vsplit(array1, 3))
運行結果如下：
[[1 2 3]
[4 5 6]
[7 8 9]]
==============================
[array([[1, 2, 3]]), array([[4, 5, 6]]), array([[7, 8, 9]])]
- hsplit()
函數說明：hsplit(array, N)函數可以實現數組元素的水平分割（相當於以垂直方向分割水平，實現水平分割），array為要分割的數組，N為分割的份數。
代碼示例如下：
import numpy as np
array1 = np.array(([1, 2, 3], [4, 5, 6], [7, 8, 9]), dtype=int)
print(array1)
print('=' * 30)
print(np.hsplit(array1, 3))
運行結果如下：
[[1 2 3]
[4 5 6]
[7 8 9]]
==============================
[array([[1],
[4],
[7]]), array([[2],
[5],
[8]]), array([[3],
[6],
[9]])]
（3）多維數組的索引與切片（主要區別與一維數組不同的用法）
1. 索引省略用法
說明：當能確定維度時，索引方法和普通數組一樣，如array[1], array[1, 2], array[1, 2, 3]。當確定不了維度時，可以通過下標右邊…省略號或直接省略下標數，來讀取數組。
示例：
import numpy as np
array = np.arange(1, 13).reshape((2, 2, 3))
print(array)
print('=' * 30)
print(array[1])
print('=' * 30)
print(array[1, ])
print('=' * 30)
print(array[1, ...])
print('=' * 30)
print(array[1, ..., 2]) # 此時不能用 array[1, 2]，會報錯為: IndexErrorindex 2 is out of bounds for axis 1 with size 2
運行結果如下：
[[[ 1 2 3]
[ 4 5 6]]
[[ 7 8 9]
[10 11 12]]]
==============================
[[ 7 8 9]
[10 11 12]]
==============================
[[ 7 8 9]
[10 11 12]]
==============================
[[ 7 8 9]
[10 11 12]]
==============================
[ 9 12]
2. 二維數組切片
說明：默認的切片方式，如[0:2:1]獲得第1行到第2行元素，這種切的是行，操作方式與一維數組相同，如果要切片二維數組的行和列，則
操作方式為：數組名[行切片, 列切片]
格式為：array[start:stop:step, start:stop:step]
如：array[:, 2]就是截取所有行，第三列的子數組。array[:, :]就是獲取所有行所有列。
示例：
import numpy as np
array = np.arange(1, 13).reshape((3, 4))
print(array)
print('=' * 30)
# 獲取從第1行到第2行步長為1的所有行，再從這些行中獲得第2列到第4列步長為2的所有元素
print(array[0:2:1,1:4:2])
運行結果如下：
[[ 1 2 3 4]
[ 5 6 7 8]
[ 9 10 11 12]]
==============================
[[2 4]
[6 8]]
3. 三維數組切片
說明：操作方式與二維數組相類型，無非就是多了一維而已。
操作方式為：數組名[頁切片, 行切片, 列切片]
格式為：array[start:stop:step, start:stop:step, start:stop:step]
示例：
import numpy as np
array = np.arange(1, 13).reshape((2, 2, 3))
print(array)
print('=' * 30)
# 獲取第2頁的第2行的從第2列到第3列步長為1的所有元素
print(array[1, 1, 1:3:1])
運行結果如下：
[[[ 1 2 3]
[ 4 5 6]]
[[ 7 8 9]
[10 11 12]]]
==============================
[11 12]
4. 花式索引
- 整數數組索引
（1）一維數組的整數數組索引
說明：利用整數數組的所有元素的下標值進行索引，又叫數組索引。
示例：
import numpy as np
names = np.array(['zhaoer', 'zhangsan', 'lisi', 'wangwu', 'maliu', 'tangqi'])
index = np.array([1, 2, 4, 5])
print(*names)
print('=' * 60)
print(*names[index])
運行結果如下：
zhaoer zhangsan lisi wangwu maliu tangqi
============================================================
zhangsan lisi maliu tangqi
（2）二維數組的數組索引
說明：對二維數組輸出時如果只索引一個一維數組，則只操作行，如果索引為兩個一維數組，則第一個一維數組指定結果的x坐標，第二個一維數組指定結果的y坐標。
示例如下：
import numpy as np
# 以下是利用一個整數數組進行索引
names = np.array([['tom', 1], ['jack', 2], ['lucy', 3], ['blackCat', 4], ['win', 5], ['father', 6]])
index = np.array([1, 2, 4, 5])
print(*names)
print('=' * 60)
print(*names[index])
print('=' * 60)
# 以下用兩個一維整數數組進行索引
array = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
index1 = np.array([[0, 1, 2]]) # 注意：這是其實是一個二維數組的第一維
index2 = np.array([0, 1, 2])
print(array)
print('=' * 60)
print(array[index1, index2])
運行結果如下：
['tom' '1'] ['jack' '2'] ['lucy' '3'] ['blackCat' '4'] ['win' '5'] ['father' '6']
============================================================
['jack' '2'] ['lucy' '3'] ['win' '5'] ['father' '6']
============================================================
[[1 2 3]
[4 5 6]
[7 8 9]]
============================================================
[[1 5 9]]
- bool數組索引
說明：准備一個bool數組，用該數組索引其他數組時，只會輸出True位置對應的元素。一維或者多維數組都適用。
示例：
import numpy as np
array = np.arange(1, 10).reshape((3, 3))
index = np.array([[True, False, True], [True, False, False], [False, False, True]])
print(array)
print('=' * 20)
print(array[index])
運行結果如下：
[[1 2 3]
[4 5 6]
[7 8 9]]
====================
[1 3 4 9]
（4）基本數學計算
1. 普通計算
說明：計算的對象可以是兩個數組，也可以是一個數組一個數字，所有運算對於復數也同樣適用。如下表：
| 運算方式 | 符號 | 函數 |
|---|---|---|
| 數組加法 | + | add |
| 數組減法 | - | subtract |
| 數組乘法 | * | multiply |
| 數組除法 | / | divide |
| 數組求余 | % | mod |
| 數組求冪 | ** | power |
| 數組整除 | // | floor_divide |
示例：
import numpy as np
array1 = np.arange(1, 10).reshape((3, 3))
array2 = np.array([10, 10, 10])
print('第一個數組：')
print(array1)
print('第二個數組：')
print(array2)
print('=' * 30)
print('數組加法：')
print(np.add(array1, array2))
print('=' * 30)
print('數組減法：')
print(np.subtract(array1, array2))
print('=' * 30)
print('數組乘法：')
print(np.multiply(array1, 2))
print('=' * 30)
print('數組除法：')
print(np.divide(array1, 10))
print('=' * 30)
print('數組求余：')
print(np.mod(array1, array2))
print('=' * 30)
print('數組求冪：')
print(np.power(array1, 3))
print('=' * 30)
print('數組整除：')
print(np.floor_divide(array1, 2))
運行結果如下：
第一個數組：
[[1 2 3]
[4 5 6]
[7 8 9]]
第二個數組：
[10 10 10]
==============================
數組加法：
[[11 12 13]
[14 15 16]
[17 18 19]]
==============================
數組減法：
[[-9 -8 -7]
[-6 -5 -4]
[-3 -2 -1]]
==============================
數組乘法：
[[ 2 4 6]
[ 8 10 12]
[14 16 18]]
==============================
數組除法：
[[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 8 9]]
==============================
數組求冪：
[[ 1 8 27]
[ 64 125 216]
[343 512 729]]
==============================
數組整除：
[[0 1 1]
[2 2 3]
[3 4 4]]
2. 比較運算
說明：可以數組與數組比較，也可以數組和單個數字標量進行比較，結果是與第一個數組形狀相同的數組，滿足條件的位置為True，不滿足的為False，如下表：
| 運算方式 | 符號 |
|---|---|
| 等於比較 | == |
| 不等於比較 | != |
| 大於比較 | > |
| 小於比較 | < |
| 大於等於 | >= |
| 小於等於 | <= |
示例（此示例僅展示等於比較運算，其他運算方式相似）：
import numpy as np
array1 = np.arange(1, 10).reshape((3, 3))
array2 = np.array([1, 1, 1])
print(array1 == array2)
print('=' * 30)
print(array1 == 1)
結果：
[[ True False False]
[False False False]
[False False False]]
==============================
[[ True False False]
[False False False]
[False False False]]
3. 數組位運算
說明：運算對象可以是數組與數組，也可以是數組和單個數字標量，結果是與第一個數組形狀相同的數組，滿足條件的位置為True，不滿足的為False，如下表：
| 運算方式 | 符號 |
|---|---|
| 與 | & |
| 或 | | |
| 非 | ~ |
| 左移 | << |
| 右移 | >> |
示例（次示例僅展示與運算，其他運算方式類似）：
import numpy as np
array1 = np.arange(1, 10).reshape((3, 3))
array2 = np.array([[True, False, True], [True, False, True], [True, False, True]])
print(array1 & array2)
print('=' * 30)
print(array1 & 10)
運算結果如下：
[[1 0 1]
[0 0 0]
[1 0 1]]
==============================
[[0 2 2]
[0 0 2]
[2 8 8]]
（5）數組通用函數
說明：這里的函數和數學概念中的函數是一一對應的
1. 三角函數 反三角函數
說明：
- numpy中自帶圓周率，用numpy.pi就可以使用
- 傳遞給函數的數是以弧度計算，對於角度可以用array * numpy.pi / 180 轉換為弧度
- 調用反三角函數時可以用numpy.degrees()函數將結果中的弧度轉換為角度
函數如下表：
| 功能 | 函數 |
|---|---|
| 正弦 | sin |
| 余弦 | cos |
| 正切 | tan |
| 反正弦 | arcsin |
| 反余弦 | arccos |
| 反正切 | arctan |
以正弦為示例，其他類似：
import numpy as np
array = np.array([0, 30, 45, 60, 90])
sin = np.sin(array * np.pi / 180)
print('正弦計算結果為：')
print(sin)
print('=' * 60)
print('對結果執行反正弦並轉換為角度：')
print(np.degrees(np.arcsin(sin)))
運行結果如下：
正弦計算結果為：
[0. 0.5 0.70710678 0.8660254 1. ]
============================================================
對結果執行反正弦並轉換為角度：
[ 0. 30. 45. 60. 90.]
2. 舍入函數
函數：numpy.around(array, decimals)
函數說明：
- 其中array為數組，decimals為要保留的小數位數，默認值為0，如果為負數，則將整數四舍五入保留到小數點左側位置
- 結果是科學計數法的形式，如1.23e + 2就是1.23*10^2
示例如下：
import numpy as np
array = np.array([12, 12.123456, 12345.12])
print('將decimals默認：')
print(np.around(array))
print('保留到小數點后一位：')
print(np.around(array, 1))
print('保留到小數點左一位：')
print(np.around(array, -1))
運行結果：
將decimals默認：
[1.2000e+01 1.2000e+01 1.2345e+04]
保留到小數點后一位：
[1.20000e+01 1.21000e+01 1.23451e+04]
保留到小數點左一位：
[1.000e+01 1.000e+01 1.235e+04]
3. 取整函數
說明：
- numpy.ceil(array)是返回大於或者等於指定表達式的最小整數，即向上取整。
- numpy.floor(array)是返回小於或等於指定表達式的最大整數，即向下取整。
- 參數中array是數組名或者單個數字標量。
示例：
import numpy as np
array = np.array([1.23, 4.5, 6.789])
print('向上取整：')
print(np.ceil(array))
print('向下取整：')
print(np.floor(array))
print('對於單個數字標量：')
print(np.floor(1.23))
print(np.ceil(1.23))
運行結果如下：
向上取整：
[2. 5. 7.]
向下取整：
[1. 4. 6. ]
對於單個數字標量：
1.0
2.0
4. 以e為底的指數函數和對數函數
說明：
- numpy.exp(array)是以e為底，以array為指數的結果。
- numpy.log(array)是以e為底，以array為真數的結果。
- numpy.log2(array)是以2為底，以array為真數的結果。
- numpy.log10(array)是以10為底，以array為真數的結果。
- 其中array既可以是數組，也可以是單個數字標量。
5. 隨機函數
說明：常用隨機函數如下表
| 函數 | 參數 | 解釋 |
|---|---|---|
| numpy.random.rand(shape) | shape用於指定生成數組的形狀 | 函數產生[0, )范圍內的浮點隨機數，生成一個數組 |
| numpy.random.randn(shape) | shape用於指定生成數組的形狀 | 函數產生標准正態分布隨機數，生成一個數組 |
| numpy.random.randint(low=None, high=None, size=None, dtype=None) | 隨機數范圍[low, high)，size是隨機數的個數，dtype是隨機數類型 | 生成的type類型的size個范圍內的隨機數，返回一個數組 |
| numpy.random.normal(loc=None, scale=None, size=None) | 產生正態分布隨機數 | |
| numpy.random.uniform(low=None, high=None, size=None) | 產生均勻分布隨機數 | |
| numpy.random.poisson(lam=None, size=None) | 產生泊松分布隨機數 | |
| numpy.random.permutation(array) | array可以是數組，也可以是單獨數字標量 | 當array為數組時，打亂數組中的所有數，當array為數字標量時，返回[0, array)范圍內的數的亂序組成的數組 |
| numpy.random.shuffle(array) | array為數組 | 與上述區別是直接對array進行打亂，無返回值 |