當前位置：首頁 > 编程语言 > python >内容正文

python

Python 数据分析三剑客之 NumPy（五）：数学 / 算术 / 统计 / 排序 / 条件 / 判断函数合集

發布時間：2023/12/10 python 25 豆豆

生活随笔收集整理的這篇文章主要介紹了 Python 数据分析三剑客之 NumPy（五）：数学 / 算术 / 统计 / 排序 / 条件 / 判断函数合集小編覺得挺不錯的,現在分享給大家,幫大家做個參考.

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

NumPy 系列文章：

Python 數據分析三劍客之 NumPy（一）：理解 NumPy / 數組基礎
Python 數據分析三劍客之 NumPy（二）：數組索引 / 切片 / 廣播 / 拼接 / 分割
Python 數據分析三劍客之 NumPy（三）：數組的迭代與位運算
Python 數據分析三劍客之 NumPy（四）：字符串函數總結與對比
Python 數據分析三劍客之 NumPy（五）：數學 / 算術 / 統計 / 排序 / 條件 / 判斷函數合集
Python 數據分析三劍客之 NumPy（六）：矩陣 / 線性代數庫與 IO 操作

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

Pandas 系列文章：https://itrhx.blog.csdn.net/category_9780397.html
Matplotlib 系列文章：https://itrhx.blog.csdn.net/category_9780418.html

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

NumPy 官方中文網：https://www.numpy.org.cn/
Pandas 官方中文網：https://www.pypandas.cn/
Matplotlib 官方中文網：https://www.matplotlib.org.cn/
NumPy、Matplotlib、Pandas 速查表：https://github.com/TRHX/Python-quick-reference-table

文章目錄

- 【1x00】NumPy 函數速查表
- 【2x00】NumPy 數學函數
- - 【2x01】sin() / cos() / tan()
  - 【2x02】arcsin() / arccos() / arctan()
  - 【2x03】around() / rint() / floor() / ceil()
- 【3x00】NumPy 算術函數
- - 【3x01】add() / subtract() / multiply() / divide()
  - 【3x02】reciprocal() / power() / mod() / remainder()
  - 【3x03】absolute() / isnan()
- 【4x00】NumPy 統計函數
- - 【4x01】amax() / amin()
  - 【4x02】argmax() / argmin()
  - 【4x03】sum()
  - 【4x04】cumsum() / cumprod()
  - 【4x05】ptp()
  - 【4x06】percentile()
  - 【4x07】median()
  - 【4x08】mean()
  - 【4x09】average()
  - 【4x10】std() / var()
- 【5x00】NumPy 排序函數
- - 【5x01】sort()
  - 【5x02】msort()
  - 【5x03】argsort()
  - 【5x04】lexsort()
  - 【5x05】sort_complex()
  - 【5x06】partition()
  - 【5x07】argpartition()
  - 【5x08】unique()
- 【6x00】NumPy 條件函數
- - 【6x01】nonzero()
  - 【6x02】where()
  - 【6x03】extract()
- 【7x00】NumPy 判斷函數
- - 【7x01】any() / all()

這里是一段防爬蟲文本，請讀者忽略。本文原創首發于 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() 分別用于計算數組元素的標準差與方差。

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

方差為 S²，標準差為 S，計算公式如下：

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

$\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]

【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

總結

以上是生活随笔為你收集整理的Python 数据分析三剑客之 NumPy（五）：数学 / 算术 / 统计 / 排序 / 条件 / 判断函数合集的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。

上一篇：周星驰迎60岁生日：回顾经典造型网友直
下一篇： Python 数据分析三剑客之 Matp