NumPy 1.26 中文文档（四十二）

ApacheCN_飞龙

发布于 2024-06-28 16:19:47

840

发布于 2024-06-28 16:19:47

文章被收录于专栏：信数据得永生信数据得永生

原文：numpy.org/doc/

`numpy.nanpercentile`

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

numpy.nanpercentile(a, q, axis=None, out=None, overwrite_input=False, method='linear', keepdims=<no value>, *, interpolation=None)

计算指定轴上的数据的第 q 个百分位数，同时忽略 nan 值。

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

版本 1.9.0 中的新功能。

参数：

aarray_like

输入数组或可以转换为数组的对象，其中包含要忽略的 nan 值。

qarray_like of float

要计算的百分位数或百分位数序列，必须在 0 和 100 之间（包括 0 和 100）。

axis{int, tuple of int, None}，可选

计算百分位数的轴或轴。默认值是沿数组的平坦版本计算百分位数。

outndarray, 可选

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

overwrite_inputbool，可选

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

methodstr，可选

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

‘inverted_cdf’
‘averaged_inverted_cdf’
‘closest_observation’
‘interpolated_inverted_cdf’
‘hazen’
‘weibull’
‘linear’（默认）
‘median_unbiased’
‘normal_unbiased’

前三种方法是不连续的。NumPy 进一步对默认的‘linear’(7.)选项定义了以下不连续的变体：

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

从版本 1.22.0 开始更改：此参数以前称为“interpolation”，并且仅提供了“linear”默认值和最后四个选项。

keepdimsbool，可选

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

如果这不是默认值，它将被传递（在特殊情况下是空数组）到底层数组的mean函数中。如果数组是子类，并且mean没有 kwarg keepdims，这将引发 RuntimeError。

interpolationstr，可选

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

自版本 1.22.0 起不推荐使用。

percentilescalar or ndarray

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

另请参阅

nanmean

nanmedian

相当于nanpercentile(..., 50)

percentile, median, mean

nanquantile

相当于 nanpercentile，除了 q 的范围是[0, 1]。

注意

更多信息请参见numpy.percentile

参考资料

[1]

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

示例

>>> a = np.array([[10., 7., 4.], [3., 2., 1.]])
>>> a[0][1] = np.nan
>>> a
array([[10.,  nan,   4.],
 [ 3.,   2.,   1.]])
>>> np.percentile(a, 50)
nan
>>> np.nanpercentile(a, 50)
3.0
>>> np.nanpercentile(a, 50, axis=0)
array([6.5, 2\. , 2.5])
>>> np.nanpercentile(a, 50, axis=1, keepdims=True)
array([[7.],
 [2.]])
>>> m = np.nanpercentile(a, 50, axis=0)
>>> out = np.zeros_like(m)
>>> np.nanpercentile(a, 50, axis=0, out=out)
array([6.5, 2\. , 2.5])
>>> m
array([6.5,  2\. ,  2.5])

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

`numpy.quantile`

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

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

计算沿指定轴的数据的 q-th 分位数。

版本 1.15.0 中的新内容。

参数：

a实数 array_like

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

qfloat array_like

用于计算分位数的概率或分位数序列。值必须在 0 到 1 之间（包括 0 和 1）。

axis{int，int 元组，None}，可选

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

输出ndarray，可选

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

overwrite_inputbool，可选

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

methodstr，可选

此参数指定用于估算分位数的方法。有许多不同的方法，其中一些是 NumPy 独有的。请参见注释以了解解释。按照它们在 H&F 论文[1]中总结的 R 类型的排序，选项分为：

‘inverted_cdf’
‘averaged_inverted_cdf’
‘closest_observation’
‘interpolated_inverted_cdf’
‘hazen’
‘weibull’
‘linear’（默认）
‘median_unbiased’
‘normal_unbiased’

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

‘lower’
‘higher’，
‘中点’
‘nearest’

在版本 1.22.0 中更改：此参数以前称为“interpolation”，并且仅提供了“linear”默认值和最后四个选项。

keepdimsbool，可选

如果设置为 True，则减少的轴将保留在结果中，作为尺寸为一的维度。选择此选项，结果将正确地针对原始数组a进行广播。

插值str，可选

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

从版本 1.22.0 开始不推荐使用。

分位数标量或 ndarray

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

另请参阅

mean

百分位数

等效于 quantile，但 q 在范围[0,100]内。

中位数

等效于quantile(..., 0.5)

nanquantile

注意事项

给定长度为 n 的向量 V，V 的第 q 个分位数是在 V 的排序副本中从最小值到最大值的 q 处的值。如果归一化排名与 q 的位置不完全匹配，则两个最近邻居的值和距离以及 method 参数将确定分位数。如果 q=0.5，则此函数与中位数相同；如果 q=0.0，则与最小值相同；如果 q=1.0，则与最大值相同。

可选的 method 参数指定当所需分位数位于两个索引 i 和 j = i + 1 之间时要使用的方法。在这种情况下，我们首先确定 i + g，即位于 i 和 j 之间的虚拟索引，其中 i 是地板，g 是索引的小数部分。然后，最终结果是根据 g 对 a[i] 和 a[j] 进行插值。在计算 g 时，使用修正常数 alpha 和 beta 修改 i 和 j，其选择取决于所使用的 method。最后，请注意，由于 Python 使用基于 0 的索引，因此代码在内部从索引中再减去另外 1。

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

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

然后，不同的方法工作如下：

倒数累积分布：

H&F 方法 1 [1]。此方法提供不连续的结果：

若 g > 0；则取 j
若 g = 0；则取 i

平均倒数累积分布：

H&F 方法 2 [1]。此方法提供不连续的结果：

若 g > 0；则取 j
若 g = 0；则在边界之间取平均

`numpy.nanquantile`

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

numpy.nanquantile(a, q, axis=None, out=None, overwrite_input=False, method='linear', keepdims=<no value>, *, interpolation=None)

在忽略 nan 值的情况下计算指定轴上的第 q 分位数。返回数组元素的 q 分位数。

1.15.0 版中新增。

参数：

aarray_like

输入数组或可以转换为数组的对象，其中包含要忽略的 nan 值

qfloat 的 array_like

概率或用于计算分位数的概率序列。值必须在 0 和 1 之间（包括 0 和 1）。

轴{int, int 的 tuple, None}, 可选参数

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

outndarray，可选参数

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

overwrite_input布尔值，可选参数

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

method字符串，可选参数

该参数指定用于估计分位数的方法。有许多不同的方法，其中一些是 NumPy 特有的。请参见注释以获取解释。根据它们在 H&F 论文中总结的 R 类型，选项如下[1]：

‘inverted_cdf’
‘averaged_inverted_cdf’
‘closest_observation’
‘interpolated_inverted_cdf’
‘hazen’
‘weibull’
‘linear’（默认值）
‘median_unbiased’
‘normal_unbiased’

前三种方法是不连续的。NumPy 进一步定义了默认的‘linear’(7.)选项的以下不连续变化：

‘lower’
‘higher’，
‘midpoint’
‘nearest’

