Python 數據分析三劍客之 NumPy（五）：數學 / 算術 / 統計 / 排序 / 條件 / 判斷函數合集

原創 TRHX • 鲍勃 2020-06-21 01:30

CSDN 課程推薦：《Python 數據分析與挖掘》，講師劉順祥，浙江工商大學統計學碩士，數據分析師，曾擔任唯品會大數據部擔任數據分析師一職，負責支付環節的數據分析業務。曾與聯想、亨氏、網魚網咖等企業合作多個企業級項目。

NumPy 系列文章：

另有 Pandas、Matplotlib 系列文章已更新完畢，歡迎關注：

推薦學習資料與網站（博主參與部分文檔翻譯）：

文章目錄

這裏是一段防爬蟲文本，請讀者忽略。
本文原創首發於 CSDN，作者 TRHX。
博客首頁：https://itrhx.blog.csdn.net/
本文鏈接：https://itrhx.blog.csdn.net/article/details/105398131
未經授權，禁止轉載！惡意轉載，後果自負！尊重原創，遠離剽竊！

【1x00】NumPy 函數速查表

NumPy 三角函數
函數 描述
sin() 正弦函數
cos() 餘弦函數
tan() 正切函數
arcsin() 反正弦函數
arccos() 反餘弦函數
arctan() 反正切函數
NumPy 舍入函數
函數 描述
around() 將指定數字四捨五入到指定的小數位
rint() 將指定數字四捨五入到最近的整數
floor() 返回小於或者等於指定表達式的最大整數，即向下取整
ceil() 返回大於或者等於指定表達式的最小整數，即向上取整
NumPy 算術函數
函數 描述
add() 數組元素加法運算
subtract() 數組元素減法運算
multiply() 數組元素乘法運算
divide() 數組元素除法運算
reciprocal() 返回數組元素的倒數
power() 返回數組元素的乘冪
mod() 返回數組元素的相除後的餘數
remainder() 返回數組元素的相除後的餘數
NumPy 統計函數
函數 描述
amax() 計算數組元素沿指定軸的最大值
amin() 計算數組元素沿指定軸的最小值
argmax() 計算數組元素沿指定軸的最大值的索引值
argmin() 計算數組元素沿指定軸的最小值的索引值
sum() 計算數組中所有元素的和
cumsum() 返回一個一維數組，每個元素都是之前所有元素的累加和
cumprod() 返回一個一維數組，每個元素都是之前所有元素的累乘積
ptp() 計算數組元素最大值與最小值的差
percentile() 計算多維數組的任意百分位數
median() 計算數組元素的中位數
mean() 計算數組元素的算術平均值
average() 計算數組元素的加權平均值
std() 計算數組元素的標準差
var() 計算數組元素的方差
NumPy 排序函數
sort() 將原數組元素按照從小到大排序
msort() 將原數組元素按照第一個軸的從小到大排序
argsort() 將元素從小到大排列，提取對應的索引值並返回
lexsort() 將多個序列按照從小到大排序，返回其索引值
sort_complex() 對複數數組進行從小到大排序
partition() 對數組進行分區排序
argpartition() 對數組進行分區排序，返回元素的索引值
unique() 將數組元素去重後返回從小到大的排序結果
NumPy 條件函數
nonzero() 返回原數組中非零元素的索引值
where() 返回數組中滿足指定條件的元素的索引值
extract() 返回數組中滿足指定條件的元素
NumPy 判斷函數
any() 至少有一個元素滿足指定條件，則返回 True，否則返回 False
all() 所有的元素滿足指定條件，則返回 True，否則返回 False

【2x00】NumPy 數學函數

NumPy 數學函數包含三角函數、舍入函數等。

【2x01】sin() / cos() / tan()

numpy.sin()、numpy.cos()、numpy.tan() 分別對應正弦函數、餘弦函數、正切函數。

在求三角函數時，會先將角度轉化成弧度，在 NumPy 中的轉化公式：角度 * numpy.pi/180

應用舉例：

>>> import numpy as np
>>> a = np.array([0, 30, 45, 60 ,90])
>>> print(np.sin(a*np.pi/180))
[0.         0.5        0.70710678 0.8660254  1.        ]
>>> print(np.cos(a*np.pi/180))
[1.00000000e+00 8.66025404e-01 7.07106781e-01 5.00000000e-01 6.12323400e-17]
>>> print(np.tan(a*np.pi/180))
[0.00000000e+00 5.77350269e-01 1.00000000e+00 1.73205081e+00 1.63312394e+16]

【2x02】arcsin() / arccos() / arctan()

numpy.arcsin()、numpy.arccos()、numpy.arctan() 分別對應反正弦函數、反餘弦函數、反正切函數。

在求三角函數時，會先將角度轉化成弧度，在 NumPy 中的轉化公式：角度 * numpy.pi/180

arcsin、arccos、arctan 接收的參數是三角函數值，函數返回給定角度的 sin，cos 和 tan 的反三角函數，如果 sinθ=x，那麼 arcsinx=θ，其他類似，這些函數的結果可以通過 numpy.degrees() 函數將弧度轉換爲角度。

