NumPy 1.26 中文文档（四十一）

原文：numpy.org/doc/

numpy.isin

原文：numpy.org/doc/1.26/reference/generated/numpy.isin.html

numpy.isin(element, test_elements, assume_unique=False, invert=False, *, kind=None)

计算 element 在 test_elements 中的存在，仅广播 element。返回一个与 element 相同形状的布尔数组，其中 element 的元素在 test_elements 中为 True，否则为 False。

参数：

elementarray_like

输入数组。

test_elementsarray_like

要测试每个 element 的值。如果它是一个数组或类似数组，则该参数将被展平。查看非类数组参数的行为的注意事项。

assume_uniquebool，可选

如果为 True，则假定输入数组都是唯一的，这可以加快计算速度。默认为 False。

invertbool，可选

如果为 True，则返回数组中的值将被反转，就像计算 element not in test_elements 一样。默认为 False。np.isin(a, b, invert=True) 等同于（但比）np.invert(np.isin(a, b)) 更快。

种类{None, ‘sort’, ‘table’}，可选

要使用的算法。这不会影响最终结果，但会影响速度和内存使用。默认情况下，None 将根据内存考虑自动选择。

• 如果为 ‘sort’，将使用基于归并排序的方法。这将大致使用 ar1 和 ar2 大小之和的 6 倍的内存，不考虑 dtype 的大小。
• 如果为 ‘table’，将使用类似于计数排序的查找表方法。这仅适用于布尔和整数数组。当使用 ‘table’ 选项时，assume_unique 不起作用。
• 如果为 None，则如果所需内存分配小于或等于 ar1 和 ar2 大小之和的 6 倍，则会自动选择 ‘table’，否则将使用 ‘sort’。这样做是为了不默认使用大量内存，即使在大多数情况下 ‘table’ 可能更快。如果选择了 ‘table’，assume_unique 将不起作用。

返回：

isinndarray，bool

具有与 element 相同的形状。element[isin] 中的值在 test_elements 中。

参见

in1d

此函数的展平版本。

numpy.lib.arraysetops

具有在数组中执行集合操作的其他函数的模块。

注意事项

isin 是 python 关键字 in 的逐元素函数版本。如果 a 和 b 是 1-D 序列，则 isin(a, b) 大致等同于 np.array([item in b for item in a])。

element 和 test_elements 如果尚未转换为数组，则会被转换为数组。如果 test_elements 是一个集合（或其他非序列集合），它将被转换为一个包含一个元素的对象数组，而不是包含 test_elements 中的值的数组。 这是由于 array 构造函数处理非序列集合的方式。将集合转换为列表通常会得到所期望的行为。

如果满足以下关系式：log10(len(ar2)) > (log10(max(ar2)-min(ar2)) - 2.27) / 0.927，那么使用 kind='table' 通常比 kind=’sort’ 更快，但可能会使用更多内存。 kind 的默认值将根据内存使用量自动选择，因此如果内存约束可以放宽，可以手动设置 kind='table'。

自 1.13.0 版开始新增。

示例

>>> element = 2*np.arange(4).reshape((2, 2))
>>> element
array([[0, 2],
 [4, 6]])
>>> test_elements = [1, 2, 4, 8]
>>> mask = np.isin(element, test_elements)
>>> mask
array([[False,  True],
 [ True, False]])
>>> element[mask]
array([2, 4]) 

匹配值的索引可以通过 nonzero 获得：

>>> np.nonzero(mask)
(array([0, 1]), array([1, 0])) 

测试也可以被反转：

>>> mask = np.isin(element, test_elements, invert=True)
>>> mask
array([[ True, False],
 [False,  True]])
>>> element[mask]
array([0, 6]) 

由于 array 处理集合的方式，以下操作无法按预期工作：

>>> test_set = {1, 2, 4, 8}
>>> np.isin(element, test_set)
array([[False, False],
 [False, False]]) 

将集合转换为列表会得到预期的结果：

>>> np.isin(element, list(test_set))
array([[False,  True],
 [ True, False]]) 

numpy.setdiff1d

原文：numpy.org/doc/1.26/reference/generated/numpy.setdiff1d.html

numpy.setdiff1d(ar1, ar2, assume_unique=False)

查找两个数组的差集。

返回ar1中存在而ar2中不存在的唯一值。

参数:

ar1 数组型

输入数组。

ar2 数组型

输入比较数组。

assume_unique 布尔型

如果为 True，则假定输入数组都是唯一的，这可以加速计算。默认值为 False。

返回:

setdiff1d 数组型

在ar1中的值的一维数组，这些值不在ar2中。当assume_unique=False时，结果是有序的，但如果输入是有序的，则仅在其他情况下进行排序。

另请参阅

numpy.lib.arraysetops

模块包含了许多其他用于数组上执行集合操作的函数。

示例

>>> a = np.array([1, 2, 3, 2, 4, 1])
>>> b = np.array([3, 4, 5, 6])
>>> np.setdiff1d(a, b)
array([1, 2]) 

numpy.setxor1d

原文：numpy.org/doc/1.26/reference/generated/numpy.setxor1d.html

numpy.setxor1d(ar1, ar2, assume_unique=False)

查找两个数组的集合异或。

返回仅存在于两个输入数组中的排序、唯一值。

参数：

ar1, ar2：数组样式

输入数组。

assume_unique：布尔值

如果为真，则假定输入数组都是唯一的，这可以加快计算速度。默认为假。

返回值：

setxor1d：ndarray

排序的一维数组，其中包含仅存在于两个输入数组中的唯一值。

示例：

>>> a = np.array([1, 2, 3, 2, 4])
>>> b = np.array([2, 3, 5, 7, 5])
>>> np.setxor1d(a,b)
array([1, 4, 5, 7]) 

numpy.union1d

原文：numpy.org/doc/1.26/reference/generated/numpy.union1d.html

numpy.union1d(ar1, ar2)

找到两个数组的并集。

返回两个输入数组中任一数组中的唯一、排序后的值数组。

参数：

ar1, ar2array_like

输入数组。如果它们不是 1D，则会被展平。

返回：

union1dndarray

输入数组的唯一、排序后的并集。

另请参阅

numpy.lib.arraysetops

该模块包含许多其他用于在数组上执行集合操作的函数。

示例

>>> np.union1d([-1, 0, 1], [-2, 0, 2])
array([-2, -1,  0,  1,  2]) 

要找到多于两个数组的并集，请使用 functools.reduce：

>>> from functools import reduce
>>> reduce(np.union1d, ([1, 3, 4, 3], [3, 1, 2, 1], [6, 3, 4, 2]))
array([1, 2, 3, 4, 6]) 

Sorting, searching, and counting

原文：numpy.org/doc/1.26/reference/routines.sort.html

Sorting

Searching

Counting

Sorting

Searching

Counting

numpy.sort

原文：numpy.org/doc/1.26/reference/generated/numpy.sort.html

numpy.sort(a, axis=-1, kind=None, order=None)

返回数组的排序副本。

参数：

a类似数组

要排序的数组。

axisint 或 None，可选

用于排序的轴。如果为 None，则在排序之前将数组扁平化。默认值为-1，表示沿着最后一个轴排序。