自 1.22.0 版本更改：该参数以前称为“interpolation”，并且只提供“linear”默认值和最后四个选项。

keepdims布尔值，可选参数

如果设置为 True，那么被减少的轴将作为大小为一的维度保留在结果中。使用此选项，结果将正确地对原始数组a进行广播。

如果这不是默认值，那么它将通过（在空数组的特殊情况下）传递给底层数组的mean函数。如果数组是子类，而mean没有 kwarg keepdims，则会引发运行时错误。

interpolation字符串，可选参数

方法关键字参数的已弃用名称。

自 1.22.0 版起已弃用。

返回值：

quantile标量或 ndarray

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

另请参阅

quantile

nanmean，nanmedian

nanmedian

等同于nanquantile(..., 0.5)

nanpercentile

与 nanquantile 相同，但 q 在范围[0, 100]内。

注意事项

有关更多信息，请参

参考文献

[1]

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

例子

>>> a = np.array([[10., 7., 4.], [3., 2., 1.]])
>>> a[0][1] = np.nan
>>> a
array([[10.,  nan,   4.],
 [ 3.,   2.,   1.]])
>>> np.quantile(a, 0.5)
nan
>>> np.nanquantile(a, 0.5)
3.0
>>> np.nanquantile(a, 0.5, axis=0)
array([6.5, 2\. , 2.5])
>>> np.nanquantile(a, 0.5, axis=1, keepdims=True)
array([[7.],
 [2.]])
>>> m = np.nanquantile(a, 0.5, axis=0)
>>> out = np.zeros_like(m)
>>> np.nanquantile(a, 0.5, axis=0, out=out)
array([6.5, 2\. , 2.5])
>>> m
array([6.5,  2\. ,  2.5])
>>> b = a.copy()
>>> np.nanquantile(b, 0.5, axis=1, overwrite_input=True)
array([7., 2.])
>>> assert not np.all(a==b)

`numpy.median`

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

numpy.median(a, axis=None, out=None, overwrite_input=False, keepdims=False)

计算沿指定轴的中位数。

返回数组元素的中位数。

参数：

a array_like

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

axis{int, int 序列, None}, 可选

计算中位数的轴或轴。默认值是计算数组的扁平版本沿中位数。自版本 1.9.0 以来支持轴序列。

out ndarray，可选

替代输出数组，其中放置结果。它必须具有与预期输出相同的形状和缓冲区长度，但必要时将转换（输出）的类型。

overwrite_inputbool, 可选

如果为 True，则允许使用输入数组a的内存进行计算。该调用对输入数组进行修改。当不需要保留输入数组的内容时，这将节省内存。将输入视为未定义，但可能完全或部分排序。默认值为 False。如果overwrite_input为True且a还不是ndarray，则会引发错误。

keepdimsbool, 可选

如果设置为 True，则减少的轴将作为具有大小为一的维度留在结果中。使用此选项，结果将针对原始arr进行正确的广播。

新版本 1.9.0。

median ndarray

存储结果的新数组。如果输入包含小于float64的整数或浮点数，则输出数据类型为np.float64。否则，输出的数据类型与输入的相同。如果指定了out，则返回该数组。

另请参阅

mean，percentile

注意

给定长度为N的向量V，V的中位数是排序副本V_sorted的中间值 - 即 V_sorted[(N-1)/2]，当N为奇数时，以及V_sorted的两个中间值的平均值，当N为偶数时。

示例

>>> a = np.array([[10, 7, 4], [3, 2, 1]])
>>> a
array([[10,  7,  4],
 [ 3,  2,  1]])
>>> np.median(a)
3.5
>>> np.median(a, axis=0)
array([6.5, 4.5, 2.5])
>>> np.median(a, axis=1)
array([7.,  2.])
>>> m = np.median(a, axis=0)
>>> out = np.zeros_like(m)
>>> np.median(a, axis=0, out=m)
array([6.5,  4.5,  2.5])
>>> m
array([6.5,  4.5,  2.5])
>>> b = a.copy()
>>> np.median(b, axis=1, overwrite_input=True)
array([7.,  2.])
>>> assert not np.all(a==b)
>>> b = a.copy()
>>> np.median(b, axis=None, overwrite_input=True)
3.5
>>> assert not np.all(a==b)

`numpy.average`

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

numpy.average(a, axis=None, weights=None, returned=False, *, keepdims=<no value>)

计算沿指定轴的加权平均值。

参数：

aarray_like

包含要平均的数据的数组。如果a不是数组，则会尝试转换。

axisNone 或 int 或 int 元组，可选

沿着其进行平均值计算的轴或轴。默认情况下，axis=None 将对输入数组的所有元素进行平均值计算。如果 axis 为负数，则从最后一个轴到第一个轴计数。

新功能在版本 1.7.0 中。

如果轴是整数元组，则对元组中指定的所有轴执行平均值计算，而不是以前的单个轴或所有轴。

weightsarray_like，可选

与a中的值相关联的权重数组。a中的每个值根据其关联的权重对平均值做出贡献。权重数组可以是 1-D（在这种情况下，其长度必须是给定轴上a的大小）或与a相同形状。如果weights=None，则假定a中的所有数据的权重都等于 1。1-D 计算如下：

avg = sum(a * weights) / sum(weights)

权重的唯一约束是*sum(weights)*不能为 0。

returnedbool，可选

默认值为False。如果True，则返回元组（average，sum_of_weights），否则仅返回平均值。如果weights=None，sum_of_weights等于计算平均值的元素数量。

keepdimsbool，可选

如果设置为 True，则被减少的轴将作为尺寸为 1 的维度保留在结果中。使用此选项，结果将正确广播到原始a。注意: keepdims不适用于numpy.matrix或其他不支持keepdims方法的类的实例。

新功能在版本 1.23.0 中。

**retval，[sum_of_weights]**array_type 或 double

沿指定轴计算平均值。当returned为True时，返回一个元组，第一个元素是平均值，第二个元素是权重的总和。sum_of_weights与retval的类型相同。结果 dtype 遵循一般模式。如果weights为 None，则结果 dtype 将是a的 dtype，或者如果a是整数，则为float64。否则，如果weights不为 None 且a不是整数，则结果类型将是能够表示a和weights值的最低精度类型。如果a恰好是整数，则仍然适用先前的规则，但结果 dtype 至少为float64。

引发：

零除错误

当沿轴的所有权重都为零时。查看numpy.ma.average以获得对此类型错误鲁棒的版本。

类型错误

当 1D weights的长度与沿轴的a的形状不同时。

另请参阅

mean

ma.average

用于掩码数组的平均值 - 如果您的数据包含“缺失”值，则非常有用

numpy.result_type

返回应用 numpy 类型提升规则到参数后的类型。

示例

>>> data = np.arange(1, 5)
>>> data
array([1, 2, 3, 4])
>>> np.average(data)
2.5
>>> np.average(np.arange(1, 11), weights=np.arange(10, 0, -1))
4.0

>>> data = np.arange(6).reshape((3, 2))
>>> data
array([[0, 1],
 [2, 3],
 [4, 5]])