>>> import numpy as np
>>> a = np.array([0, 30, 45, 60 ,90])
>>> a_sin = np.sin(a*np.pi/180)
>>> a_arcsin = np.arcsin(a_sin)
>>> print(a_sin)                                           # 角度的正弦值
[0.         0.5        0.70710678 0.8660254  1.        ]
>>> print(a_arcsin)                                        # 角度的反正弦值，返回值的單位爲弧度
[0.         0.52359878 0.78539816 1.04719755 1.57079633]
>>> print(np.degrees(a_arcsin))                            # 弧度轉化爲角度
[ 0. 30. 45. 60. 90.]

【2x03】around() / rint() / floor() / ceil()

1、numpy.around() 函數將指定數字四捨五入到指定的小數位，可指定保留的小數位數。

基本語法：numpy.around(a[, decimals=0, out=None])

參數 描述
a 輸入數組
decimals int 類型，可選項，舍入的小數位數，默認值爲 0，如果爲負，整數將四捨五入到小數點左側的位置
out ndarray 對象，可選項，放置結果的備用輸出數組。它必須具有與預期輸出相同的形狀，但是如有必要，將強制轉換輸出值的類型

應用舉例：

>>> import numpy as np
>>> a = np.array([13, 1.4, 6.23, 12.834])
>>> print(np.around(a))
[13.  1.  6. 13.]
>>> print(np.around(a, decimals=1))
[13.   1.4  6.2 12.8]
>>> print(np.around(a, decimals=-1))
[10.  0. 10. 10.]

2、numpy.rint() 函數將指定數字四捨五入到最近的整數，不保留小數位。

應用舉例：

>>> import numpy as np
>>> print(np.rint([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]))
[-2. -2. -0.  0.  2.  2.  2.]

3、numpy.floor() 函數會返回小於或者等於指定表達式的最大整數，即向下取整。

應用舉例：

>>> import numpy as np
>>> print(np.floor([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]))
[-2. -2. -1.  0.  1.  1.  2.]

4、numpy.ceil() 函數會返回大於或者等於指定表達式的最小整數，即向上取整。

應用舉例：

>>> import numpy as np
>>> print(np.ceil([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]))
[-1. -1. -0.  1.  2.  2.  2.]

【3x00】NumPy 算術函數

NumPy 算術函數包含了基本的加減乘除運算、求倒數、冪、餘數等。

【3x01】add() / subtract() / multiply() / divide()

add()、subtract()、multiply()、divide() 分別對應 NumPy 中的加減乘除運算。

注意：兩個數組必須具有相同的形狀或符合數組的廣播規則才能進行運算。

應用舉例：

>>> import numpy as np
>>> a = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]])
>>> b = np.array([5, 5, 5])
>>> print(np.add(a, b))
[[ 5  6  7]
 [ 8  9 10]
 [11 12 13]]
>>> print(np.subtract(a, b))
[[-5 -4 -3]
 [-2 -1  0]
 [ 1  2  3]]
>>> print(np.multiply(a, b))
[[ 0  5 10]
 [15 20 25]
 [30 35 40]]
>>> print(np.divide(a, b))
[[0.  0.2 0.4]
 [0.6 0.8 1. ]
 [1.2 1.4 1.6]]

【3x02】reciprocal() / power() / mod() / remainder()

1、numpy.reciprocal() 函數用於返回各數組元素的倒數。

應用舉例：

>>> import numpy as np
>>> print(np.reciprocal([0.25, 4, 1, 2.10]))
[4.         0.25       1.         0.47619048]

2、numpy.power() 函數將第一個數組中的元素作爲底數，計算它與第二個數組中相應元素的冪。

應用舉例：

>>> import numpy as np
>>> a = np.array([5, 10, 100])
>>> b = np.array([3, 2, 1])
>>> print(np.power(a, b))
[125 100 100]
>>>
>>> print(np.power(a, 2))
[   25   100 10000]

3、numpy.mod() 與 numpy.remainder() 都可以計算數組中相應元素相除後的餘數。

應用舉例：

>>> import numpy as np
>>> a = np.array([10, 15, 20])
>>> b = np.array([3, 4, 5])
>>> print(np.mod(a, b))
[1 3 0]
>>> print(np.remainder(a, b))
[1 3 0]
>>> print(np.mod(a, 6))
[4 3 2]
>>> print(np.remainder(a, 9))
[1 6 2]

【3x03】absolute() / isnan()

1、numpy.absolute() 函數用於計算元素的絕對值。

應用舉例：

>>> import numpy as np
>>> print(np.absolute([-1.2, 1.2, 13, -10]))
[ 1.2  1.2 13.  10. ]

2、numpy.isnan() 函數用於判斷元素是否爲 NaN（Not a Number）。

應用舉例：

>>> import numpy as np
>>> np.isnan(np.nan)
True
>>> np.isnan(np.inf)
False
>>> print(np.isnan([np.nan, 2, 3, np.nan]))
[ True False False  True]

【4x00】NumPy 統計函數

NumPy 統計函數包含了計算最大值、最小值、最大值與最小值的差、百分位數、中位數、算術平均值、加權平均值、標準差與方差等。

【4x01】amax() / amin()

numpy.amax() 和 numpy.amin() 函數分別用於計算數組中的元素沿指定軸的最大值和最小值。