kind{‘quicksort’, ‘mergesort’, ‘heapsort’, ‘stable’}，可选

排序算法。默认为‘quicksort’。请注意，‘stable’和‘mergesort’都在底层使用 timsort 或基数排序，一般情况下，实际实现会根据数据类型而有所不同。‘mergesort’选项保留供向后兼容使用。

1.15.0 版更改：增加了‘stable’选项。

orderstr 或 str 列表，可选

当 a 是已定义字段的数组时，此参数指定首选比较的字段顺序，第一、第二等。可以将单个字段指定为字符串，不需要指定所有字段，但未指定字段仍将按照它们在 dtype 中出现的顺序用于打破关系。

返回：

sorted_arrayndarray

与 a 类型和形状相同的数组。

另请参见

ndarray.sort

在原位对数组进行排序的方法。

argsort

间接排序。

lexsort

多个键的间接稳定排序。

searchsorted

在排序数组中查找元素。

partition

部分排序。

注意事项

各种排序算法的特点在于它们的平均速度、最坏情况性能、工作空间大小以及它们是否稳定。稳定排序会保持具有相同键的项在相对顺序中保持一致。NumPy 中实现的四种算法具有以下属性：

注意

数据类型确定实际使用的是‘mergesort’还是‘timsort’，即使指定了‘mergesort’。目前不提供更细粒度的用户选择。

所有排序算法在除了最后一个轴之外的任何轴上排序时都会对数据进行临时复制。因此，沿着最后一个轴排序比沿着其他任何轴排序更快，并且使用的空间更少。

对于复数，排序顺序是词典序。如果实部和虚部都不是 NaN，则顺序由实部确定，除非它们相等，在这种情况下，顺序由虚部确定。

在 numpy 1.4.0 之前，对包含 nan 值的实数和复数数组进行排序会导致未定义的行为。在 numpy 版本>= 1.4.0 中，nan 值被排序到末尾。扩展的排序顺序是：

• 实数：[R, nan]
• 复数：[R + Rj, R + nanj, nan + Rj, nan + nanj]

其中 R 是一个非 nan 实数值。具有相同 nan 位置的复数值根据非 nan 部分（如果存在）进行排序。非 nan 值按照以前的方式进行排序。

新版本 1.12.0 中新增。

quicksort 已更改为introsort。当排序没有足够的进展时，它会切换到heapsort。这种实现使得 quicksort 在最坏情况下为 O(n*log(n))。

‘stable’会自动选择最适合数据类型的稳定排序算法。它，以及‘mergesort’目前映射到timsort或基数排序，具体取决于数据类型。API 向前兼容性目前限制了选择实现的能力，并且对于不同的数据类型是硬编码的。

新版本 1.17.0 中新增。

Timsort 用于在已经或几乎排序的数据上获得更好的性能。在随机数据上，timsort 几乎与 mergesort 相同。现在它用于稳定排序，而 quicksort 仍然是默认排序（如果没有选择）。有关 timsort 的详细信息，请参考CPython listsort.txt。‘mergesort’和‘stable’映射到基数排序以用于整数数据类型。基数排序是 O(n)排序，而不是 O(n log n)。

在版本 1.18.0 中更改。

NaT 现在为了与 NaN 一致性而排序到数组末尾。

例子

>>> a = np.array([[1,4],[3,1]])
>>> np.sort(a)                # sort along the last axis
array([[1, 4],
 [1, 3]])
>>> np.sort(a, axis=None)     # sort the flattened array
array([1, 1, 3, 4])
>>> np.sort(a, axis=0)        # sort along the first axis
array([[1, 1],
 [3, 4]]) 

使用order关键字指定在对结构化数组进行排序时要使用的字段：

>>> 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)       # create a structured array
>>> np.sort(a, order='height')                        
array([('Galahad', 1.7, 38), ('Arthur', 1.8, 41),
 ('Lancelot', 1.8999999999999999, 38)],
 dtype=[('name', '|S10'), ('height', '<f8'), ('age', '<i4')]) 

按年龄排序，如果年龄相等，则按身高排序：

>>> np.sort(a, order=['age', 'height'])               
array([('Galahad', 1.7, 38), ('Lancelot', 1.8999999999999999, 38),
 ('Arthur', 1.8, 41)],
 dtype=[('name', '|S10'), ('height', '<f8'), ('age', '<i4')]) 

numpy.lexsort

原文：numpy.org/doc/1.26/reference/generated/numpy.lexsort.html

numpy.lexsort(keys, axis=-1)

使用一系列键执行间接稳定排序。

给定多个排序键，可以将其解释为电子表格中的列，lexsort 返回一个整数索引数组，描述了按多个列排序的顺序。序列中的最后一个键用于主要排序顺序，倒数第二个键用于次要排序顺序，依此类推。键参数必须是可以转换为相同形状数组的对象序列。如果为键参数提供了一个 2D 数组，则其行被解释为排序键，并且排序是根据最后一行、倒数第二行等进行的。

参数：

keys(k, N) 包含 k 个 (N,)-shaped 序列的数组或元组

k 不同的“列”要进行排序。最后一列（如果keys是一个 2D 数组，则为最后一行）是主要排序键。

axisint，可选

要进行间接排序的轴。默认情况下，对最后一个轴进行排序。

返回：

indices(N,) 整数的 ndarray

沿指定轴对键进行排序的索引数组。

另请参阅

argsort

间接排序。

ndarray.sort

原地排序。

sort

返回数组的排序副本。

示例

按姓氏排序：先按姓氏，再按名字。

>>> surnames =    ('Hertz',    'Galilei', 'Hertz')
>>> first_names = ('Heinrich', 'Galileo', 'Gustav')
>>> ind = np.lexsort((first_names, surnames))
>>> ind
array([1, 2, 0]) 

>>> [surnames[i] + ", " + first_names[i] for i in ind]
['Galilei, Galileo', 'Hertz, Gustav', 'Hertz, Heinrich'] 

对两列数字进行排序：

>>> a = [1,5,1,4,3,4,4] # First column
>>> b = [9,4,0,4,0,2,1] # Second column
>>> ind = np.lexsort((b,a)) # Sort by a, then by b
>>> ind
array([2, 0, 4, 6, 5, 3, 1]) 

>>> [(a[i],b[i]) for i in ind]
[(1, 0), (1, 9), (3, 0), (4, 1), (4, 2), (4, 4), (5, 4)] 

请注意，首先根据a的元素进行排序。次要排序是根据b的元素进行的。

正常的argsort将产生：

>>> [(a[i],b[i]) for i in np.argsort(a)]
[(1, 9), (1, 0), (3, 0), (4, 4), (4, 2), (4, 1), (5, 4)] 

结构化数组通过argsort按字典顺序排序：

>>> x = np.array([(1,9), (5,4), (1,0), (4,4), (3,0), (4,2), (4,1)],
...              dtype=np.dtype([('x', int), ('y', int)])) 

>>> np.argsort(x) # or np.argsort(x, order=('x', 'y'))
array([2, 0, 4, 6, 5, 3, 1]) 

numpy.argsort

原文：numpy.org/doc/1.26/reference/generated/numpy.argsort.html

numpy.argsort(a, axis=-1, kind=None, order=None)

返回将数组排序的索引。

