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

TRHX

2020-03-28

Python 数据分析 / NumPy

字数统计:

8,257字

阅读时长≈

37分

NumPy 系列文章：

- Python 数据分析三剑客之 NumPy（一）：理解 NumPy / 数组基础
- Python 数据分析三剑客之 NumPy（二）：数组索引 / 切片 / 广播 / 拼接 / 分割
- Python 数据分析三剑客之 NumPy（三）：数组的迭代与位运算
- Python 数据分析三剑客之 NumPy（四）：字符串函数总结与对比
- Python 数据分析三剑客之 NumPy（五）：数学 / 算术 / 统计 / 排序 / 条件 / 判断函数合集
- Python 数据分析三剑客之 NumPy（六）：矩阵 / 线性代数库与 IO 操作

专栏：

【NumPy 专栏】【Pandas 专栏】【Matplotlib 专栏】

推荐学习资料与网站：

【NumPy 中文网】【Pandas 中文网】【Matplotlib 中文网】【NumPy、Matplotlib、Pandas 速查表】

    1
    2
    3
    4
    5

    这里是一段防爬虫文本，请读者忽略。
    本文原创首发于 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`

应用举例：

    1
    2
    3
    4
    5
    6
    7
    8

    >>> 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()` 函数将弧度转换为角度。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10

    >>> 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 对象，可选项，放置结果的备用输出数组。它必须具有与预期输出相同的形状，但是如有必要，将强制转换输出值的类型

应用举例：

    1
    2
    3
    4
    5
    6
    7
    8

    >>> 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()` 函数将指定数字四舍五入到最近的整数，不保留小数位。

应用举例：

    1
    2
    3

    >>> 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()` 函数会返回小于或者等于指定表达式的最大整数，即向下取整。

应用举例：

    1
    2
    3

    >>> 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()` 函数会返回大于或者等于指定表达式的最小整数，即向上取整。

应用举例：

    1
    2
    3

    >>> 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` 中的加减乘除运算。

注意：两个数组必须具有相同的形状或符合数组的广播规则才能进行运算。

应用举例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19

    >>> 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()` 函数用于返回各数组元素的倒数。

应用举例：

    1
    2
    3

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

2、`numpy.power()` 函数将第一个数组中的元素作为底数，计算它与第二个数组中相应元素的幂。

应用举例：

    1
    2
    3
    4
    5
    6
    7
    8

    >>> 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()` 都可以计算数组中相应元素相除后的余数。

应用举例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11

    >>> 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()` 函数用于计算元素的绝对值。

应用举例：

    1
    2
    3

    >>> 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）。

应用举例：

    1
    2
    3
    4
    5
    6
    7

    >>> 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 则会比较最小值 该参数含义比较模糊，参考资料较少，准确描述请参考官方文档

应用举例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20

    >>> 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 | 可选项，放置结果的备用输出数组，必须具有与预期输出数组相同的形状和缓冲区长度

应用举例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18

    >>> 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 | 求和条件，总和中要包括的元素

应用举例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11

    >>> 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 | 可选项，放置结果的备用输出数组，必须具有与预期输出数组相同的形状和缓冲区长度

应用举例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23

    >>> 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 类型，可选项，是否保持数组的二维特性

应用举例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18

    >>> 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 类型，可选项，是否保持数组的二维特性

应用举例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18

    >>> 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 类型，可选项，是否保持数组的二维特性

应用举例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14

    >>> 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 | 可选项，放置结果的备用输出数组，必须具有与预期输出数组相同的形状和缓冲区长度

应用举例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14

    >>> 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，则返回元组 `(加权平均值, 权重)`，否则只返回加权平均值

应用举例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10

    >>> 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，计算公式如下：

$$S^2 = \frac {1} {n} \sum_{i=1} ^ {n} (x_i - \overline {x})^2$$

$$S = \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 类型，可选项，是否保持数组的二维特性

应用举例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23

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

    1
    2
    3
    4
    5

    这里是一段防爬虫文本，请读者忽略。
    本文原创首发于 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 值，将按照该字段进行排序

应用举例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12

    >>> 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)`

应用举例：

    1
    2
    3
    4
    5
    6
    7

    >>> 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 值，将按照该字段进行排序