基本語法：

numpy.amax(a[, axis=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>])

numpy.amin(a[, axis=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>])

參數解釋：

參數 描述
a 待處理的數組對象
axis 指定軸，可選項，整數或者整數元組類型
out ndarray 對象，可選項，放置結果的備用輸出數組，必須具有與預期輸出數組相同的形狀和緩衝區長度
keepdims bool 類型，可選項，是否保持數組的二維特性
initial 初始值標量，可選項，如果設置了標量，則除了元素之間的比較外，還會和標量進行對比
where 比較條件，通常和 initial 參數一起使用
如果當前是 amax 函數，where 爲 True 時則會比較最大值， Flase 則會比較最小值
該參數含義比較模糊，參考資料較少，準確描述請參考官方文檔

應用舉例：

>>> import numpy as np
>>> a = np.array([[2, 4], [8, 9]])
>>> print(a)
[[2 4]
 [8 9]]
>>> 
>>> print(np.amax(a))
9
>>> 
>>> print(np.amax(a, axis=0))                                  # 元素按行比較
[8 9]
>>>
>>> print(np.amax(a, axis=0, keepdims=True))                   # 元素按行比較並保持數組的二維特性
[[8 9]]
>>> 
>>> print(np.amax(a, axis=1))                                  # 元素按列比較
[4 9]
>>> 
>>> print(np.amax(a, axis=1, initial=5))                       # 元素按列比較（包括標量一起比較）
[5 9]

【4x02】argmax() / argmin()

numpy.argmax() 和 numpy.argmin() 函數分別沿指定軸返回最大元素和最小元素的索引值。

基本語法：numpy.argmax(a[, axis=None, out=None])；numpy.argmin(a[, axis=None, out=None])

參數 描述
a 待處理的數組對象
axis 指定軸，可選項，整數或者整數元組類型，若未指定，則在操作前會將數組展開
out 可選項，放置結果的備用輸出數組，必須具有與預期輸出數組相同的形狀和緩衝區長度

應用舉例：

>>> import numpy as np
>>> a = np.array([[30,40,70],[80,20,10],[50,90,60]])
>>> print(a)
[[30 40 70]
 [80 20 10]
 [50 90 60]]
>>> 
>>> print (np.argmax(a))
7
>>> 
>>> print(np.argmin(a))
5
>>> 
>>> print(np.argmax(a, axis=0))
[1 2 0]
>>> 
>>> print(np.argmin(a, axis=0))
[0 1 1]

【4x03】sum()

numpy.sum() 函數用於計算所有元素的和。

基本語法：numpy.sum(a, axis=None, dtype=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)

參數 描述
a 待處理的數組對象
axis 指定軸，可選項，整數或者整數元組類型，若未指定則運算前會將數組展平
dtype 指定數據類型，可選項
out 可選項，放置結果的備用輸出數組，必須具有與預期輸出數組相同的形狀和緩衝區長度
keepdims bool 類型，可選項，是否保持數組的二維特性
initial 初始值標量，可選項，如果設置了標量，則除了元素之間的求和外，還會和標量進行求和
where 求和條件，總和中要包括的元素

應用舉例：

>>> import numpy as np
>>> print(np.sum([[0, 1], [0, 5]]))
6
>>> print(np.sum([[0, 1], [0, 5]], axis=0))
[0 6]
>>> print(np.sum([[0, 1], [0, 5]], axis=1))
[1 5]
>>> print(np.sum([[0, 1], [np.nan, 5]], where=[False, True], axis=1))
[1. 5.]
>>> print(np.sum([10], initial=5))
15

【4x04】cumsum() / cumprod()

numpy.cumsum()：返回一個一維數組，每個元素都是之前所有元素的累加和。
numpy.cumprod()：返回一個一維數組，每個元素都是之前所有元素的累乘積。

基本語法：numpy.cumsum(a, axis=None, dtype=None, out=None)；numpy.cumprod(a, axis=None, dtype=None, out=None)

參數 描述
a 待處理的數組對象
axis 指定軸，可選項，整數或者整數元組類型，若未指定則運算前會將數組展平
dtype 指定數據類型，可選項
out 可選項，放置結果的備用輸出數組，必須具有與預期輸出數組相同的形狀和緩衝區長度

應用舉例：

>>> import numpy as np
>>> a = np.array([[1,2,3], [4,5,6]])
>>> print(np.cumsum(a))
[ 1  3  6 10 15 21]
>>> 
>>> print(np.cumsum(a, axis=0))
[[1 2 3]
 [5 7 9]]
>>> 
>>> print(np.cumsum(a, axis=1))
[[ 1  3  6]
 [ 4  9 15]]
>>> 
>>> print(np.cumprod(a))
[  1   2   6  24 120 720]
>>> 
>>> print(np.cumprod(a, axis=0))
[[ 1  2  3]
 [ 4 10 18]]
>>> 
>>> print(np.cumprod(a, axis=1))
[[  1   2   6]
 [  4  20 120]]

【4x05】ptp()

numpy.ptp() 函數用於計算數組中元素最大值與最小值的差。

基本語法：numpy.ptp(a[, axis=None, out=None, keepdims=<no value>])