使用由kind关键字指定的算法沿给定轴进行间接排序。它返回一个与a形状相同的索引数组，按照排序顺序索引沿给定轴的数据。

参数:

aarray_like

要排序的数组。

axisint 或 None，可选

用于排序的轴。默认为-1（最后一个轴）。如果为 None，则使用扁平化的数组。

kind{‘quicksort’, ‘mergesort’, ‘heapsort’, ‘stable’}, 可选

排序算法。默认为“quicksort”。请注意，“stable”和“mergesort”都在内部使用 timsort，一般情况下，实际实现会随数据类型而变化。保留“mergesort”选项是为了向后兼容性。

1.15.0 版本更改：添加了“stable”选项。

orderstr 或 str 列表，可选

当a是一个定义了字段的数组时，此参数指定首先比较哪些字段，第二个字段等等。可以将单个字段指定为字符串，并且不需要指定所有字段，但未指定的字段仍将按照它们在 dtype 中出现的顺序来使用，以打破平局。

返回:

index_arrayndarray, int

沿指定axis对a进行排序的索引数组。如果a是一维的，则a[index_array]会产生一个排序后的a。更一般地，np.take_along_axis(a, index_array, axis=axis)始终产生排序后的a，无论维度如何。

参见

sort

描述所使用的排序算法。

lexsort

使用多个键进行间接稳定排序。

ndarray.sort

原地排序。

argpartition

间接部分排序。

take_along_axis

将 argsort 中的index_array应用于数组，就像调用 sort 一样。

注意

有关不同排序算法的说明，请参见sort。

截至 NumPy 1.4.0，argsort可用于包含 nan 值的实数/复数数组。增强的排序顺序在sort中有文档记录。

示例

一维数组:

>>> x = np.array([3, 1, 2])
>>> np.argsort(x)
array([1, 2, 0]) 

二维数组:

>>> x = np.array([[0, 3], [2, 2]])
>>> x
array([[0, 3],
 [2, 2]]) 

>>> ind = np.argsort(x, axis=0)  # sorts along first axis (down)
>>> ind
array([[0, 1],
 [1, 0]])
>>> np.take_along_axis(x, ind, axis=0)  # same as np.sort(x, axis=0)
array([[0, 2],
 [2, 3]]) 

>>> ind = np.argsort(x, axis=1)  # sorts along last axis (across)
>>> ind
array([[0, 1],
 [0, 1]])
>>> np.take_along_axis(x, ind, axis=1)  # same as np.sort(x, axis=1)
array([[0, 3],
 [2, 2]]) 

N 维数组的排序元素的索引:

>>> ind = np.unravel_index(np.argsort(x, axis=None), x.shape)
>>> ind
(array([0, 1, 1, 0]), array([0, 0, 1, 1]))
>>> x[ind]  # same as np.sort(x, axis=None)
array([0, 2, 2, 3]) 

使用键进行排序:

>>> x = np.array([(1, 0), (0, 1)], dtype=[('x', '<i4'), ('y', '<i4')])
>>> x
array([(1, 0), (0, 1)],
 dtype=[('x', '<i4'), ('y', '<i4')]) 

>>> np.argsort(x, order=('x','y'))
array([1, 0]) 

>>> np.argsort(x, order=('y','x'))
array([0, 1]) 

numpy.ndarray.sort

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.sort.html

方法

ndarray.sort(axis=-1, kind=None, order=None)

就地对数组进行排序。有关完整文档，请参阅numpy.sort。

参数：

axisint, 可选

排序的轴。默认为-1，表示沿着最后一个轴排序。

kind{‘quicksort’, ‘mergesort’, ‘heapsort’, ‘stable’}, 可选

排序算法。默认为‘quicksort’。请注意，‘stable’和‘mergesort’都在底层使用 timsort，一般情况下，实际实现会随数据类型而变化。‘mergesort’选项保留用于向后兼容性。

1.15.0 版本更改：添加了‘stable’选项。

orderstr 或 str 列表，可选

当a是一个定义了字段的数组时，此参数指定首先比较哪些字段，第二个字段等。可以将单个字段指定为字符串，并且不需要指定所有字段，但未指定的字段仍将按照它们在 dtype 中出现的顺序来使用，以解决平局。

参见

numpy.sort

返回数组的排序副本。

numpy.argsort

间接排序。

numpy.lexsort

多个键的间接稳定排序。

numpy.searchsorted

在排序数组中查找元素。

numpy.partition

部分排序。

注意事项

有关不同排序算法的说明，请参见numpy.sort。

示例

>>> a = np.array([[1,4], [3,1]])
>>> a.sort(axis=1)
>>> a
array([[1, 4],
 [1, 3]])
>>> a.sort(axis=0)
>>> a
array([[1, 3],
 [1, 4]]) 

使用order关键字指定在对结构化数组进行排序时要使用的字段：

>>> a = np.array([('a', 2), ('c', 1)], dtype=[('x', 'S1'), ('y', int)])
>>> a.sort(order='y')
>>> a
array([(b'c', 1), (b'a', 2)],
 dtype=[('x', 'S1'), ('y', '<i8')]) 

numpy.sort_complex

numpy.org/doc/1.26/reference/generated/numpy.sort_complex.html

numpy.sort_complex(a)

使用实部首先，然后是虚部对复数数组进行排序。

参数：

a 类似数组

输入数组

返回：

out 复数 ndarray

始终返回排序后的复数数组。

示例

>>> np.sort_complex([5, 3, 6, 2, 1])
array([1.+0.j, 2.+0.j, 3.+0.j, 5.+0.j, 6.+0.j]) 

>>> np.sort_complex([1 + 2j, 2 - 1j, 3 - 2j, 3 - 3j, 3 + 5j])
array([1.+2.j,  2.-1.j,  3.-3.j,  3.-2.j,  3.+5.j]) 

numpy.partition

译文：numpy.org/doc/1.26/reference/generated/numpy.partition.html

numpy.partition(a, kth, axis=-1, kind='introselect', order=None)

返回数组的分区副本。

创建数组的副本，其元素重新排列，使得第 k 个位置的元素的值在排序数组中的位置。在分区数组中，所有在第 k 个元素之前的元素都小于或等于该元素，而在第 k 个元素之后的所有元素都大于或等于该元素。两个分区中元素的顺序是未定义的。

自版本 1.8.0 起新增。

参数：

a类似数组

要排序的数组。

kthint 或 int 序列

要按元素索引进行分区的元素。元素的第 k 个值将在其最终排序位置上，所有较小的元素将在其前面移动，所有相等或更大的元素将在其后面。分区中所有元素的顺序是未定义的。如果提供了一个 k-th 序列，它将一次将所有由它们的 k-th 索引的元素分区到它们的排序位置。

自版本 1.22.0 起弃用：将布尔值作为索引传递已弃用。

轴整数或 None，可选

要排序的轴。如果为 None，则在排序之前将数组展平。默认值为 -1，沿着最后一个轴排序。

种类{‘introselect’}，可选

选择算法。默认为 ‘introselect’。

顺序字符串或字符串列表，可选

当 a 是一个定义了字段的数组时，此参数指定首先比较哪些字段，其次是哪些字段等。可以将单个字段指定为字符串。不需要指定所有字段，但未指定的字段仍将按照它们在 dtype 中出现的顺序来解决冲突。