>>> np.average(data, axis=1, weights=[1./4, 3./4])
array([0.75, 2.75, 4.75])
>>> np.average(data, weights=[1./4, 3./4])
Traceback (most recent call last):
  ...
TypeError: Axis must be specified when shapes of a and weights differ.

>>> a = np.ones(5, dtype=np.float128)
>>> w = np.ones(5, dtype=np.complex64)
>>> avg = np.average(a, weights=w)
>>> print(avg.dtype)
complex256

运用keepdims=True，以下结果的形状为(3, 1)。

>>> np.average(data, axis=1, keepdims=True)
array([[0.5],
 [2.5],
 [4.5]])

`numpy.mean`

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

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

沿指定轴计算算术平均值。

返回数组元素的平均值。默认情况下，平均值是在扁平化数组上计算的，否则在指定的轴上计算。对于整数输入，中间和返回值使用float64。

参数:

aarray_like

包含所需平均值的数字的数组。如果a不是数组，则会尝试进行转换。

axisNone 或 int 或 int 元组, 可选

计算平均值的轴。默认情况下，计算扁平数组的平均值。

1.7.0 版本中的新内容。

如果这是一个 int 元组，则将在多个轴上执行平均值，而不是以前的单个轴或所有轴的平均值。

dtype数据类型, 可选

用于计算平均值的类型。对于整数输入，默认值为float64；对于浮点输入，它与输入 dtype 相同。

outndarray, 可选

备选输出数组，用于放置结果。默认值为None；如果提供，则必须具有与预期输出相同的形状，但必要时将进行类型转换。详情请参阅输出类型确定。

keepdimsbool, 可选

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

如果传递了默认值，则keepdims将不会传递给mean方法的子类，但任何非默认值都将传递。如果子类方法不实现keepdims，则会引发任何异常。

wherearray_like of bool, 可选

要包括在均值中的元素。详情请参阅reduce。

1.20.0 版本中的新内容。

mndarray，参见上面的 dtype 参数

如果out=None，返回一个包含平均值的新数组，否则返回对输出数组的引用。

另请参阅

average

加权平均

std, var, nanmean, nanstd, nanvar

注意

算术平均值是沿着轴的元素之和除以元素个数。

请注意，对于浮点输入，均值是使用与输入相同的精度计算的。根据输入数据，这可能导致结果不准确，特别是对于float32（见下面的示例）。使用dtype关键字指定更高精度的累加器可以缓解这个问题。

默认情况下，float16的结果是用float32作为中间值计算，以获得额外的精度。

示例

>>> a = np.array([[1, 2], [3, 4]])
>>> np.mean(a)
2.5
>>> np.mean(a, axis=0)
array([2., 3.])
>>> np.mean(a, axis=1)
array([1.5, 3.5])

在单精度下，mean可能不准确：

>>> a = np.zeros((2, 512*512), dtype=np.float32)
>>> a[0, :] = 1.0
>>> a[1, :] = 0.1
>>> np.mean(a)
0.54999924

用float64计算均值更精确：

>>> np.mean(a, dtype=np.float64)
0.55000000074505806 # may vary

指定一个where参数：

>>> a = np.array([[5, 9, 13], [14, 10, 12], [11, 15, 19]])
>>> np.mean(a)
12.0
>>> np.mean(a, where=[[True], [False], [False]])
9.0

`numpy.std`

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

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

沿指定轴计算标准差。

返回数组元素的标准差，这是对分布的扩展度的一种测量。默认情况下，通过压平的数组计算标准差，或者可以沿指定轴进行计算。

参数：

a类似数组

计算这些值的标准差。

axisNone 或 int 或 int 的元组，可选

计算标准差的轴或轴。默认值是计算压平数组的标准差。

自 1.7.0 版本新增。

如果传入的是 int 的元组，则会在多个轴上执行标准差计算，而不是之前的单个轴或所有轴的计算。

dtypedtype，可选

用于计算标准差的类型。对于整数类型的数组，默认值是 float64，对于浮点类型的数组，它与数组类型相同。

outndarray，可选

替代输出数组，用于放置结果。它必须具有与期望输出相同的形状，但如果需要，将会对计算的值进行类型强制转换。

ddofint，可选

自由度差异。计算中使用的除数是N - ddof，其中N代表元素的数量。默认情况下，ddof为零。

keepdimsbool，可选

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

如果传入的是默认值，那么keepdims将不会传递给 std 的子类的方法，然而任何非默认值都会。如果子类的方法没有实现keepdims，则会引发任何异常。

wherebool 值的数组或类似数组，可选

包括在标准差中的元素。有关详细信息，请参见 reduce。

自 1.20.0 版本新增。

standard_deviationndarray，参见上面的 dtype 参数。

如果out为空，则返回一个包含标准差的新数组，否则返回对输出数组的引用。

参见

var, mean, nanmean, nanstd, nanvar

输出类型确定

注释

标准差是平均平方离差的平方根，即std = sqrt(mean(x))，其中x = abs(a - a.mean())**2。

平均平方偏差通常被计算为 x.sum() / N，其中 N = len(x)。然而，如果指定了 ddof，则会使用除数 N - ddof。在标准统计实践中，ddof=1 提供了无偏估计的方差，适用于无限总体。ddof=0提供了正态分布变量方差的最大似然估计。该函数计算的标准偏差是估计方差的平方根，因此即使使用 ddof=1，它也不会是标准偏差的无偏估计。

请注意，对于复数，std 在平方之前取绝对值，因此结果总是实数且非负。

对于浮点输入，std 是使用与输入相同的精度来计算的。根据输入数据的不同，这可能导致结果不准确，特别是对于 float32（见下面的例子）。使用 dtype 关键字指定更高精度的累加器可以缓解这个问题。

例子

>>> a = np.array([[1, 2], [3, 4]])
>>> np.std(a)
1.1180339887498949 # may vary
>>> np.std(a, axis=0)
array([1.,  1.])
>>> np.std(a, axis=1)
array([0.5,  0.5])

在单精度中，std() 可能不准确：

>>> a = np.zeros((2, 512*512), dtype=np.float32)
>>> a[0, :] = 1.0
>>> a[1, :] = 0.1
>>> np.std(a)
0.45000005

在 float64 中计算标准偏差更精确：

>>> np.std(a, dtype=np.float64)
0.44999999925494177 # may vary

指定一个 where 参数：

>>> a = np.array([[14, 8, 11, 10], [7, 9, 10, 11], [10, 15, 5, 10]])
>>> np.std(a)
2.614064523559687 # may vary
>>> np.std(a, where=[[True], [True], [False]])
2.0

`numpy.var`

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

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

沿指定轴计算方差。

返回数组元素的方差，是分布扩散的一种度量。默认情况下，计算扁平化数组的方差，否则计算沿指定轴的方差。

参数：

a 像数组

包含要求方差的数字的数组。如果a不是数组，则会尝试转换。

axisNone 或整数或整数元组，可选

计算方差的轴或轴。默认是计算扁平化数组的方差。

版本 1.7.0 中的新功能。

如果这是一个整数元组，将在多个轴上执行方差，而不是以前的单个轴或所有轴。

dtype数据类型，可选