參數 描述
a 待處理的數組對象
axis 指定軸，可選項，整數或者整數元組類型
out 可選項，放置結果的備用輸出數組，必須具有與預期輸出數組相同的形狀和緩衝區長度
keepdims bool 類型，可選項，是否保持數組的二維特性

應用舉例：

>>> import numpy as np
>>> a = np.array([[2,5,8],[7,6,3],[2,9,4]])
>>> print(a)
[[2 5 8]
 [7 6 3]
 [2 9 4]]
>>> print(np.ptp(a))
7
>>> 
>>> print(np.ptp(a, axis=0))
[5 4 5]
>>> 
>>> print(np.ptp(a, axis=1))
[6 4 7]
>>> print(np.ptp(a, axis=1, keepdims=True))
[[6]
 [4]
 [7]]

【4x06】percentile()

numpy.percentile() 函數用於計算一個多維數組的任意百分位數。

百分位數：統計學術語，如果將一組數據從小到大排序，並計算相應的累計百分位，則某一百分位所對應數據的值就稱爲這一百分位的百分位數。可表示爲：一組 n 個觀測值按數值大小排列。如：處於 p% 位置的值稱第 p 百分位數。

基本語法：numpy.percentile(a, q[, axis=None, out=None, overwrite_input=False, interpolation='linear', keepdims=False])

參數 描述
a 待處理的數組對象
q 要計算的百分位數，在 [0, 100] 之間
axis 指定軸，可選項，整數或者整數元組類型
out 可選項，放置結果的備用輸出數組，必須具有與預期輸出數組相同的形狀和緩衝區長度
overwrite_input bool 值，可選項，如果爲True，則允許通過中間計算來修改輸入數組 a 以節省內存
在這種情況下，此操作完成後 a 的內容是不確定的
interpolation 可選項，指定當所需百分比位於兩個數據點 i<j 之間時要使用的插值方法：
linear：i + (j - i) * fraction，其中 fraction 是由 i 和 j 包圍的索引的分數部分
lower：i；higher：j；nearest：i 或 j，以最近者爲準；midpoint：(i + j) / 2
keepdims bool 類型，可選項，是否保持數組的二維特性

應用舉例：

>>> import numpy as np
>>> a = np.array([[10, 7, 4], [3, 2, 1]])
>>> print(a)
[[10  7  4]
 [ 3  2  1]]
>>> 
>>> print(np.percentile(a, 50))
3.5
>>> 
>>> print(np.percentile(a, 50, axis=0))
[6.5 4.5 2.5]
>>> 
>>> print(np.percentile(a, 50, axis=1))
[7. 2.]
>>> 
>>> print(np.percentile(a, 50, axis=1, keepdims=True))
[[7.]
 [2.]]

【4x07】median()

numpy.median() 函數用於計算數組元素的中位數。

基本語法：numpy.median(a[, axis=None, out=None, overwrite_input=False, keepdims=False])

參數 描述
a 待處理的數組對象
axis 指定軸，可選項，整數或者整數元組類型
out 可選項，放置結果的備用輸出數組，必須具有與預期輸出數組相同的形狀和緩衝區長度
overwrite_input bool 值，可選項，如果爲True，則允許通過中間計算來修改輸入數組 a 以節省內存
在這種情況下，此操作完成後 a 的內容是不確定的
keepdims bool 類型，可選項，是否保持數組的二維特性

應用舉例：

>>> import numpy as np
>>> a = np.array([[10, 7, 4], [3, 2, 1]])
>>> print(a)
[[10  7  4]
 [ 3  2  1]]
>>>
>>> print(np.median(a))
3.5
>>>
>>> print(np.median(a, axis=0))
[6.5 4.5 2.5]
>>> 
>>> print(np.median(a, axis=1))
[7. 2.]

【4x08】mean()

numpy.mean() 函數計算數組中元素的算術平均值。

算術平均值：沿軸的元素的總和除以元素的數量。

基本語法：numpy.mean(a[, axis=None, dtype=None, out=None])

參數 描述
a 待處理的數組對象
axis 指定軸，可選項，整數或者整數元組類型
dtype 可選項，用於計算平均值的類型
out 可選項，放置結果的備用輸出數組，必須具有與預期輸出數組相同的形狀和緩衝區長度

應用舉例：

>>> import numpy as np
>>> a = np.array([[10, 7, 4], [3, 2, 1]])
>>> print(a)
[[10  7  4]
 [ 3  2  1]]
>>> 
>>> print(np.mean(a))
4.5
>>> 
>>> print(np.mean(a, axis=0))
[6.5 4.5 2.5]
>>> 
>>> print(np.mean(a, axis=1))
[7. 2.]

【4x09】average()

numpy.average() 函數根據在另一個數組中給出的各自的權重來計算數組中元素的加權平均值。

加權平均值：將各數值乘以相應的權數，然後加總求和得到總體值，再除以總的單位數。

例如：現有數組 [1, 2, 3, 4]，相應的權重爲 [5, 6, 7, 8]，則計算方法爲：（1*5+2*6+3*7+4*8）/（5+6+7+8）≈ 2.6923

基本語法：numpy.average(a[, axis=None, weights=None, returned=False])