返回：

分区数组ndarray

与 a 相同类型和形状的数组。

另请参阅

ndarray.partition

在原地对数组进行排序的方法。

argpartition

间接分区。

sort

完全排序

笔记

各种选择算法的特点在于它们的平均速度、最坏情况性能、工作空间大小以及它们是否稳定。稳定排序会保持具有相同键的项目相对顺序不变。可用的算法具有以下特性：

所有分区算法在沿着除最后一个轴以外的任何轴进行分区时都会对数据进行临时复制。因此，沿着最后一个轴进行分区比沿着其他任何轴进行分区更快，使用的空间也更少。

复数的排序顺序是按字典顺序排列的。如果实部和虚部都不是 nan，则顺序由实部确定，除非它们相等，在这种情况下，顺序由虚部确定。

示例

>>> a = np.array([7, 1, 7, 7, 1, 5, 7, 2, 3, 2, 6, 2, 3, 0])
>>> p = np.partition(a, 4)
>>> p
array([0, 1, 2, 1, 2, 5, 2, 3, 3, 6, 7, 7, 7, 7]) 

p[4]为 2；p[:4]中的所有元素都小于或等于p[4]，p[5:]中的所有元素都大于或等于p[4]。划分如下：

[0, 1, 2, 1], [2], [5, 2, 3, 3, 6, 7, 7, 7, 7] 

下一个示例展示了传递给kth的多个值的使用。

>>> p2 = np.partition(a, (4, 8))
>>> p2
array([0, 1, 2, 1, 2, 3, 3, 2, 5, 6, 7, 7, 7, 7]) 

p2[4]为 2，p2[8]为 5。p2[:4]中的所有元素都小于或等于p2[4]，p2[5:8]中的所有元素都大于或等于p2[4]且小于或等于p2[8]，p2[9:]中的所有元素都大于或等于p2[8]。划分如下：

[0, 1, 2, 1], [2], [3, 3, 2], [5], [6, 7, 7, 7, 7] 

numpy.argpartition

原文：numpy.org/doc/1.26/reference/generated/numpy.argpartition.html

numpy.argpartition(a, kth, axis=-1, kind='introselect', order=None)

使用 kind 关键字指定的算法沿给定轴执行间接分区。它返回一个与 a 相同形状的索引数组，按照分区顺序索引给定轴上的数据。

自版本 1.8.0 起新增。

参数：

a类似数组

要排序的数组。

kth整数或整数序列

要按其进行分区的元素索引。第 k 个元素将处于其最终排序位置，所有较小的元素将在其前面移动，所有较大的元素将在其后面。分区中所有元素的顺序是未定义的。如果提供了 k-th 的序列，则会一次将它们全部分区到其排序位置。

自版本 1.22.0 起弃用：将布尔值作为索引已弃用。

axis整数或 None，可选

用于排序的轴。默认为 -1（最后一个轴）。如果为 None，则使用扁平化的数组。

kind{‘introselect’}，可选

选择算法。默认为 ‘introselect’

orderstr 或 str 列表，可选

当 a 是一个定义了字段的数组时，此参数指定首先比较哪些字段，第二个字段等。可以将单个字段指定为字符串，不需要指定所有字段，但未指定的字段仍将被使用，按照它们在 dtype 中出现的顺序来打破平局。

返回：

index_arrayndarray，整数

沿指定轴对 a 进行分区的索引数组。如果 a 是一维的，a[index_array] 会产生一个分区的 a。更一般地，np.take_along_axis(a, index_array, axis=axis) 总是产生分区的 a，无论维度如何。

另请参阅

partition

描述所使用的分区算法。

ndarray.partition

原地分区。

argsort

完全间接排序。

take_along_axis

将 argpartition 中的 index_array 应用于数组，就像调用分区一样。

注意

有关不同选择算法的说明，请参阅 partition。

示例

一维数组：

>>> x = np.array([3, 4, 2, 1])
>>> x[np.argpartition(x, 3)]
array([2, 1, 3, 4])
>>> x[np.argpartition(x, (1, 3))]
array([1, 2, 3, 4]) 

>>> x = [3, 4, 2, 1]
>>> np.array(x)[np.argpartition(x, 3)]
array([2, 1, 3, 4]) 

多维数组：

>>> x = np.array([[3, 4, 2], [1, 3, 1]])
>>> index_array = np.argpartition(x, kth=1, axis=-1)
>>> np.take_along_axis(x, index_array, axis=-1)  # same as np.partition(x, kth=1)
array([[2, 3, 4],
 [1, 1, 3]]) 

numpy.argmax

原文：numpy.org/doc/1.26/reference/generated/numpy.argmax.html

numpy.argmax(a, axis=None, out=None, *, keepdims=<no value>)

返回沿轴的最大值的索引。

参数：

aarray_like

输入数组。

axisint，可选

默认情况下，索引是到扁平数组，否则沿指定轴。

outarray，可选

如果提供，结果将插入到此数组中。它应具有适当的形状和 dtype。

keepdimsbool，可选

如果设置为 True，则被减少的轴将作为大小为一的维度保留在结果中。使用此选项，结果将正确地广播到数组。

1.22.0 版中的新内容。

返回：

index_arrayint 的 ndarray

索引数组。它与 a.shape 具有相同的形状，其中沿 axis 的维度已移除。如果 keepdims 设置为 True，则 axis 的大小将为 1，生成的数组将具有与 a.shape 相同的形状。

另请参见

ndarray.argmax, argmin

amax

沿给定轴的最大值。

unravel_index

将平坦索引转换为索引元组。

take_along_axis

将 np.expand_dims(index_array, axis) 从 argmax 应用到数组上，就像调用 max 一样。

注意

如果最大值出现多次，则返回对应于第一次出现的索引。

示例

>>> a = np.arange(6).reshape(2,3) + 10
>>> a
array([[10, 11, 12],
 [13, 14, 15]])
>>> np.argmax(a)
5
>>> np.argmax(a, axis=0)
array([1, 1, 1])
>>> np.argmax(a, axis=1)
array([2, 2]) 

N 维数组的最大元素的索引：

>>> ind = np.unravel_index(np.argmax(a, axis=None), a.shape)
>>> ind
(1, 2)
>>> a[ind]
15 

>>> b = np.arange(6)
>>> b[1] = 5
>>> b
array([0, 5, 2, 3, 4, 5])
>>> np.argmax(b)  # Only the first occurrence is returned.
1 

>>> x = np.array([[4,2,3], [1,0,3]])
>>> index_array = np.argmax(x, axis=-1)
>>> # Same as np.amax(x, axis=-1, keepdims=True)
>>> np.take_along_axis(x, np.expand_dims(index_array, axis=-1), axis=-1)
array([[4],
 [3]])
>>> # Same as np.amax(x, axis=-1)
>>> np.take_along_axis(x, np.expand_dims(index_array, axis=-1), axis=-1).squeeze(axis=-1)
array([4, 3]) 

将 keepdims 设置为 True，

>>> x = np.arange(24).reshape((2, 3, 4))
>>> res = np.argmax(x, axis=1, keepdims=True)
>>> res.shape
(2, 1, 4) 

numpy.nanargmax