用于计算方差的类型。对于整数型数组，默认值为float64；对于浮点类型数组，它与数组类型相同。

out ndarray，可选

替代输出数组，其中放置结果。它必须具有与预期输出相同的形状，但必要时会进行类型转换。

ddof 整数，可选

“自由度差”: 计算中使用的除数为N - ddof，其中N表示元素数量。默认情况下，ddof为零。

keepdims 布尔值，可选

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

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

where 布尔值数组，可选

包括在方差中的元素。有关详细信息，请参见reduce。

版本 1.20.0 中的新功能。

方差 ndarray，参见上面的 dtype 参数

如果out=None，则返回一个包含方差的新数组；否则，返回对输出数组的引用。

另请参见

std，mean，nanmean，nanstd，nanvar

输出类型确定

注意

方差是平均偏离均值的平方，即var = mean(x)，其中x = abs(a - a.mean())**2。

均值通常计算为 x.sum() / N，其中 N = len(x)。然而，如果指定了 ddof，则会使用除数 N - ddof。在标准统计实践中，ddof=1 提供了对假设无限总体方差的无偏估计。ddof=0 对于正态分布的变量提供了方差的最大似然估计。

注意，在处理复数时，先取绝对值再进行平方，以确保结果始终为实数且非负。

对于浮点输入，方差的计算与输入数据的精度相同。根据输入数据的不同，这可能导致结果不准确，尤其是对于 float32（请参见下面的示例）。使用 dtype 关键字指定更高精度的累加器可以缓解问题。

示例

>>> a = np.array([[1, 2], [3, 4]])
>>> np.var(a)
1.25
>>> np.var(a, axis=0)
array([1.,  1.])
>>> np.var(a, axis=1)
array([0.25,  0.25])

在单精度下，var() 可能不准确：

>>> a = np.zeros((2, 512*512), dtype=np.float32)
>>> a[0, :] = 1.0
>>> a[1, :] = 0.1
>>> np.var(a)
0.20250003

使用 float64 计算方差更准确：

>>> np.var(a, dtype=np.float64)
0.20249999932944759 # may vary
>>> ((1-0.55)**2 + (0.1-0.55)**2)/2
0.2025

指定 where 参数：

>>> a = np.array([[14, 8, 11, 10], [7, 9, 10, 11], [10, 15, 5, 10]])
>>> np.var(a)
6.833333333333333 # may vary
>>> np.var(a, where=[[True], [True], [False]])
4.0

`numpy.nanmedian`

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

numpy.nanmedian(a, axis=None, out=None, overwrite_input=False, keepdims=<no value>)

沿指定轴计算中位数，同时忽略 NaN。

返回数组元素的中位数。

自版本 1.9.0 新增。

参数：

aarray_like

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

axis{int, sequence of int, None}, optional

计算中位数的轴或轴。默认是沿数组的扁平版本计算中位数。自版本 1.9.0 开始支持一系列轴。

outndarray, optional

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

overwrite_inputbool, optional

如果为 True，则允许使用输入数组a的内存进行计算。调用median将修改输入数组。当您不需要保留输入数组的内容时，这将节省内存。将输入视为未定义，但可能已全部或部分排序。默认值为 False。如果overwrite_input为True，且a不是已经是ndarray，则会引发错误。

keepdimsbool, optional

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

如果这不是默认值，将通过（在空数组的特殊情况下）传递给基础数组的mean函数。如果数组是子类，且mean没有 kwarg keepdims，这将引发 RuntimeError。

medianndarray

持有结果的新数组。如果输入包含小于float64的整数或浮点数，则输出数据类型为np.float64。否则，输出的数据类型与输入的数据类型相同。如果指定了out，则返回该数组。

另请参见

mean, median, percentile

注意

给定长度为N的向量V，V的中位数是排序副本V_sorted的中间值，即V_sorted[(N-1)/2]，当N为奇数时，V_sorted的两个中间值的平均值，当N为偶数时。

示例

>>> a = np.array([[10.0, 7, 4], [3, 2, 1]])
>>> a[0, 1] = np.nan
>>> a
array([[10., nan,  4.],
 [ 3.,  2.,  1.]])
>>> np.median(a)
nan
>>> np.nanmedian(a)
3.0
>>> np.nanmedian(a, axis=0)
array([6.5, 2\. , 2.5])
>>> np.median(a, axis=1)
array([nan,  2.])
>>> b = a.copy()
>>> np.nanmedian(b, axis=1, overwrite_input=True)
array([7.,  2.])
>>> assert not np.all(a==b)
>>> b = a.copy()
>>> np.nanmedian(b, axis=None, overwrite_input=True)
3.0
>>> assert not np.all(a==b)

`numpy.nanmean`

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

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

沿指定轴计算算术平均值，忽略 NaN。

返回数组元素的平均值。默认情况下，通过平坦数组进行平均，否则通过指定的轴进行平均。对于整数输入，默认情况下使用float64中间和返回值。

对于所有-NaN 切片，返回 NaN 并引发RuntimeWarning。

版本 1.8.0 中的新功能。

参数：

aarray_like

包含所需平均值的数字的数组。如果a不是数组，则会尝试转换。

axis{int, tuple of int, None}，可选

计算平均值的轴或轴。默认值是计算平均值的扁平数组。

dtype数据类型，可选

用于计算平均值的类型。对于整数输入，默认值为float64；对于非精确输入，与输入 dtype 相同。

outndarray，可选

交替的输出数组，其中放置结果。默认值为None；如果提供，它必须具有与预期输出相同的形状，但如果需要，类型将被转换。有关更多详细信息，请参见输出类型确定。

keepdimsbool, optional

如果设置为 True，则被减少的轴会作为尺寸为一的维度留在结果中。使用此选项，结果将正确地广播对原始a。

如果值不是默认值，则keepdims将通过传递给mean或sum的子类的方法。如果子类方法未实现keepdims，则将引发任何异常。

wherebool 类型数组，可选

包含在均值中的元素。有关详细信息，请参阅reduce。

版本 1.22.0 中的新功能。

mndarray，见上面的 dtype 参数

如果out=None，返回包含平均值的新数组，否则返回对输出数组的引用。对于只包含 NaN 的切片，返回 NaN。

另见

average

加权平均

mean

不忽略 NaN 的算术平均值

var, nanvar

注意

算术平均值是沿轴向的非 NaN 元素的总和除以非 NaN 元素的数量。

请注意，对于浮点数输入，均值是使用输入数据的相同精度计算的。根据输入数据的不同，这可能会导致结果不准确，特别是对于float32。使用dtype关键字指定更高精度的累加器可以缓解这个问题。

例子

>>> a = np.array([[1, np.nan], [3, 4]])
>>> np.nanmean(a)
2.6666666666666665
>>> np.nanmean(a, axis=0)
array([2.,  4.])
>>> np.nanmean(a, axis=1)
array([1.,  3.5]) # may vary

`numpy.nanstd`

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

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

计算沿指定轴的标准差，同时忽略 NaN。

返回非 NaN 数组元素的标准差，即分布的展开度量，默认情况下计算平均值的标准差，否则计算指定轴上的标准差。