參數 描述
a 待處理的數組對象
axis 指定軸，可選項，整數或者整數元組類型
weights 可選項，與 a 中的值相關聯的權重數組，如果 weights=None，則 a 中的所有數據都具有 1 的權重，相當於 mean 函數
returned 可選項，bool 類型，默認爲 False，如果爲 True，則返回元組 (加權平均值, 權重)，否則只返回加權平均值

應用舉例：

>>> import numpy as np
>>> a = np.array([1, 2, 3, 4])
>>> print(np.average(a))          # 不指定權重時相當於 mean 函數
2.5
>>> 
>>> print(np.average(a, weights=[5, 6, 7, 8]))
2.6923076923076925
>>> 
>>> print(np.average(a, weights=[5, 6, 7, 8], returned=True))
(2.6923076923076925, 26.0)

【4x10】std() / var()

numpy.std() 和 numpy.var() 分別用於計算數組元素的標準差與方差。

標準差是一組數據平均值分散程度的一種度量，標準差是方差的算術平方根。

方差爲 S2，標準差爲 S，計算公式如下：

S2=1n∑i=1n(xi−x‾)2S^2 = \frac {1} {n} \sum_{i=1} ^ {n} (x_i - \overline {x})^2

S=S2S = \sqrt {S^2}

基本語法：

numpy.std(a, axis=None, dtype=None, out=None, ddof=0, keepdims=<no value>)

numpy.var(a[, axis=None, dtype=None, out=None, ddof=0, keepdims=<no value>])

參數 描述
a 待處理的數組對象
axis 指定軸，可選項，整數或者整數元組類型
dtype 可選項，值的數據類型
out 可選項，放置結果的備用輸出數組，必須具有與預期輸出數組相同的形狀和緩衝區長度
ddof 自由度（Delta Degrees of Freedom），計算中使用的除數是 N-ddof，其中 N 表示元素的數量，ddof 默認爲零
keepdims bool 類型，可選項，是否保持數組的二維特性

應用舉例：

>>> import numpy as np
>>> a = np.array([[1, 2], [3, 4]])
>>> print(a)
[[1 2]
 [3 4]]
>>> 
>>> print(np.std(a))
1.118033988749895
>>> 
>>> print(np.std(a, axis=0))
[1. 1.]
>>> 
>>> print(np.std(a, axis=1))
[0.5 0.5]
>>> 
>>> print(np.var(a))
1.25
>>> 
>>> print(np.var(a, axis=0))
[1. 1.]
>>> 
>>> print(np.var(a, axis=1))
[0.25 0.25]

這裏是一段防爬蟲文本，請讀者忽略。
本文原創首發於 CSDN，作者 TRHX。
博客首頁：https://itrhx.blog.csdn.net/
本文鏈接：https://itrhx.blog.csdn.net/article/details/105398131
未經授權，禁止轉載！惡意轉載，後果自負！尊重原創，遠離剽竊！

【5x00】NumPy 排序函數

NumPy 排序函數中可以指定使用的排序方法，各種分類算法的特徵在於它們的平均速度，最壞情況下的性能，工作空間大小以及它們是否穩定，三種算法對比如下：

方法 速度 最壞情況 工作空間 穩定性
快速排序（quicksort） 1 O(n^2) 0 no
歸併排序（mergesort） 2 O(n*log(n)) ~n/2 yes
堆排序（heapsort） 3 O(n*log(n)) 0 no

【5x01】sort()

numpy.sort() 函數會將原數組元素從小到大排序，返回輸入數組的排序副本。

基本語法：numpy.sort(a[, axis=-1, kind='quicksort', order=None])

參數 描述
a 要排序的數組
axis 要排序的軸，可選項，如果爲 None，則在排序之前會將數組展平，默認值爲 -1，它沿着最後一個軸排序
kind 排序算法，可選項，默認值爲快速排序（quicksort）
order 字符串或者字符串列表，可選項，若指定 order 值，將按照該字段進行排序

應用舉例：

>>> import numpy as np
>>> a = np.array([[1,4],[3,1]])
>>> print(np.sort(a))
[[1 4]
 [1 3]]
>>> 
>>> print(np.sort(a, axis=None))   # 數組將展平
[1 1 3 4]
>>> 
>>> print(np.sort(a, axis=0))
[[1 1]
 [3 4]]
>>> 
>>> print(np.sort(a, axis=1))
[[1 4]
 [1 3]]

>>> import numpy as np
>>> dtype = [('name', 'S10'), ('height', float), ('age', int)]
>>> values = [('Arthur', 1.8, 41), ('Lancelot', 1.9, 38), ('Galahad', 1.7, 38)]
>>> a = np.array(values, dtype=dtype)
>>> print(a)
[(b'Arthur', 1.8, 41) (b'Lancelot', 1.9, 38) (b'Galahad', 1.7, 38)]
>>> 
>>> print(np.sort(a, order='height'))                # 按 height 排序
[(b'Galahad', 1.7, 38) (b'Arthur', 1.8, 41) (b'Lancelot', 1.9, 38)]
>>> 
>>> print(np.sort(a, order=['age', 'height']))      # 按 age 排序，如果 age 相等，則按 height 排序
[(b'Galahad', 1.7, 38) (b'Lancelot', 1.9, 38) (b'Arthur', 1.8, 41)]