原文：numpy.org/doc/1.26/reference/generated/numpy.nanargmax.html

numpy.nanargmax(a, axis=None, out=None, *, keepdims=<no value>)

返回指定轴上最大值的索引，忽略 NaN。对于全为 NaN 的切片，会引发ValueError。警告：如果一个切片只包含 NaN 和-Infs，则无法信任结果。

参数：

aarray_like

输入数据。

axisint，可选

沿其操作的轴。默认情况下使用扁平化的输入。

outarray，可选

如果提供了，结果将被插入到这个数组中。它应该具有适当的形状和 dtype。

新版本 1.22.0 中新增。

keepdimsbool，可选

如果设置为 True，则被减少的轴将作为大小为一的维度保留在结果中。使用此选项，结果将正确地广播到数组。

新版本 1.22.0 中新增。

返回：

index_arrayndarray

一个索引数组或单个索引值。

另请参阅

argmax，nanargmin

示例

>>> a = np.array([[np.nan, 4], [2, 3]])
>>> np.argmax(a)
0
>>> np.nanargmax(a)
1
>>> np.nanargmax(a, axis=0)
array([1, 0])
>>> np.nanargmax(a, axis=1)
array([1, 1]) 

numpy.argmin

原文：numpy.org/doc/1.26/reference/generated/numpy.argmin.html

numpy.argmin(a, axis=None, out=None, *, keepdims=<no value>)

返回沿轴的最小值的索引。

参数：

a类似数组

输入数组。

axis整数，可选

默认情况下，索引是进入扁平数组，否则沿指定轴。

out数组，可选

如果提供，结果将插入到此数组中。它应具有适当的形状和 dtype。

keepdims布尔值，可选

如果设置为 True，则被减少的轴将作为大小为一的维度保留在结果中。使用此选项，结果将正确地广播到数组。

在 1.22.0 版本中新增。

返回：

index_array整数的 ndarray

数组中的索引数组。它与a.shape具有相同的形状，沿axis的维度被移除。如果keepdims设置为 True，则axis的大小将为 1，生成的数组将具有与a.shape相同的形状。

另请参见

ndarray.argmin, argmax

amin

沿给定轴的最小值。

unravel_index

将一个扁平索引转换为索引元组。

take_along_axis

从 argmin 应用np.expand_dims(index_array, axis)到一个数组，就像调用 min 一样。

注意

在最小值出现多次的情况下，返回对应于第一次出现的索引。

示例

>>> a = np.arange(6).reshape(2,3) + 10
>>> a
array([[10, 11, 12],
 [13, 14, 15]])
>>> np.argmin(a)
0
>>> np.argmin(a, axis=0)
array([0, 0, 0])
>>> np.argmin(a, axis=1)
array([0, 0]) 

N 维数组的最小元素的索引：

>>> ind = np.unravel_index(np.argmin(a, axis=None), a.shape)
>>> ind
(0, 0)
>>> a[ind]
10 

>>> b = np.arange(6) + 10
>>> b[4] = 10
>>> b
array([10, 11, 12, 13, 10, 15])
>>> np.argmin(b)  # Only the first occurrence is returned.
0 

>>> x = np.array([[4,2,3], [1,0,3]])
>>> index_array = np.argmin(x, axis=-1)
>>> # Same as np.amin(x, axis=-1, keepdims=True)
>>> np.take_along_axis(x, np.expand_dims(index_array, axis=-1), axis=-1)
array([[2],
 [0]])
>>> # Same as np.amax(x, axis=-1)
>>> np.take_along_axis(x, np.expand_dims(index_array, axis=-1), axis=-1).squeeze(axis=-1)
array([2, 0]) 

将keepdims设置为True，

>>> x = np.arange(24).reshape((2, 3, 4))
>>> res = np.argmin(x, axis=1, keepdims=True)
>>> res.shape
(2, 1, 4) 

numpy.nanargmin

译文：numpy.org/doc/1.26/reference/generated/numpy.nanargmin.html

numpy.nanargmin(a, axis=None, out=None, *, keepdims=<no value>)

返回指定轴上最小值的索引，忽略 NaN。对于全 NaN 切片，会引发ValueError。警告：如果切片仅包含 NaN 和 Infs，则无法信任结果。

参数：

aarray_like

输入数据。

axisint，可选

操作的轴。默认使用扁平化的输入。

outarray，可选

如果提供，结果将被插入到此数组中。它应该具有适当的形状和数据类型。

新版本 1.22.0 中提供。

keepdimsbool，可选

如果设置为 True，则被减少的轴将作为大小为一的维度保留在结果中。使用此选项，结果将正确广播到数组。

新版本 1.22.0 中提供。

返回：

index_arrayndarray

一个索引数组或单个索引值。

另请参见

argmin, nanargmax

示例

>>> a = np.array([[np.nan, 4], [2, 3]])
>>> np.argmin(a)
0
>>> np.nanargmin(a)
2
>>> np.nanargmin(a, axis=0)
array([1, 1])
>>> np.nanargmin(a, axis=1)
array([1, 0]) 

numpy.argwhere

原文：numpy.org/doc/1.26/reference/generated/numpy.argwhere.html

numpy.argwhere(a)

找到非零元素的数组索引，按元素分组。

参数：

aarray_like

输入数据。

返回：

index_array(N, a.ndim) ndarray

非零元素的索引。索引按元素分组。该数组的形状为(N, a.ndim)，其中N是非零项的数量。

参见

where，nonzero

注意

np.argwhere(a) 几乎与 np.transpose(np.nonzero(a)) 相同，但对于 0D 数组产生了正确形状的结果。

argwhere 的输出不适合用于索引数组。为此，请使用 nonzero(a)。

示例

>>> x = np.arange(6).reshape(2,3)
>>> x
array([[0, 1, 2],
 [3, 4, 5]])
>>> np.argwhere(x>1)
array([[0, 2],
 [1, 0],
 [1, 1],
 [1, 2]]) 

numpy.nonzero

原文：numpy.org/doc/1.26/reference/generated/numpy.nonzero.html

numpy.nonzero(a)

返回非零元素的下标。

返回一个数组的元组，每个维度都包含该维度中非零元素的下标。 a 中的值始终以行为主测试和返回，C 样式排序。

要按元素而不是维度对下标进行分组，请使用argwhere，其将为每个非零元素返回一行。

注意

当在零维数组或标量上调用nonzero(a)时，会将其视为nonzero(atleast_1d(a))。

自版本 1.17.0 开始弃用：如果此行为是刻意的，请显式使用atleast_1d。

参数：

a类似数组

输入数组。

返回：

tuple_of_arrays数组

非零元素的下标。

参见

flatnonzero

返回输入数组的扁平版本中非零的下标。

ndarray.nonzero

等效的 ndarray 方法。

count_nonzero

计算输入数组中的非零元素的数量。

注解

尽管可以使用a[nonzero(a)]获得非零值，但建议改用x[x.astype(bool)]或x[x != 0]，这样可以正确处理 0 维数组。

示例

>>> x = np.array([[3, 0, 0], [0, 4, 0], [5, 6, 0]])
>>> x
array([[3, 0, 0],
 [0, 4, 0],
 [5, 6, 0]])