对于所有包含全为 NaN 或自由度为零的切片，都会返回 NaN 并引发RuntimeWarning。

新版本 1.8.0 中更新。

参数：

aarray_like

计算非 NaN 值的标准差。

axis{int, tuple of int, None}，可选

计算标准差的轴或轴。默认值是计算扁平化数组的标准差。

dtypedtype，可选

用于计算标准差的类型。对于整数类型的数组，默认值是 float64，对于浮点类型的数组，它与数组类型相同。

outndarray，可选

替代输出数组，其中存放结果。它必须具有与预期输出相同的形状，但如有必要，计算值的类型（类型）将被转换。

ddofint，可选

表示自由度的度。计算中使用的除数是N - ddof，其中N表示非 NaN 元素的数量。默认情况下ddof为零。

keepdimsbool，可选

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

如果此值不是默认值，则将其原样传递给子类的相关函数。如果这些函数没有keepdims kwarg，则会引发运行时错误。

wherearray_like of bool，可选

要包括在标准差中的元素。有关详细信息，请参见reduce。

新版本 1.22.0 中更新。

standard_deviationndarray，参见上述 dtype 参数。

如果out为 None，则返回一个包含标准差的新数组，否则返回对输出数组的引用。如果 ddof 大于等于切片中的非 NaN 元素数量或切片只包含 NaN，则该切片的结果为 NaN。

另请参阅

var，mean，std

nanvar，nanmean

输出类型确定

注意

标准差是平均值与平方偏差的平均值的平方根：std = sqrt(mean(abs(x - x.mean())**2))。

平均平方偏差通常计算为x.sum() / N，其中N = len(x)。然而，如果指定了ddof，那么除数将改为使用N - ddof。在标准统计实践中，ddof=1提供了无偏估计的无限总体方差。ddof=0提供了正态分布变量方差的最大似然估计。此函数计算的标准差是估计方差的平方根，所以即使ddof=1，它也不会是标准偏差的无偏估计。

请注意，对于复数，std 在平方前取绝对值，以使结果始终是实数且非负数。

对于浮点输入，std 是使用输入精度计算的。根据输入数据，这可能导致结果不准确，特别是对于 float32（参见下面的示例）。使用dtype关键字指定更高精度的累加器可以缓解这个问题。

示例

>>> a = np.array([[1, np.nan], [3, 4]])
>>> np.nanstd(a)
1.247219128924647
>>> np.nanstd(a, axis=0)
array([1., 0.])
>>> np.nanstd(a, axis=1)
array([0.,  0.5]) # may vary

`numpy.nanvar`

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

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

沿着指定轴计算方差，同时忽略 NaN。

返回数组元素的方差，表示分布的扩展程度。默认情况下，通过对扁平化数组进行计算来计算方差，否则通过指定的轴进行计算。

对于所有为 NaN 的片段或自由度为零的片段，将返回 NaN，并引发RuntimeWarning。

新特性在版本 1.8.0 中添加。

参数：

aarray_like

包含所需方差的数字的数组。如果a不是数组，则会尝试进行转换。

axis{int, tuple of int, None}，可选

计算方差的轴或轴。默认是计算扁平化数组的方差。

dtype数据类型，可��

用于计算方差的数据类型。对于整数类型的数组，默认值是float64；对于浮点数类型的数组，其数据类型与数组类型相同。

outndarray，可选

可选的输出数组，用来存放结果。它必须与预期的输出具有相同的形状，但如果需要会进行类型转换。

ddofint，可选

“自由度差值”: 计算中使用的除数为N - ddof，其中N表示非 NaN 元素的数量。默认情况下ddof为零。

keepdimsbool，可选

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

wherearray_like of bool，可选

包含在方差中的元素。详情参见reduce。

新特性在版本 1.22.0 中添加。

variancendarray，参见上面的 dtype 参数

如果out为 None，则返回一个包含方差的新数组，否则返回对输出数组的引用。如果 ddof >= 切片中非 NaN 元素的数量，或者切片仅包含 NaN，则该切片的结果为 NaN。

另请参阅

std

标准差

mean

平均值

var

忽略 NaN 时的方差

nanstd，nanmean

输出类型确定

注意事项

方差是平均值的平方偏差，即，var = mean(abs(x - x.mean())**2)。

平均值通常计算为x.sum() / N，其中N = len(x)。如果指定了ddof，则使用除数N - ddof。在标准统计实践中，ddof=1提供了假设无限总体方差的无偏估计。ddof=0为正态分布变量的方差提供了最大似然估计。

请注意，对于复数，先取绝对值再平方，以确保结果始终是实数且非负。

对于浮点输入，方差是使用与输入相同的精度计算的。根据输入数据，这可能导致结果不准确，特别是对于float32（见下面的示例）。使用dtype关键字指定更高精度的累加器可以缓解此问题。

要使此函数在 ndarray 的子类上工作，它们必须使用 kwarg keepdims定义sum。

例子

>>> a = np.array([[1, np.nan], [3, 4]])
>>> np.nanvar(a)
1.5555555555555554
>>> np.nanvar(a, axis=0)
array([1.,  0.])
>>> np.nanvar(a, axis=1)
array([0.,  0.25])  # may vary

`numpy.corrcoef`

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

numpy.corrcoef(x, y=None, rowvar=True, bias=<no value>, ddof=<no value>, *, dtype=None)

返回 Pearson 积矩相关系数。

请参考cov文档获取更多细节。相关系数矩阵 R 与协方差矩阵 C 之间的关系为

[R_{ij} = \frac{ C_{ij} } { \sqrt{ C_{ii} C_{jj} } }]

R 的值介于 -1 到 1 之间，包括端点。

参数:

xarray_like

包含多个变量和观测值的 1-D 或 2-D 数组。x 的每一行代表一个变量，每一列代表所有这些变量的单个观测值。也请参阅下方的 rowvar。

yarray_like, 可选

一个包含额外变量和观测值的集合。y 的形状与 x 相同。

rowvar布尔值，可选

如果 rowvar 为 True（默认情况），则每行代表一个变量，列中包含观测值。否则，关系被转置：每列代表一个变量，而行包含观测值。

bias_NoValue, 可选

无效果，请勿使用。

自版本 1.10.0 弃用。

ddof_NoValue, 可选

无效果，请勿使用。

自版本 1.10.0 弃用。

dtype数据类型，可选

结果的数据类型。默认情况下，返回的数据类型至少具有numpy.float64 精度。

1.20 版本中推出。

Rndarray

变量的相关系数矩阵。

另请参见

cov

协方差矩阵

备注

由于浮点舍入的结果，最终数组可能不会是 Hermite 矩阵，对角线元素可能不会是 1，元素可能不满足不等式 abs(a) <= 1。为了改善这种情况，实部和虚部被剪切到区间[-1, 1]，但在复杂情况下帮助不大。

此函数接受但忽略参数 bias 和 ddof。这是为了向后兼容以前版本的函数。这些参数对函数的返回值没有影响，在这个版本和以前的 numpy 版本中可以安全地忽略。

示例