【5x02】msort()

numpy.msort() 函數將數組按第一個軸從小到大排序，返回排序後的數組副本，相當於 numpy.sort(a, axis=0)

應用舉例：

>>> import numpy as np
>>> print(np.msort([[1, 4, 5], [2, 1, 3]]))
[[1 1 3]
 [2 4 5]]
>>> print(np.sort([[1, 4, 5], [2, 1, 3]], axis=0))
[[1 1 3]
 [2 4 5]]

【5x03】argsort()

numpy.argsort() 函數將原數組元素從小到大排列，提取其對應在原數組中的索引值並返回。

舉例：原數組爲：[3, 1, 2]，從小到大排列：[1, 2, 3]，排列後的各元素在原數組中對應的索引值：[1, 2, 0]

基本語法：numpy.argsort(a[, axis=-1, kind=None, order=None])

參數 描述
a 要排序的數組
axis 要排序的軸，可選項，如果爲 None，則在排序之前會將數組展平，默認值爲 -1，它沿着最後一個軸排序
kind 排序算法，可選項，默認值爲快速排序（quicksort）
order 字符串或者字符串列表，可選項，若指定 order 值，將按照該字段進行排序

應用舉例：

>>> import numpy as np
>>> a = np.array([3, 1, 2])
>>> print(np.argsort(a))
[1 2 0]
>>> 
>>> b = np.array([[0, 3], [2, 2]])
>>> print(np.argsort(b))
[[0 1]
 [0 1]]
>>> 
>>> print(np.argsort(b, axis=0))
[[0 1]
 [1 0]]
>>> 
>>> print(np.argsort(b, axis=1))
[[0 1]
 [0 1]]

【5x04】lexsort()

numpy.lexsort() 函數使用鍵序列執行間接穩定排序，用於對多個序列進行排序，返回其索引值。

基本語法：numpy.lexsort(keys, axis=-1)

參數 描述
keys 類似於 (k, N) 的要排序的數組
axis 指定要排序的軸，默認對最後一個軸進行排序

舉例：現有數組 a = [1,5,1,4,3,4,4]，b = [9,4,0,4,0,2,1]，利用 lexsort() 函數排序後的結果爲：[2,0,4,6,5,3,1]，排序過程如下：

假設數組 a1 爲語文成績：a1 = [1,5,1,4,3,4,4]
假設數組 b1 爲數學成績：b1 = [9,4,0,4,0,2,1]
數組索引值 c1 爲同學姓名： c1 = [0,1,2,3,4,5,6]

1、首先按照語文成績進行排名：
語文成績（數組 a）從小到大排名：a2 = [1,1,3,4,4,4,5]，對應的學生姓名（索引值）爲：c2 = [0,2,4,3,5,6,1]，現在可以看到：
0、2 同學的語文成績都一樣，均爲 1
3、5、6 同學的語文成績都一樣，均爲 4

2、接下來，對於語文成績相同的，按照他們的數學成績再次進行排名：
0、2 同學對應的數學成績分別爲：9 和 0，從小到大再次排序，即 0 排在 2 的後面，對應的學生姓名爲 c3 = [2,0,4,3,5,6,1]
3、5、6 同學對應的數學成績分別爲：4、2、1，從小到大再次排序後，對應的學生姓名爲 c4 = [2,0,4,6,5,3,1]，即最終結果。

簡單來說，先對數組 a 從小到大排序，提取排序後元素對應的索引值，排序後元素有相同的，再根據數組 b 從小到大排序，得到最終的索引值。

以上步驟用 numpy.lexsort() 函數實現如下：

>>> import numpy as np
>>> a = [1,5,1,4,3,4,4]
>>> b = [9,4,0,4,0,2,1]
>>> 
>>> c1 = np.lexsort((a,b))    # 先按 b 排序，再按照 a 排序
>>> c2 = np.lexsort((b,a))    # 先按 a 排序，再按照 b 排序
>>> 
>>> print(c1)
[2 4 6 5 3 1 0]
>>> print(c2)
[2 0 4 6 5 3 1]
>>> 
>>> print([(a[i],b[i]) for i in c1])
[(1, 0), (3, 0), (4, 1), (4, 2), (4, 4), (5, 4), (1, 9)]
>>> print([(a[i],b[i]) for i in c2])
[(1, 0), (1, 9), (3, 0), (4, 1), (4, 2), (4, 4), (5, 4)]

>>> import numpy as np
>>> first_names = ('Hertz', 'Galilei', 'Hertz')
>>> second_names = ('Heinrich', 'Galileo', 'Gustav')
>>> 
>>> print(np.lexsort((second_names, first_names)))   # 按照字母對應的 ascii 碼從小到大進行排序
[1 2 0]

【5x05】sort_complex()

numpy.sort_complex() 函數先使用實部，再使用虛部對複數數組進行排序。

複數：把形如 z=a+bi（a,b 均爲實數）的數稱爲複數，其中 a 稱爲實部，b 稱爲虛部，i 稱爲虛數單位。

基本語法：numpy.sort_complex(a)

應用舉例：