>>> np.nonzero(x)
(array([0, 1, 2, 2]), array([0, 1, 0, 1])) 

>>> x[np.nonzero(x)]
array([3, 4, 5, 6])
>>> np.transpose(np.nonzero(x))
array([[0, 0],
 [1, 1],
 [2, 0],
 [2, 1]]) 

nonzero的一个常见用法是找到数组的索引，其中条件为 True。给定数组 a，条件 a > 3 是一个布尔数组，因为 False 被解释为 0，np.nonzero(a > 3)产生条件为真的 a 的索引。

>>> a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
>>> a > 3
array([[False, False, False],
 [ True,  True,  True],
 [ True,  True,  True]])
>>> np.nonzero(a > 3)
(array([1, 1, 1, 2, 2, 2]), array([0, 1, 2, 0, 1, 2])) 

使用此结果索引 a 等同于直接使用掩码：

>>> a[np.nonzero(a > 3)]
array([4, 5, 6, 7, 8, 9])
>>> a[a > 3]  # prefer this spelling
array([4, 5, 6, 7, 8, 9]) 

nonzero也可以作为数组的方法调用。

>>> (a > 3).nonzero()
(array([1, 1, 1, 2, 2, 2]), array([0, 1, 2, 0, 1, 2])) 

numpy.flatnonzero

原文：numpy.org/doc/1.26/reference/generated/numpy.flatnonzero.html

numpy.flatnonzero(a)

返回扁平化版本 a 中非零的索引。

这相当于np.nonzero(np.ravel(a))[0]。

参数：

a数组样式

输入数据。

返回：

res数组

输出数组，包含a.ravel()中非零的元素的索引。

另请参见

nonzero

返回输入数组中非零元素的索引。

ravel

返回一个包含输入数组元素的 1-D 数组。

示例

>>> x = np.arange(-2, 3)
>>> x
array([-2, -1,  0,  1,  2])
>>> np.flatnonzero(x)
array([0, 1, 3, 4]) 

使用非零元素的索引作为索引数组来提取这些元素：

>>> x.ravel()[np.flatnonzero(x)]
array([-2, -1,  1,  2]) 

numpy.where

原文：numpy.org/doc/1.26/reference/generated/numpy.where.html

numpy.where(condition, [x, y, ]/)

根据 condition 从 x 或 y 中选择元素。

注

仅提供 condition 时，这函数就是 np.asarray(condition).nonzero() 的简写。应优先使用 nonzero，因为它对子类的行为正确。本文档余下部分仅适用于提供了三个参数的情况。

参数：

conditionarray_like, bool

在为 True 时产生 x，否则产生 y。

x, yarray_like

需要选择的值。 x、y 和 condition 需要能广播到某种形状。

返回：

outndarray

在 condition 为 True 时具有 x 的元素，其他情况下具有 y 的元素。

另请参阅

choose

nonzero

当省略 x 和 y 时调用的函数

注意事项

如果所有数组都是 1-D，则 where 相当于：

[xv if c else yv
 for c, xv, yv in zip(condition, x, y)] 

示例

>>> a = np.arange(10)
>>> a
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> np.where(a < 5, a, 10*a)
array([ 0,  1,  2,  3,  4, 50, 60, 70, 80, 90]) 

这也适用于多维数组：

>>> np.where([[True, False], [True, True]],
...          [[1, 2], [3, 4]],
...          [[9, 8], [7, 6]])
array([[1, 8],
 [3, 4]]) 

x、y 和 condition 的形状一起进行广播：

>>> x, y = np.ogrid[:3, :4]
>>> np.where(x < y, x, 10 + y)  # both x and 10+y are broadcast
array([[10,  0,  0,  0],
 [10, 11,  1,  1],
 [10, 11, 12,  2]]) 

>>> a = np.array([[0, 1, 2],
...               [0, 2, 4],
...               [0, 3, 6]])
>>> np.where(a < 4, a, -1)  # -1 is broadcast
array([[ 0,  1,  2],
 [ 0,  2, -1],
 [ 0,  3, -1]]) 

numpy.searchsorted

原文：numpy.org/doc/1.26/reference/generated/numpy.searchsorted.html

numpy.searchsorted(a, v, side='left', sorter=None)

查找应插入以保持顺序的元素的索引。

找到排序数组 a 中的索引，使得如果 v 的对应元素被插入到这些索引之前，a 的顺序将会被保留。

假设 a 已排序：

参数：

a1-D 数组样式

输入数组。如果 sorter 为 None，则必须按升序排列，否则 sorter 必须是一个对其进行排序的索引数组。

v数组样式

要插入到 a 中的值。

side{‘left’，‘right’}，可选

若为‘left’，则给出找到的第一个适当位置的索引。若为‘right’，则返回最后一个这样的索引。如果没有合适的索引，返回 0 或 N（其中 N 为a的长度）。

sorter1-D 数组样式，可选

整数索引数组，将数组a排序为升序。它们通常是 argsort 的结果。

版本 1.7.0 中的新内容。

返回：

indices整数或整数数组

具有与 v 相同形状的插入点数组，或者如果 v 是标量，则为整数。

另请参阅

sort

返回数组的排序副本。

histogram

从 1-D 数据生成直方图。

注意事项

二分搜索用于查找所需的插入点。

截至 NumPy 1.4.0，searchsorted 可与包含nan 值的实/复数数组一起使用。增强的排序顺序在sort 中有文档记录。

此函数使用与内置 python bisect.bisect_left (side='left') 和 bisect.bisect_right 函数相同的算法，也在 v 参数中向量化。

示例

>>> np.searchsorted([1,2,3,4,5], 3)
2
>>> np.searchsorted([1,2,3,4,5], 3, side='right')
3
>>> np.searchsorted([1,2,3,4,5], [-10, 10, 2, 3])
array([0, 5, 1, 2]) 

numpy.extract

原文：numpy.org/doc/1.26/reference/generated/numpy.extract.html

numpy.extract(condition, arr)

返回满足某些条件的数组元素。

这相当于np.compress(ravel(condition), ravel(arr))。如果condition是布尔类型，np.extract相当于arr[condition]。

请注意，place与extract完全相反。

参数：

conditionarray_like

一个非零或 True 的数组，指示要提取的arr中的元素。

arrarray_like

与condition大小相同的输入数组。

返回：

提取ndarray

condition为 True 时，从arr中提取的值为condition为 True 的值的一维数组。

另请参阅

take, put, copyto, compress, place

例子

>>> arr = np.arange(12).reshape((3, 4))
>>> arr
array([[ 0,  1,  2,  3],
 [ 4,  5,  6,  7],
 [ 8,  9, 10, 11]])
>>> condition = np.mod(arr, 3)==0
>>> condition
array([[ True, False, False,  True],
 [False, False,  True, False],
 [False,  True, False, False]])
>>> np.extract(condition, arr)
array([0, 3, 6, 9]) 

如果condition是布尔类型：

>>> arr[condition]
array([0, 3, 6, 9]) 

numpy.count_nonzero

原文：numpy.org/doc/1.26/reference/generated/numpy.count_nonzero.html

numpy.count_nonzero(a, axis=None, *, keepdims=False)

计算数组 a 中非零值的数量。