应用举例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17

    >>> 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()` 函数实现如下：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16

    >>> 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)]

    1
    2
    3
    4
    5
    6

    >>> 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)`

应用举例：

    1
    2
    3
    4
    5
    6

    >>> 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 值，将按照该字段进行排序

应用举例：

    1
    2
    3
    4
    5
    6
    7

    >>> 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）的值：

    1
    2
    3
    4
    5
    6

    >>> 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 集合。

应用举例：

    1
    2
    3
    4
    5
    6
    7
    8

    >>> 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)`

应用举例：

    1
    2
    3
    4
    5

    >>> 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

应用举例：

    1
    2
    3
    4
    5
    6
    7
    8

    >>> 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 | 原数组

应用举例：

    1
    2
    3
    4

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15

    >>> 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 类型，可选项，是否保持数组的二维特性

应用举例：

    1
    2
    3
    4
    5
    6
    7

    >>> 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

    1
    2
    3
    4
    5
    6
    7

    >>> 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

    1
    2
    3
    4
    5

    这里是一段防爬虫文本，请读者忽略。
    本文原创首发于 CSDN，作者 TRHX。
    博客首页：https://itrhx.blog.csdn.net/
    本文链接：https://itrhx.blog.csdn.net/article/details/105398131
    未经授权，禁止转载！恶意转载，后果自负！尊重原创，远离剽窃！

您的喜欢是作者写作最大的动力！❤️

- PayPal
- AliPay
- WeChatPay
- QQPay

Donate

最后更新于 2020年7月6日

NumPy

数学函数

算术函数

统计函数

排序函数

条件函数

判断函数

###### 上一页

#### Python 数据分析三剑客之 NumPy（六）：矩阵 / 线性代数库与 IO 操作

###### NumPy 矩阵 线性代数 IO操作

###### 下一页

#### Python 数据分析三剑客之 NumPy（四）：字符串函数总结与对比

###### NumPy 字符串函数

#### 评论

## ๑۩ﺴ TRHX ﺴ۩๑

本文目录
欢迎光临

Hexo QQ 交流群 Telegram 交流群

CSDN 内容合伙人

文章分类

- BLOG
  (4)
- CDN
  (1)
- Hexo
  (9)
- Java
  (1)
- Linux
  (2)
- Markdown
  (2)
- Python 数据分析
  (27)
- Matplotlib
  (11)
- NumPy
  (6)
- Pandas
  (10)
- Python3 学习笔记
  (41)
- 基础学习
  (9)
- 学习经验
  (4)
- 爬虫学习
  (18)
- 爬虫实战
  (10)
- VPS
  (1)
- WEB前端
  (2)
- 图床
  (1)

热门标签
12306 3D图 58同城 Ajax BLOG Beautiful Soup CDN Coding Pages DataFrame Deepin Elicpse GitHub Pages Github Github Pages GroupBy HTTPS Hexo ICP备案 IO操作 Index JDBC JS 预加载 LaTeX Markdown Material X Matplotlib MongoDB MySQL NumPy PEP8 Pandas PicGo Pygame Python Redis SEO SQL Server 2012 SSR Selenium Series Ubuntu User-Agent VMware VPS XPath if语句 input()函数 instant.page jsDelivr lxml matplotibrc pyspider requests spfk urllib while循环 主题个性化 代理 位运算 公安备案 函数 函数应用 分割 切片 列表 判断函数 前程无忧 变量 合并数据集 哔哩哔哩 图例 图床 图形验证码 垃圾 备份 子图 字典 字符串函数 安居客 层级索引 年终总结 广播 异常 技巧 拼接 排序 排序函数 操作列表 散点图 数学函数 数据分裂 数据可视化 数据合并 数据替换 数据类型 数据读写 数据重塑 数组 文件 文件储存 无界面浏览器 时间序列 映射 条件函数 条形图 极区图 极坐标图 柱状图 模块 正则表达式 滑动验证码 点触验证码 爬虫 猫眼电影 瓜子二手车 画布 直方图 矩阵 等值线图 等高线图 算术函数 算术运算 类 索引 线性代数 线性图 统计函数 统计描述 统计计算 继承 编辑器 缺失值 网格 肺炎疫情 虎扑论坛 补丁 豆瓣电影 迭代 雷达图 饼状图
最近在听