>>> import numpy as np
>>> print(np.sort_complex([5, 3, 6, 2, 1]))
[1.+0.j 2.+0.j 3.+0.j 5.+0.j 6.+0.j]
>>> 
>>> print(np.sort_complex([1 + 2j, 2 - 1j, 3 - 2j, 3 - 3j, 3 + 5j]))
[1.+2.j 2.-1.j 3.-3.j 3.-2.j 3.+5.j]

【5x06】partition()

numpy.partition() 函數用於對數組進行分區排序，返回數組的分區副本。

基本語法：numpy.partition(a, kth[, axis=-1, kind='introselect', order=None])

參數 描述
a 待排序數組
kth 整數或者整數序列，原數組元素中從小到大的第 k 個元素，在排序後的數組中，仍然處於第 k 位置
小於該元素的位於該元素的左邊，大於該元素的位於該元素的右邊，左右兩邊沒有特別的排序要求
axis 指定要排序的軸，可選項，默認對最後一個軸進行排序
kind 排序算法，可選項，默認值爲快速排序（quicksort）
order 字符串或者字符串列表，可選項，若指定 order 值，將按照該字段進行排序

應用舉例：

>>> import numpy as np
>>> a = np.array([3, 4, 2, 1])
>>> print(np.partition(a, 3))       # 原數組元素中從小到大的第 3 個元素，排序後仍然處於第 3 位置，小於 3 的在前面，大於 3 的在後面，前後無特別排序要求
[2 1 3 4]
>>> 
>>> print(np.partition(a, (1, 3)))  # 小於 1 的在前面，大於 3 的在後面，1 和 3 之間的在中間
[1 2 3 4]

【5x07】argpartition()

numpy.argpartition() 函數用於對數組進行分區排序，返回重組後的索引值數組。

利用該函數可以很快地找出第 k 大的數的位置，以及大於 k（排在 k 後面）和小於 k（排在 k 前面）的數的位置。

基本語法：numpy.argpartition(a[, kth, axis=-1, kind='introselect', order=None])

參數 描述
a 待排序數組
kth 整數或者整數序列，原數組元素中從小到大的第 k 個元素，在排序後的數組中，仍然處於第 k 位置
小於該元素的位於該元素的左邊，大於該元素的位於該元素的右邊，左右兩邊沒有特別的排序要求
axis 指定要排序的軸，可選項，默認對最後一個軸進行排序
kind 排序算法，可選項，默認值爲快速排序（quicksort）
order 字符串或者字符串列表，可選項，若指定 order 值，將按照該字段進行排序

以下實例將找到數組的第 3 小（索引值 2）的值和第 2 大（索引值 -2）的值：

>>> import numpy as np
>>> a = np.array([46, 57, 23, 39, 1, 10, 0, 120])
>>> print(a[np.argpartition(a, 2)[2]])
10
>>> print(a[np.argpartition(a, -2)[-2]])
57

【5x08】unique()

numpy.unique() 函數找到唯一值並返回從小到大的排序結果，類似於 Python 的 set 集合。

應用舉例：

>>> import numpy as np
>>> print(np.unique([1, 1, 2, 2, 3, 3]))
[1 2 3]
>>> 
>>> a = np.array([[1, 0, 0], [1, 0, 0], [2, 3, 4]])
>>> print(np.unique(a, axis=0))
[[1 0 0]
 [2 3 4]]

【6x00】NumPy 條件函數

【6x01】nonzero()

numpy.nonzero() 函數將返回原數組中非零元素的索引值。

基本語法：numpy.nonzero(a)

應用舉例：

>>> import numpy as np
>>> a = np.array([[3, 0, 0], [0, 4, 0], [5, 6, 0]])
>>> print(np.nonzero(a))
(array([0, 1, 2, 2], dtype=int32), 
 array([0, 1, 0, 1], dtype=int32))

返回兩個數組，其中的元素一一對應，比如數字 3 的索引值爲 (0,0)，數字 4 的索引值爲 (1,1)

【6x02】where()

numpy.where() 函數返回數組中滿足指定條件的元素的索引值。

基本語法：numpy.where(condition[, x, y])

參數 描述
condition 判斷條件，如果滿足該條件，則產生 x，否則產生 y，若未指定 x 與 y，則返回滿足該條件元素的索引值
x, y 返回的值爲數組對象，如果滿足 condition，則產生 x，否則產生 y

應用舉例：

>>> import numpy as np
>>> a = np.array([12, 7, 9, 10, 21, 5, 11, 1])
>>>
>>> print(np.where(a>8))
(array([0, 2, 3, 4, 6], dtype=int32),)         # 返回滿足 a>8 的元素的索引值
>>> 
>>> print(np.where(a>8, a, 10*a))              # 如果原數組中的元素 a>8，則返回 a，否則返回 10*a
[12 70  9 10 21 50 11 10]

【6x03】extract()

numpy.extract() 函數返回數組中滿足指定條件的元素。

基本語法：numpy.extract(condition, arr)

參數 描述
condition 判斷條件
arr 原數組

應用舉例：

>>> import numpy as np
>>> a = np.array([12, 7, 9, 10, 21, 5, 11, 1])
>>> print(np.extract(a>8, a))
[12  9 10 21 11]

>>> import numpy as np
>>> a = np.arange(9).reshape(3,3)
>>> print(a)
[[0 1 2]
 [3 4 5]
 [6 7 8]]