“非零”一词是指 Python 2.x 内置方法 __nonzero__()（在 Python 3.x 中更名为 __bool__()）对 Python 对象进行“真实性”测试。例如，如果一个数字非零，则被视为真实，而如果一个字符串不为空，则被视为真实。因此，该函数（递归地）计算 a 中有多少元素（及其中的子数组）的 __nonzero__() 或 __bool__() 方法评估为 True。

参数:

a类似数组

要计算非零值的数组。

axisint 或元组, 可选

沿其计算非零值的轴或轴的元组。默认为 None，意味着非零值将沿着 a 的扁平版本计算。

新版本 1.12.0 中加入。

keepdimsbool, 可选

如果设置为 True，则将计算的轴保留在结果中作为大小为一的维度。使用此选项，结果将正确广播到输入数组。

新版本 1.19.0 中加入。

返回:

countint 或 int 数组

沿着给定轴的数组中非零值的数量。否则，返回数组中的总非零值数量。

参见

非零

返回所有非零值的坐标。

示例

>>> np.count_nonzero(np.eye(4))
4
>>> a = np.array([[0, 1, 7, 0],
...               [3, 0, 2, 19]])
>>> np.count_nonzero(a)
5
>>> np.count_nonzero(a, axis=0)
array([1, 1, 2, 1])
>>> np.count_nonzero(a, axis=1)
array([2, 3])
>>> np.count_nonzero(a, axis=1, keepdims=True)
array([[2],
 [3]]) 

统计学

原文：numpy.org/doc/1.26/reference/routines.statistics.html

顺序统计

平均值和方差

相关性

直方图

顺序统计量

平均值和方差

Correlating

直方图

numpy.ptp

原文：numpy.org/doc/1.26/reference/generated/numpy.ptp.html

numpy.ptp(a, axis=None, out=None, keepdims=<no value>)

沿轴的值的范围（最大值 - 最小值）。

函数的名称来自于“peak to peak”的缩写。

警告

ptp保留了数组的数据类型。这意味着对于具有 n 位有符号整数的输入（如np.int8、np.int16等），返回值也是具有 n 位有符号整数。在这种情况下，大于2**(n-1)-1的峰值-峰值值将作为负值返回。下面是一个带解决方法的示例。

参数：

a（类似于数组）

输入值。

axis（None、int 或 int 型的元组，可选）

寻找峰值的轴。默认情况下，将数组展平。axis可以是负数，此时它从最后一个轴向第一个轴计数。

版本 1.15.0 中新增。

如果这是一组 int 型的元组，则将对多个轴进行归约，而不是像以前那样对单个轴或所有轴进行归约。

out（类似于数组）

用于放置结果的替代输出数组。它必须具有与预期输出相同的形状和缓冲区长度，但如果需要，输出值的类型将被强制转换。

keepdims（布尔型，可选）

如果设置为 True，则被减少的轴会在结果中保留为大小为一的维度。通过此选项，结果将与输入数组正确地进行广播。

如果传递了默认值，则keepdims不会传递到ptp方法的ndarray子类中，但任何非默认值都会传递。如果子类的方法没有实现keepdims，则会引发任何异常。

返回值：

ptp（类似于 ndarray 或标量）

给定数组的范围 - 如果数组为一维，则为标量；如果数组为多维，则为沿给定轴的结果的新数组。

示例：

>>> x = np.array([[4, 9, 2, 10],
...               [6, 9, 7, 12]]) 

>>> np.ptp(x, axis=1)
array([8, 6]) 

>>> np.ptp(x, axis=0)
array([2, 0, 5, 2]) 

>>> np.ptp(x)
10 

该示例表明，当输入是一组有符号整数时，可能会返回负值。

>>> y = np.array([[1, 127],
...               [0, 127],
...               [-1, 127],
...               [-2, 127]], dtype=np.int8)
>>> np.ptp(y, axis=1)
array([ 126,  127, -128, -127], dtype=int8) 

一种解决方法是使用*view()*方法将结果视为具有相同位宽的无符号整数：

>>> np.ptp(y, axis=1).view(np.uint8)
array([126, 127, 128, 129], dtype=uint8) 

numpy.percentile

原文：numpy.org/doc/1.26/reference/generated/numpy.percentile.html

numpy.percentile(a, q, axis=None, out=None, overwrite_input=False, method='linear', keepdims=False, *, interpolation=None)

沿指定轴计算数据的第 q 个百分位数。

返回数组元素的第 q 个百分位数。

参数：

a 实数的 array_like。

输入数组或可转换为数组的对象。

q 浮点数的 array_like。

计算要计算的百分位数的百分比或百分比序列。值必须介于 0 和 100 之间（包括边界）。

axis {int, int 的元组, None}，可选。

计算百分位数的轴或轴。默认是在数组的扁平版本上计算百分位数。

1.9.0 版中的更改：支持轴的元组

out ndarray，可选。

替代输出数组，必须具有与预期输出相同的形状和缓冲区长度，但如有必要，则输出的类型将被强制转换。

overwrite_input bool，可选。

如果为 True，则允许中间计算修改输入数组 a，以节省内存。在这种情况下，此函数完成后输入 a 的内容是未定义的。

methodstr，可选。

此参数指定用于估计百分位数的方法。有许多不同的方法，其中一些是 NumPy 特有的。有关说明，请参阅注释。按照其在 H&F 论文 [1]中总结的 R 类型排序的选项为：

1. ‘inverted_cdf’
2. ‘averaged_inverted_cdf’
3. ‘closest_observation’
4. ‘interpolated_inverted_cdf’
5. ‘hazen’
6. ‘weibull’
7. ‘linear’（默认）
8. ‘median_unbiased’
9. ‘normal_unbiased’

前三种方法是不连续的。NumPy 还定义了默认 ‘linear’（7.）选项的以下不连续变体：

• ‘lower’
• ‘higher’
• ‘midpoint’
• ‘nearest’

1.22.0 版中的更改：此参数以前称为“interpolation”，并且只提供了“linear”默认值和其余的四个选项。

keepdimsbool，可选。

如果设置为 True，则缩减的轴将作为大小为 1 的维度保留在结果中。使用此选项，结果将正确地广播到原始数组 a。

新版 1.9.0 中新增。

interpolation str，可选。

方法关键字参数的不推荐名称。

从 1.22.0 版开始不推荐使用。

返回：

percentile 标量或 ndarray。

如果 q 是单个百分位数并且 axis=None，则结果是标量。如果给出多个百分位数，结果的第一个轴对应于百分位数。其他轴是在 a 缩减后剩下的轴。如果输入包含小于 float64 的整数或浮点数，则输出数据类型为 float64。否则，输出的数据类型与输入的相同。如果指定了 out，则返回该数组。

另请参阅

mean

median

等效于 percentile(..., 50)

nanpercentile

分位数

与分位数相同，只是范围为 [0, 1] 的 q。

注

给定长度为 n 的向量 V，V 的第 q 个百分位数是在排序后的 V 的最小值和最大值之间，从最小值到最大值的q/100 处的值。如果标准化排名与位置 q 不完全匹配，则两个最近邻居的值和距离以及 method 参数将确定百分位数。如果 q=50，这个函数与中位数相同，如果 q=0，则与最小值相同，如果 q=100，则与最大值相同。