在此示例中，我们生成两个随机数组，xarr 和 yarr，并计算行-wise 和列-wise 的 Pearson 相关系数 R。由于默认情况下 rowvar 为真，我们首先找到 xarr 的变量之间的行-wise Pearson 相关系数。

>>> import numpy as np
>>> rng = np.random.default_rng(seed=42)
>>> xarr = rng.random((3, 3))
>>> xarr
array([[0.77395605, 0.43887844, 0.85859792],
 [0.69736803, 0.09417735, 0.97562235],
 [0.7611397 , 0.78606431, 0.12811363]])
>>> R1 = np.corrcoef(xarr)
>>> R1
array([[ 1\.        ,  0.99256089, -0.68080986],
 [ 0.99256089,  1\.        , -0.76492172],
 [-0.68080986, -0.76492172,  1\.        ]])

如果我们增加另一组变量和观测值 yarr，我们可以计算 xarr 和 yarr 变量之间的按行 Pearson 相关系数。

>>> yarr = rng.random((3, 3))
>>> yarr
array([[0.45038594, 0.37079802, 0.92676499],
 [0.64386512, 0.82276161, 0.4434142 ],
 [0.22723872, 0.55458479, 0.06381726]])
>>> R2 = np.corrcoef(xarr, yarr)
>>> R2
array([[ 1\.        ,  0.99256089, -0.68080986,  0.75008178, -0.934284  ,
 -0.99004057],
 [ 0.99256089,  1\.        , -0.76492172,  0.82502011, -0.97074098,
 -0.99981569],
 [-0.68080986, -0.76492172,  1\.        , -0.99507202,  0.89721355,
 0.77714685],
 [ 0.75008178,  0.82502011, -0.99507202,  1\.        , -0.93657855,
 -0.83571711],
 [-0.934284  , -0.97074098,  0.89721355, -0.93657855,  1\.        ,
 0.97517215],
 [-0.99004057, -0.99981569,  0.77714685, -0.83571711,  0.97517215,
 1\.        ]])

最后，如果我们使用选项 rowvar=False，那么现在列会被视为变量，我们将在 xarr 和 yarr 中变量之间计算列-wise Pearson 相关系数。

>>> R3 = np.corrcoef(xarr, yarr, rowvar=False)
>>> R3
array([[ 1\.        ,  0.77598074, -0.47458546, -0.75078643, -0.9665554 ,
 0.22423734],
 [ 0.77598074,  1\.        , -0.92346708, -0.99923895, -0.58826587,
 -0.44069024],
 [-0.47458546, -0.92346708,  1\.        ,  0.93773029,  0.23297648,
 0.75137473],
 [-0.75078643, -0.99923895,  0.93773029,  1\.        ,  0.55627469,
 0.47536961],
 [-0.9665554 , -0.58826587,  0.23297648,  0.55627469,  1\.        ,
 -0.46666491],
 [ 0.22423734, -0.44069024,  0.75137473,  0.47536961, -0.46666491,
 1\.        ]])

`numpy.correlate`

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

numpy.correlate(a, v, mode='valid')

两个一维序列的互相关。

此函数计算信号处理文本中通常定义的相关性：

[c_k = \sum_n a_{n+k} \cdot \overline{v}_n]

其中 a 和 v 序列在必要时进行零填充，(\overline x) 表示复共轭。

参数：

a, varray_like

输入序列。

mode{‘valid’, ‘same’, ‘full’}, 可选

参考 convolve 文档字符串。请注意，默认值为 ‘valid’，与 convolve 不同，后者使用 ‘full’。

old_behaviorbool

old_behavior 在 NumPy 1.10 中已移除。如果需要旧行为，请使用 multiarray.correlate。

outndarray

a 和 v 的离散互相关。

另请参见

convolve

两个一维序列的离散线性卷积。

multiarray.correlate

互相关的旧版本，无复共轭。

scipy.signal.correlate

使用 FFT 在大数组上具有优越性能。

注意事项

上述相关性的定义并不唯一，有时相关性可能有不同的定义。另一个常见的定义是：

[c’k = \sum_n a{n} \cdot \overline{v_{n+k}}]

与 (c_k) 通过 (c’k = c{-k}) 相关。

在大数组中，numpy.correlate 可能执行缓慢（即 n = 1e5），因为它不使用 FFT 来计算卷积；在这种情况下，scipy.signal.correlate 可能更可取。

示例

>>> np.correlate([1, 2, 3], [0, 1, 0.5])
array([3.5])
>>> np.correlate([1, 2, 3], [0, 1, 0.5], "same")
array([2\. ,  3.5,  3\. ])
>>> np.correlate([1, 2, 3], [0, 1, 0.5], "full")
array([0.5,  2\. ,  3.5,  3\. ,  0\. ])

使用复数序列：

>>> np.correlate([1+1j, 2, 3-1j], [0, 1, 0.5j], 'full')
array([ 0.5-0.5j,  1.0+0.j ,  1.5-1.5j,  3.0-1.j ,  0.0+0.j ])

当两个输入序列 a 和 v 交换位置时，注意到你会得到时间反转、复共轭的结果 ((\overline{c_{-k}}))：

>>> np.correlate([0, 1, 0.5j], [1+1j, 2, 3-1j], 'full')
array([ 0.0+0.j ,  3.0+1.j ,  1.5+1.5j,  1.0+0.j ,  0.5+0.5j])

`numpy.cov`

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

numpy.cov(m, y=None, rowvar=True, bias=False, ddof=None, fweights=None, aweights=None, *, dtype=None)

给定数据和权重，估算协方差矩阵。

协方差指示了两个变量一起变化的程度。如果我们检查 N 维样本，(X = [x_1, x_2, … x_N]^T)，那么协方差矩阵元素 (C_{ij}) 即为(x_i)和(x_j)的协方差。元素 (C_{ii}) 即为(x_i)的方差。

请参见算法概述中的注释。

参数：

marray_like

包含多个变量和观察值的一维或二维数组。 m的每一行代表一个变量，每一列代表所有这些变量的单个观察值。也参见下面的 rowvar。

yarray_like，可选

另一组变量和观察值。y与m具有相同的形式。

rowvarbool，可选

如果 rowvar 为 True（默认值），则每行代表一个变量，列中包含观察。否则，关系被转置：每列代表一个变量，而行包含观察。

biasbool，可选

默认归一化（False）是由(N - 1)实现的，其中N是给定的观察数量（无偏估计）。如果 bias 为 True，则正常化为N。这些值可以在 numpy 版本 >= 1.5 中通过使用关键字ddof进行覆盖。

ddofint，可选

如果不是None，则会覆盖 bias 隐含的默认值。请注意，即使 fweights 和 aweights 都被指定，当ddof=1时也会返回无偏估计，而ddof=0将返回简单平均值。详情请参阅注释。默认值为None。

版本 1.5 中的新增内容。

fweightsarray_like，int，可选

整数频率权重的一维数组；每个观察向量应重复的次数。

版本 1.10 中的新增内容。

aweightsarray_like，可选