>>> 
>>> condition = np.mod(a,2) == 0     # 定義篩選條件（餘數爲 0，即偶數）
>>> print(condition)
[[ True False  True]
 [False  True False]
 [ True False  True]]
>>>
>>> print(np.extract(condition, a))
[0 2 4 6 8]

【7x00】NumPy 判斷函數

【7x01】any() / all()

numpy.any()：如果至少有一個元素滿足指定條件，則返回 True，否則返回 False。

numpy.all()：如果所有的元素滿足指定條件，則返回 True，否則返回 False。

基本語法：numpy.any(a[, axis=None, out=None, keepdims=<no value>])；numpy.all(a[, axis=None, out=None, keepdims=<no value>])

參數 描述
a 待處理的數組對象
axis 指定軸，可選項，整數或者整數元組類型
out 可選項，放置結果的備用輸出數組，必須具有與預期輸出數組相同的形狀和緩衝區長度
keepdims bool 類型，可選項，是否保持數組的二維特性

應用舉例：

>>> import numpy as np
>>> print(np.any([[True, False], [True, True]]))
True
>>> 
>>> a = np.array([-3, -2, 4, 2, 8, 1])
>>> print(np.any(a<0))
True

>>> import numpy as np
>>> print(np.all([[True, False], [True, True]]))
False
>>> 
>>> a = np.array([-3, -2, 4, 2, 8, 1])
>>> print(np.all(a<0))
False

這裏是一段防爬蟲文本，請讀者忽略。
本文原創首發於 CSDN，作者 TRHX。
博客首頁：https://itrhx.blog.csdn.net/
本文鏈接：https://itrhx.blog.csdn.net/article/details/105398131
未經授權，禁止轉載！惡意轉載，後果自負！尊重原創，遠離剽竊！
發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

Python 數據分析三劍客之 NumPy（二）：數組索引 / 切片 / 廣播 / 拼接 / 分割

CSDN 課程推薦：《Python 數據分析與挖掘》，講師劉順祥，浙江工商大學統計學碩士，數據分析師，曾擔任唯品會大數據部擔任數據分析師一職，負責支付環節的數據分析業務。曾與聯想、亨氏、網魚網咖等企業合作多個企業級項目。

TRHX • 鲍勃 2020-06-20 23:29:12

Python 數據分析三劍客之 NumPy（一）：理解 NumPy / 數組基礎

CSDN 課程推薦：《Python 數據分析與挖掘》，講師劉順祥，浙江工商大學統計學碩士，數據分析師，曾擔任唯品會大數據部擔任數據分析師一職，負責支付環節的數據分析業務。曾與聯想、亨氏、網魚網咖等企業合作多個企業級項目。

TRHX • 鲍勃 2020-06-20 23:29:12

Python 數據分析三劍客之 NumPy（三）：數組的迭代與位運算

CSDN 課程推薦：《Python 數據分析與挖掘》，講師劉順祥，浙江工商大學統計學碩士，數據分析師，曾擔任唯品會大數據部擔任數據分析師一職，負責支付環節的數據分析業務。曾與聯想、亨氏、網魚網咖等企業合作多個企業級項目。

TRHX • 鲍勃 2020-06-20 23:29:11

Python 數據分析三劍客之 NumPy（四）：字符串函數總結與對比

CSDN 課程推薦：《Python 數據分析與挖掘》，講師劉順祥，浙江工商大學統計學碩士，數據分析師，曾擔任唯品會大數據部擔任數據分析師一職，負責支付環節的數據分析業務。曾與聯想、亨氏、網魚網咖等企業合作多個企業級項目。

TRHX • 鲍勃 2020-06-20 23:29:11

[Python3] NumPy基礎

文章目錄一、創建數組二、數組操作類型1. 數組屬性2. 數組索引：獲取單個元素3. 切片4. 數組的變形5. 數組拼接和分裂三、數組計算：通用函數四、聚合五、數組計算：廣播六、比較、掩碼和布爾邏輯1. 比較2. 操作布爾數組3.

TreasureAI 2020-06-15 22:48:34

Python 數據分析三劍客之 NumPy（六）：矩陣 / 線性代數庫與 IO 操作

TRHX • 鲍勃 2020-04-19 02:24:14

Python 數據分析三劍客之 NumPy（五）：最全數學 / 算術 / 統計 / 排序 / 條件 / 判斷函數合集

TRHX • 鲍勃 2020-04-14 01:44:42

Python 數據分析三劍客之 NumPy（一）：理解 NumPy，數組基礎

TRHX 2020-03-21 10:44:31

Python 中 NumPy 的數據類型

止步听风 2020-03-04 05:40:47

Python 中 NumPy 的子類化 ndarray

止步听风 2020-02-28 01:20:26

Python 中 NumPy 的結構化數組

止步听风 2020-02-28 01:20:26

Python 中 NumPy 的輸入輸出

止步听风 2020-02-28 01:20:26

Python 中 NumPy 編寫自定義數組容器

止步听风 2020-02-28 01:20:26

NumPy 中 asarray 的用法

止步听风 2020-02-28 01:20:26

Python 中 NumPy 的廣播

止步听风 2020-02-28 01:20:26