可选的 method 参数指定了当所需的百分位数位于两个索引 i 和 j = i + 1 之间时要使用的方法。在这种情况下，我们首先确定一个位于 i 和 j 之间的虚拟索引 i + g，其中 i 是 floor，g 是索引的小数部分。最终结果是基于 g 的 a[i] 和 a[j] 的插值。在计算 g 期间，i 和 j 被修正使用校正常数 alpha 和 beta，其选择取决于使用的 method。最后，注意由于 Python 使用基于 0 的索引，代码在内部从索引中再减去 1。

下列公式确定排序样本中百分位的虚拟索引 i + g 的位置：

[i + g = (q / 100) * ( n - alpha - beta + 1 ) + alpha]

不同的方法运作如下

inverted_cdf:

H&F 的第 1 种方法 [1]。这种方法给出不连续的结果：

• 如果 g > 0 ; 则取 j
• 如果 g = 0 ; 则取 i

averaged_inverted_cdf:

H&F 的第 2 种方法 [1]。这种方法给出不连续的结果：

• 如果 g > 0 ; 则取 j
• 如果 g = 0 ; 则在边界之间取平均

closest_observation:

H&F 的第 3 种方法 [1]。这种方法给出不连续的结果：

• 如果 g > 0 ; 则取 j
• 如果 g = 0 且索引为奇数 ; 则取 j
• 如果 g = 0 且索引为偶数 ; 则取 i

interpolated_inverted_cdf:

H&F 的第 4 种方法 [1]。这种方法使用以下方法给出连续的结果：

• alpha = 0
• beta = 1

hazen:

H&F 的第 5 种方法 [1]。这种方法使用以下方法给出连续的结果：

• alpha = 1/2
• beta = 1/2

weibull:

H&F 的第 6 种方法 [1]。这种方法使用以下方法给出连续的结果：

• alpha = 0
• beta = 0

linear:

H&F 的第 7 种方法 [1]。这种方法使用以下方法给出连续的结果：

• alpha = 1
• beta = 1

median_unbiased:

H&F 的第 8 种方法 [1]。这种方法可能是最好的方法，如果样本分布函数是未知的（参见参考）。这种方法使用以下方法给出连续的结果：

• alpha = 1/3
• beta = 1/3

normal_unbiased:

H&F 的第 9 种方法 [1]。这种方法可能是最好的方法，如果样本分布函数已知是正态的。这种方法使用以下方法给出连续的结果：

• alpha = 3/8
• beta = 3/8

lower:

NumPy 方法保留用于向后兼容。以i作为插值点。

更高：

NumPy 方法保留用于向后兼容。以j作为插值点。

最近的：

NumPy 方法保留用于向后兼容。取最近的i或j。

中点：

NumPy 方法保留用于向后兼容。使用(i + j) / 2。

参考文献

[1] (1,2,3,4,5,6,7,8,9,10)

R. J. Hyndman 和 Y. Fan，“统计软件包中的样本分位数”，《美国统计学家》，1996 年，50(4)，361-365 页

例子

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

>>> m = np.percentile(a, 50, axis=0)
>>> out = np.zeros_like(m)
>>> np.percentile(a, 50, axis=0, out=out)
array([6.5, 4.5, 2.5])
>>> m
array([6.5, 4.5, 2.5]) 

>>> b = a.copy()
>>> np.percentile(b, 50, axis=1, overwrite_input=True)
array([7.,  2.])
>>> assert not np.all(a == b) 

这些不同的方法可以以图形方式进行可视化:

import matplotlib.pyplot as plt

a = np.arange(4)
p = np.linspace(0, 100, 6001)
ax = plt.gca()
lines = [
    ('linear', '-', 'C0'),
    ('inverted_cdf', ':', 'C1'),
    # Almost the same as `inverted_cdf`:
    ('averaged_inverted_cdf', '-.', 'C1'),
    ('closest_observation', ':', 'C2'),
    ('interpolated_inverted_cdf', '--', 'C1'),
    ('hazen', '--', 'C3'),
    ('weibull', '-.', 'C4'),
    ('median_unbiased', '--', 'C5'),
    ('normal_unbiased', '-.', 'C6'),
    ]
for method, style, color in lines:
    ax.plot(
        p, np.percentile(a, p, method=method),
        label=method, linestyle=style, color=color)
ax.set(
    title='Percentiles for different methods and data: ' + str(a),
    xlabel='Percentile',
    ylabel='Estimated percentile value',
    yticks=a)
ax.legend(bbox_to_anchor=(1.03, 1))
plt.tight_layout()
plt.show() 

linear:

H&F 的第 7 种方法 [1]。这种方法使用以下方法给出连续的结果：

• alpha = 1
• beta = 1

median_unbiased:

H&F 的第 8 种方法 [1]。这种方法可能是最好的方法，如果样本分布函数是未知的（参见参考）。这种方法使用以下方法给出连续的结果：

• alpha = 1/3
• beta = 1/3

normal_unbiased:

H&F 的第 9 种方法 [1]。这种方法可能是最好的方法，如果样本分布函数已知是正态的。这种方法使用以下方法给出连续的结果：

• alpha = 3/8
• beta = 3/8

lower:

NumPy 方法保留用于向后兼容。以i作为插值点。

更高：

NumPy 方法保留用于向后兼容。以j作为插值点。

最近的：

NumPy 方法保留用于向后兼容。取最近的i或j。

中点：

NumPy 方法保留用于向后兼容。使用(i + j) / 2。

参考文献

[1] (1,2,3,4,5,6,7,8,9,10)

R. J. Hyndman 和 Y. Fan，“统计软件包中的样本分位数”，《美国统计学家》，1996 年，50(4)，361-365 页

例子

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

>>> m = np.percentile(a, 50, axis=0)
>>> out = np.zeros_like(m)
>>> np.percentile(a, 50, axis=0, out=out)
array([6.5, 4.5, 2.5])
>>> m
array([6.5, 4.5, 2.5]) 

>>> b = a.copy()
>>> np.percentile(b, 50, axis=1, overwrite_input=True)
array([7.,  2.])
>>> assert not np.all(a == b) 

这些不同的方法可以以图形方式进行可视化:

import matplotlib.pyplot as plt

a = np.arange(4)
p = np.linspace(0, 100, 6001)
ax = plt.gca()
lines = [
    ('linear', '-', 'C0'),
    ('inverted_cdf', ':', 'C1'),
    # Almost the same as `inverted_cdf`:
    ('averaged_inverted_cdf', '-.', 'C1'),
    ('closest_observation', ':', 'C2'),
    ('interpolated_inverted_cdf', '--', 'C1'),
    ('hazen', '--', 'C3'),
    ('weibull', '-.', 'C4'),
    ('median_unbiased', '--', 'C5'),
    ('normal_unbiased', '-.', 'C6'),
    ]
for method, style, color in lines:
    ax.plot(
        p, np.percentile(a, p, method=method),
        label=method, linestyle=style, color=color)
ax.set(
    title='Percentiles for different methods and data: ' + str(a),
    xlabel='Percentile',
    ylabel='Estimated percentile value',
    yticks=a)
ax.legend(bbox_to_anchor=(1.03, 1))
plt.tight_layout()
plt.show()