观察向量权重的一维数组。这些相对权重对于被认为“重要”的观察通常很大，对于被认为不太“重要”的观察则较小。如果ddof=0，权重数组可以用于为观察向量分配概率。

版本 1.10 中的新增内容。

dtype数据类型，可选

结果的数据类型。默认情况下，返回数据类型至少为numpy.float64精度。

版本 1.20 中的新增内容。

outndarray

变量的协方差矩阵。

另请参阅

corrcoef

标准化协方差矩阵

注释

假设观察在观察数组 m 的列中，并且为简洁起见，令f = fweights和a = aweights。计算加权协方差的步骤如下：

>>> m = np.arange(10, dtype=np.float64)
>>> f = np.arange(10) * 2
>>> a = np.arange(10) ** 2.
>>> ddof = 1
>>> w = f * a
>>> v1 = np.sum(w)
>>> v2 = np.sum(w * a)
>>> m -= np.sum(m * w, axis=None, keepdims=True) / v1
>>> cov = np.dot(m * w, m.T) * v1 / (v1**2 - ddof * v2)

请注意，当a == 1时，归一化因子v1 / (v1**2 - ddof * v2)应为1 / (np.sum(f) - ddof)。

示例

考虑两个变量，(x_0)和(x_1)，它们之间存在完美的负相关关系：

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

注意当(x_0)增加时，(x_1)减少。协方差矩阵清楚地显示了这一点：

>>> np.cov(x)
array([[ 1., -1.],
 [-1.,  1.]])

请注意元素(C_{0,1})，显示了(x_0)和(x_1)之间的相关性为负。

此外，注意x和y是如何结合在一起的：

>>> x = [-2.1, -1,  4.3]
>>> y = [3,  1.1,  0.12]
>>> X = np.stack((x, y), axis=0)
>>> np.cov(X)
array([[11.71      , -4.286     ], # may vary
 [-4.286     ,  2.144133]])
>>> np.cov(x, y)
array([[11.71      , -4.286     ], # may vary
 [-4.286     ,  2.144133]])
>>> np.cov(x)
array(11.71)

`numpy.histogram`

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

numpy.histogram(a, bins=10, range=None, density=None, weights=None)

计算数据集的直方图。

参数:

a类似数组

输入数据。直方图是在扁平化数组上计算的。

bins整数或标量序列或字符串，可选

如果bins为整数，则定义给定范围内等宽箱的数量（默认为 10）。如果bins为序列，则定义一个单调递增的箱边数组，包括最右边的边缘，允许不均匀的箱宽。

新版本 1.11.0 中引入。

如果bins为字符串，则定义用于计算最佳箱宽的方法，定义为histogram_bin_edges。

range（浮点数，浮点数），可选

箱子的下限和上限。如果未提供，则范围简单地为(a.min(), a.max())。超出范围的值将被忽略。范围的第一个元素必须小于或等于第二个元素。range也会影响自动箱计算。虽然根据range内的实际数据计算出最优的箱宽，但箱数将填满整个范围，包括不包含数据的部分。

weights类似数组，可选

与a形状相同的权重数组。仅对a中的每个值对应的权重对箱计数做贡献（而不是 1）。如果density为 True，则权重将被归一化，以使范围上的密度积分保持为 1。

density布尔型，可选

如果为False，结果将包含每个箱中的样本数。如果为True，结果是箱中概率密度函数的值，在此范围上归一化为 1。请注意，直方图值的总和除非选择单位宽度的箱子，否则将不等于 1；这不是概率质量函数。

hist数组

直方图的值。请参阅密度和权重以了解可能的语义。

bin_edges浮点数数组

返回箱边（hist 的长度+1）。

另请参阅

histogramdd, bincount, searchsorted, digitize, histogram_bin_edges

注释

所有除了最后（右手边最大）箱子都是半开放的。换句话说，如果bins为：

[1, 2, 3, 4]

那么第一个箱子是[1, 2)（包括 1，但不包括 2），第二个是[2, 3)。然而，最后一个箱子是[3, 4]，它包括4。

示例

>>> np.histogram([1, 2, 1], bins=[0, 1, 2, 3])
(array([0, 2, 1]), array([0, 1, 2, 3]))
>>> np.histogram(np.arange(4), bins=np.arange(5), density=True)
(array([0.25, 0.25, 0.25, 0.25]), array([0, 1, 2, 3, 4]))
>>> np.histogram([[1, 2, 1], [1, 0, 1]], bins=[0,1,2,3])
(array([1, 4, 1]), array([0, 1, 2, 3]))

>>> a = np.arange(5)
>>> hist, bin_edges = np.histogram(a, density=True)
>>> hist
array([0.5, 0\. , 0.5, 0\. , 0\. , 0.5, 0\. , 0.5, 0\. , 0.5])
>>> hist.sum()
2.4999999999999996
>>> np.sum(hist * np.diff(bin_edges))
1.0

新版本 1.11.0 中引入。

使用 2 个顶峰随机数据和 2000 个点的自动箱选择方法示例：

>>> import matplotlib.pyplot as plt
>>> rng = np.random.RandomState(10)  # deterministic random data
>>> a = np.hstack((rng.normal(size=1000),
...                rng.normal(loc=5, scale=2, size=1000)))
>>> _ = plt.hist(a, bins='auto')  # arguments are passed to np.histogram
>>> plt.title("Histogram with 'auto' bins")
Text(0.5, 1.0, "Histogram with 'auto' bins")
>>> plt.show()

`numpy.histogram2d`

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

numpy.histogram2d(x, y, bins=10, range=None, density=None, weights=None)

计算两个数据样本的二维直方图。

参数：

x array_like，形状(N,)

包含要进行直方图制作的点的 x 坐标的数组。

y array_like，形状(N,)

包含要进行直方图制作的点的 y 坐标的数组。

bins int 或 array_like 或[int, int]或[array, array]，可选

bin 规范：

如果为 int，则两个维度的 bin 数量(nx=ny=bins)。
如果是 array_like，则两个维度的 bin 边缘(x_edges=y_edges=bins)。
如果[int, int]，每个维度的 bin 数量(nx, ny = bins)。
如果为[array, array]，则两个维度中的 bin 边缘(x_edges, y_edges = bins)。
一个组合[int, array]或[array, int]，其中 int 是 bin 的数量，array 是 bin 的边缘。

range array_like，形状(2,2)，可选

沿每个维度的 bin 的最左边和最右边的边缘(如果在bins参数中没有明确指定)：[[xmin, xmax], [ymin, ymax]]。此范围之外的所有值将被视为异常值，不计入直方图。

density bool，可选

如果为 False，返回每个 bin 中的样本数量。如果为 True，返回 bin 处的概率density函数，bin_count / sample_count / bin_area。

weights array_like，形状(N,)，可选

一个加权值数组w_i，对每个样本(x_i, y_i)进行加权。如果density为 True，则将对权重进行归一化为 1。如果density为 False，则返回的直方图的值等于落入每个 bin 的样本的权重之和。

H ndarray，形状(nx, ny)

与样本x和y的二维直方图。x中的值沿第一个维度进行直方图处理，而y中的值沿第二个维度进行直方图处理。

xedges ndarray，形状(nx+1,)

第一个维度的 bin 边缘。

yedges ndarray，形状(ny+1,)

第二个维度的 bin 边缘。

参见

histogram

1D 直方图

histogramdd

多维直方图

注意

当density为 True 时，返回的直方图是样本密度，定义为对bin_value * bin_area的乘积的所有 bin 的总和为 1。

请注意，直方图不遵循笛卡尔坐标系的惯例，其中x值在横轴上，y值在纵轴上。相反，x沿数组的第一个维度(垂直)进行直方图处理，y沿数组的第二个维度(水平)进行直方图处理。这确保与histogramdd的兼容性。

示例

>>> from matplotlib.image import NonUniformImage
>>> import matplotlib.pyplot as plt

使用可变 bin 宽度构建 2-D 直方图。首先定义 bin 的边缘：

>>> xedges = [0, 1, 3, 5]
>>> yedges = [0, 2, 3, 4, 6]

接下来我们创建一个具有随机 bin 内容的直方图 H：

>>> x = np.random.normal(2, 1, 100)
>>> y = np.random.normal(1, 1, 100)
>>> H, xedges, yedges = np.histogram2d(x, y, bins=(xedges, yedges))
>>> # Histogram does not follow Cartesian convention (see Notes),
>>> # therefore transpose H for visualization purposes.
>>> H = H.T

imshow（https://matplotlib.org/stable/api/_as-gen/matplotlib.pyplot.imshow.html#matplotlib.pyplot.imshow）只能显示方形箱子：

>>> fig = plt.figure(figsize=(7, 3))
>>> ax = fig.add_subplot(131, title='imshow: square bins')
>>> plt.imshow(H, interpolation='nearest', origin='lower',
...         extent=[xedges[0], xedges[-1], yedges[0], yedges[-1]])
<matplotlib.image.AxesImage object at 0x...>

pcolormesh（https://matplotlib.org/stable/api/_as-gen/matplotlib.pyplot.pcolormesh.html#matplotlib.pyplot.pcolormesh）可以显示实际的边缘：

>>> ax = fig.add_subplot(132, title='pcolormesh: actual edges',
...         aspect='equal')
>>> X, Y = np.meshgrid(xedges, yedges)
>>> ax.pcolormesh(X, Y, H)
<matplotlib.collections.QuadMesh object at 0x...>

NonUniformImage（https://matplotlib.org/stable/api/image_api.html#matplotlib.image.NonUniformImage）可用于显示实际的箱边和插值：

>>> ax = fig.add_subplot(133, title='NonUniformImage: interpolated',
...         aspect='equal', xlim=xedges[[0, -1]], ylim=yedges[[0, -1]])
>>> im = NonUniformImage(ax, interpolation='bilinear')
>>> xcenters = (xedges[:-1] + xedges[1:]) / 2
>>> ycenters = (yedges[:-1] + yedges[1:]) / 2
>>> im.set_data(xcenters, ycenters, H)
>>> ax.add_image(im)
>>> plt.show()

../../_images/numpy-histogram2d-1_00_00.png

也可以构建一个二维直方图而不指定箱边：

>>> # Generate non-symmetric test data
>>> n = 10000
>>> x = np.linspace(1, 100, n)
>>> y = 2*np.log(x) + np.random.rand(n) - 0.5
>>> # Compute 2d histogram. Note the order of x/y and xedges/yedges
>>> H, yedges, xedges = np.histogram2d(y, x, bins=20)

现在我们可以使用pcolormesh（https://matplotlib.org/stable/api/_as-gen/matplotlib.pyplot.pcolormesh.html#matplotlib.pyplot.pcolormesh）绘制直方图，并使用hexbin（https://matplotlib.org/stable/api/_as-gen/matplotlib.pyplot.hexbin.html#matplotlib.pyplot.hexbin）进行比较。

>>> # Plot histogram using pcolormesh
>>> fig, (ax1, ax2) = plt.subplots(ncols=2, sharey=True)
>>> ax1.pcolormesh(xedges, yedges, H, cmap='rainbow')
>>> ax1.plot(x, 2*np.log(x), 'k-')
>>> ax1.set_xlim(x.min(), x.max())
>>> ax1.set_ylim(y.min(), y.max())
>>> ax1.set_xlabel('x')
>>> ax1.set_ylabel('y')
>>> ax1.set_title('histogram2d')
>>> ax1.grid()

>>> # Create hexbin plot for comparison
>>> ax2.hexbin(x, y, gridsize=20, cmap='rainbow')
>>> ax2.plot(x, 2*np.log(x), 'k-')
>>> ax2.set_title('hexbin')
>>> ax2.set_xlim(x.min(), x.max())
>>> ax2.set_xlabel('x')
>>> ax2.grid()

>>> plt.show()

../../_images/numpy-histogram2d-1_01_00.png

>>> ax = fig.add_subplot(132, title='pcolormesh: actual edges',
...         aspect='equal')
>>> X, Y = np.meshgrid(xedges, yedges)
>>> ax.pcolormesh(X, Y, H)
<matplotlib.collections.QuadMesh object at 0x...>

NonUniformImage（https://matplotlib.org/stable/api/image_api.html#matplotlib.image.NonUniformImage）可用于显示实际的箱边和插值：

>>> ax = fig.add_subplot(133, title='NonUniformImage: interpolated',
...         aspect='equal', xlim=xedges[[0, -1]], ylim=yedges[[0, -1]])
>>> im = NonUniformImage(ax, interpolation='bilinear')
>>> xcenters = (xedges[:-1] + xedges[1:]) / 2
>>> ycenters = (yedges[:-1] + yedges[1:]) / 2
>>> im.set_data(xcenters, ycenters, H)
>>> ax.add_image(im)
>>> plt.show()

[外链图片转存中…(img-BAmkj6IO-1719458427240)]

也可以构建一个二维直方图而不指定箱边：

>>> # Generate non-symmetric test data
>>> n = 10000
>>> x = np.linspace(1, 100, n)
>>> y = 2*np.log(x) + np.random.rand(n) - 0.5
>>> # Compute 2d histogram. Note the order of x/y and xedges/yedges
>>> H, yedges, xedges = np.histogram2d(y, x, bins=20)

>>> # Plot histogram using pcolormesh
>>> fig, (ax1, ax2) = plt.subplots(ncols=2, sharey=True)
>>> ax1.pcolormesh(xedges, yedges, H, cmap='rainbow')
>>> ax1.plot(x, 2*np.log(x), 'k-')
>>> ax1.set_xlim(x.min(), x.max())
>>> ax1.set_ylim(y.min(), y.max())
>>> ax1.set_xlabel('x')
>>> ax1.set_ylabel('y')
>>> ax1.set_title('histogram2d')
>>> ax1.grid()

>>> # Create hexbin plot for comparison
>>> ax2.hexbin(x, y, gridsize=20, cmap='rainbow')
>>> ax2.plot(x, 2*np.log(x), 'k-')
>>> ax2.set_title('hexbin')
>>> ax2.set_xlim(x.min(), x.max())
>>> ax2.set_xlabel('x')
>>> ax2.grid()