SciPy 1.12 中文文档（五十九）

原文：docs.scipy.org/doc/scipy-1.12.0/index.html

`scipy.stats.nbinom`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.nbinom.html#scipy.stats.nbinom

scipy.stats.nbinom = <scipy.stats._discrete_distns.nbinom_gen object>

负二项离散随机变量。

作为 rv_discrete 类的一个实例，nbinom 对象继承了一组通用方法（下面完整列表），并根据这个特定分布补充了细节。

另请参阅

hypergeom, binom, nhypergeom

注意事项

负二项分布描述了一系列独立同分布的伯努利试验，重复进行直到达到预定的非随机成功次数。

nbinom 的失败次数的概率质量函数是：

[f(k) = \binom{k+n-1}{n-1} p^n (1-p)^k]

对于 (k \ge 0), (0 < p \leq 1)

nbinom 接受 (n) 和 (p) 作为形状参数，其中 (n) 是成功次数，(p) 是单次成功的概率，(1-p) 是单次失败的概率。

负二项分布的另一种常见参数化是通过平均失败次数 (\mu) 来实现 (n) 次成功。平均值 (\mu) 与成功概率的关系如下

[p = \frac{n}{n + \mu}]

成功次数 (n) 也可以用“分散度”、“异质性”或“聚合度”参数 (\alpha) 来指定，它将平均值 (\mu) 与方差 (\sigma²) 关联起来，例如 (\sigma² = \mu + \alpha \mu²)。无论使用 (\alpha) 的哪种约定，

[\begin{split}p &= \frac{\mu}{\sigma²} \ n &= \frac{\mu²}{\sigma² - \mu}\end{split}]

上面的概率质量函数是以“标准化”形式定义的。要移动分布，请使用 loc 参数。具体而言，nbinom.pmf(k, n, p, loc) 等同于 nbinom.pmf(k - loc, n, p)。

示例

>>> import numpy as np
>>> from scipy.stats import nbinom
>>> import matplotlib.pyplot as plt
>>> fig, ax = plt.subplots(1, 1)

计算前四个矩：

>>> n, p = 5, 0.5
>>> mean, var, skew, kurt = nbinom.stats(n, p, moments='mvsk')

显示概率质量函数 (pmf)：

>>> x = np.arange(nbinom.ppf(0.01, n, p),
...               nbinom.ppf(0.99, n, p))
>>> ax.plot(x, nbinom.pmf(x, n, p), 'bo', ms=8, label='nbinom pmf')
>>> ax.vlines(x, 0, nbinom.pmf(x, n, p), colors='b', lw=5, alpha=0.5)

或者，可以调用分布对象（作为函数）来固定形状和位置。这将返回一个“冻结”的随机变量对象，保持给定的参数不变。

冻结分布并显示冻结的 pmf：

>>> rv = nbinom(n, p)
>>> ax.vlines(x, 0, rv.pmf(x), colors='k', linestyles='-', lw=1,
...         label='frozen pmf')
>>> ax.legend(loc='best', frameon=False)
>>> plt.show()

../../_images/scipy-stats-nbinom-1_00_00.png

检查 cdf 和 ppf 的准确性：

>>> prob = nbinom.cdf(x, n, p)
>>> np.allclose(x, nbinom.ppf(prob, n, p))
True

生成随机数：

>>> r = nbinom.rvs(n, p, size=1000)

方法

rvs(n, p, loc=0, size=1, random_state=None)	随机变量。
pmf(k, n, p, loc=0)	概率质量函数。
logpmf(k, n, p, loc=0)	概率质量函数的对数。
cdf(k, n, p, loc=0)	累积分布函数。
logcdf(k, n, p, loc=0)	累积分布函数的对数。
sf(k, n, p, loc=0)	生存函数（也定义为 `1 - cdf`，但sf有时更精确）。
logsf(k, n, p, loc=0)	生存函数的对数。
ppf(q, n, p, loc=0)	百分位点函数（`cdf`的逆函数，即百分位数）。
isf(q, n, p, loc=0)	逆生存函数（`sf`的逆函数）。
stats(n, p, loc=0, moments=’mv’)	均值（‘m’）、方差（‘v’）、偏度（‘s’）和/或峰度（‘k’）。
entropy(n, p, loc=0)	随机变量的（微分）熵。
expect(func, args=(n, p), loc=0, lb=None, ub=None, conditional=False)	期望值（对于分布的一个参数的函数）。
median(n, p, loc=0)	分布的中位数。
mean(n, p, loc=0)	分布的均值。
var(n, p, loc=0)	分布的方差。
std(n, p, loc=0)	分布的标准差。
interval(confidence, n, p, loc=0)	置信区间，围绕中位数有相等的区域。

`scipy.stats.nchypergeom_fisher`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.nchypergeom_fisher.html#scipy.stats.nchypergeom_fisher

scipy.stats.nchypergeom_fisher = <scipy.stats._discrete_distns.nchypergeom_fisher_gen object>

Fisher 的非中心超几何离散随机变量。

Fisher 的非中心超几何分布模型从箱中抽取两种类型的物体。 M 是总物体数， n 是类型 I 物体的数量， odds 是赔率比：当每种类型只有一个物体时选择类型 I 物体而不是类型 II 物体的赔率。随机变量表示从箱子中一把抓取物体后抽取的类型 I 物体数量，事后发现我们抓取了 N 个物体。

作为 rv_discrete 类的一个实例，nchypergeom_fisher 对象继承了该类的一系列通用方法（下面列出了完整列表），并完成了这些方法与该特定分布的详细信息。

参见

nchypergeom_wallenius, hypergeom, nhypergeom

注释

让数学符号 (N), (n), 和 (M) 分别对应上述定义的参数 N, n, 和 M。

概率质量函数定义为

[p(x; M, n, N, \omega) = \frac{\binom{n}{x}\binom{M - n}{N-x}\omega^x}{P_0},]

对于 (x \in [x_l, x_u]), (M \in {\mathbb N}), (n \in [0, M]), (N \in [0, M]), (\omega > 0), 其中 (x_l = \max(0, N - (M - n))), (x_u = \min(N, n)),

[P_0 = \sum_{y=x_l}^{x_u} \binom{n}{y}\binom{M - n}{N-y}\omega^y,]

并且二项式系数定义为

[\binom{n}{k} \equiv \frac{n!}{k! (n - k)!}.]

nchypergeom_fisher 使用 Agner Fog 的 BiasedUrn 包，并在 SciPy 许可下分发。

用于表示形状参数 (N, n, 和 M) 的符号并非普遍接受；选择这些符号是为了与 hypergeom 保持一致。

请注意，Fisher 的非中心超几何分布与 Wallenius 的非中心超几何分布不同，Wallenius 模型从箱子中逐个抽取预定数量的 N 物体。然而，当赔率比为单位时，两个分布都归结为普通超几何分布。

上述概率质量函数以“标准化”形式定义。要移动分布，请使用 loc 参数。具体来说，nchypergeom_fisher.pmf(k, M, n, N, odds, loc) 与 nchypergeom_fisher.pmf(k - loc, M, n, N, odds) 是完全等价的。

参考文献

[1]

阿格内尔·福格，《有偏抽奖理论》。cran.r-project.org/web/packages/BiasedUrn/vignettes/UrnTheory.pdf

[2]

“费舍尔的非中心超几何分布”，维基百科，en.wikipedia.org/wiki/Fisher’s_noncentral_hypergeometric_distribution

示例

>>> import numpy as np
>>> from scipy.stats import nchypergeom_fisher
>>> import matplotlib.pyplot as plt
>>> fig, ax = plt.subplots(1, 1)

计算前四个时刻：

>>> M, n, N, odds = 140, 80, 60, 0.5
>>> mean, var, skew, kurt = nchypergeom_fisher.stats(M, n, N, odds, moments='mvsk')

显示概率质量函数（pmf）：

>>> x = np.arange(nchypergeom_fisher.ppf(0.01, M, n, N, odds),
...               nchypergeom_fisher.ppf(0.99, M, n, N, odds))
>>> ax.plot(x, nchypergeom_fisher.pmf(x, M, n, N, odds), 'bo', ms=8, label='nchypergeom_fisher pmf')
>>> ax.vlines(x, 0, nchypergeom_fisher.pmf(x, M, n, N, odds), colors='b', lw=5, alpha=0.5)

或者，可以调用分布对象（作为函数）以固定形状和位置。这将返回一个“冻结”的随机变量对象，保持给定的参数不变。

冻结分布并显示冻结的 pmf：

>>> rv = nchypergeom_fisher(M, n, N, odds)
>>> ax.vlines(x, 0, rv.pmf(x), colors='k', linestyles='-', lw=1,
...         label='frozen pmf')
>>> ax.legend(loc='best', frameon=False)
>>> plt.show()

../../_images/scipy-stats-nchypergeom_fisher-1_00_00.png

检查 cdf 和 ppf 的准确性：

>>> prob = nchypergeom_fisher.cdf(x, M, n, N, odds)
>>> np.allclose(x, nchypergeom_fisher.ppf(prob, M, n, N, odds))
True

生成随机数：

>>> r = nchypergeom_fisher.rvs(M, n, N, odds, size=1000)

方法

rvs(M, n, N, odds, loc=0, size=1, random_state=None)	随机变量。
pmf(k, M, n, N, odds, loc=0)	概率质量函数。
logpmf(k, M, n, N, odds, loc=0)	概率质量函数的对数。
cdf(k, M, n, N, odds, loc=0)	累积分布函数。
logcdf(k, M, n, N, odds, loc=0)	累积分布函数的对数。
sf(k, M, n, N, odds, loc=0)	生存函数（也被定义为 `1 - cdf`，但 sf 有时更精确）。
logsf(k, M, n, N, odds, loc=0)	生存函数的对数。
ppf(q, M, n, N, odds, loc=0)	百分点函数（`cdf` 的反函数 — 百分位数）。
isf(q, M, n, N, odds, loc=0)	生存函数的反函数（`sf`的反函数）。
stats(M, n, N, odds, loc=0, moments=’mv’)	均值（‘m’）、方差（‘v’）、偏度（‘s’）和/或峰度（‘k’）。
entropy(M, n, N, odds, loc=0)	随机变量的（微分）熵。
expect(func, args=(M, n, N, odds), loc=0, lb=None, ub=None, conditional=False)	对于分布的函数（一个参数）的期望值。
median(M, n, N, odds, loc=0)	分布的中位数。
mean(M, n, N, odds, loc=0)	分布的均值。
var(M, n, N, odds, loc=0)	分布的方差。
std(M, n, N, odds, loc=0)	分布的标准差。
interval(confidence, M, n, N, odds, loc=0)	周围面积相等的置信区间，围绕中位数。

`scipy.stats.nchypergeom_wallenius`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.nchypergeom_wallenius.html#scipy.stats.nchypergeom_wallenius

scipy.stats.nchypergeom_wallenius = <scipy.stats._discrete_distns.nchypergeom_wallenius_gen object>

Wallenius'非中心超几何离散随机变量。

Wallenius'非中心超几何分布模型从一个箱子中抽取两种类型的对象。M是对象的总数，n是第一类型对象的数量，odds是赔率比：当每种类型只有一个对象时，选择第一类型对象而不是第二类型对象的比率。随机变量表示如果我们从一个箱子中逐个抽取预定的N个对象，则抽取的第一类型对象的数量。

作为rv_discrete类的一个实例，nchypergeom_wallenius对象从中继承了一系列通用方法（下面详细列出），并根据这一特定分布完善了它们的细节。

参见

nchypergeom_fisher，hypergeom，nhypergeom

注意事项

让数学符号(N)，(n)和(M)分别对应于上述定义的参数N，n和M。

概率质量函数定义为

[p(x; N, n, M) = \binom{n}{x} \binom{M - n}{N-x} \int_0¹ \left(1-t^{\omega/D}\right)^x\left(1-t^{1/D}\right)^{N-x} dt]

对于(x \in [x_l, x_u])，(M \in {\mathbb N})，(n \in [0, M])，(N \in [0, M])，(\omega > 0)，其中(x_l = \max(0, N - (M - n)))，(x_u = \min(N, n))，

[D = \omega(n - x) + ((M - n)-(N-x)),]

和二项式系数定义为

[\binom{n}{k} \equiv \frac{n!}{k! (n - k)!}.]

nchypergeom_wallenius使用 Agner Fog 的 BiasedUrn 包，根据 SciPy 的许可分发。

用于表示形状参数（N，n和M）的符号并不是普遍接受的；它们被选择是为了与hypergeom保持一致。

请注意，Wallenius'非中心超几何分布与 Fisher's 非中心超几何分布不同，后者模拟一次从箱子中抽取少量对象，后来发现抽取了N个对象。然而，当赔率比为 1 时，这两个分布都会减少到普通超几何分布。

上述概率质量函数以“标准化”形式定义。要移动分布，请使用 loc 参数。具体来说，nchypergeom_wallenius.pmf(k, M, n, N, odds, loc) 与 nchypergeom_wallenius.pmf(k - loc, M, n, N, odds) 是完全等价的。

参考文献

[1]

Agner Fog，“偏倚球理论”。cran.r-project.org/web/packages/BiasedUrn/vignettes/UrnTheory.pdf

[2]

“瓦列尼乌斯非中心超几何分布”，维基百科，en.wikipedia.org/wiki/Wallenius’_noncentral_hypergeometric_distribution

示例

>>> import numpy as np
>>> from scipy.stats import nchypergeom_wallenius
>>> import matplotlib.pyplot as plt
>>> fig, ax = plt.subplots(1, 1)

计算前四个时刻：

>>> M, n, N, odds = 140, 80, 60, 0.5
>>> mean, var, skew, kurt = nchypergeom_wallenius.stats(M, n, N, odds, moments='mvsk')

显示概率质量函数（pmf）：

>>> x = np.arange(nchypergeom_wallenius.ppf(0.01, M, n, N, odds),
...               nchypergeom_wallenius.ppf(0.99, M, n, N, odds))
>>> ax.plot(x, nchypergeom_wallenius.pmf(x, M, n, N, odds), 'bo', ms=8, label='nchypergeom_wallenius pmf')
>>> ax.vlines(x, 0, nchypergeom_wallenius.pmf(x, M, n, N, odds), colors='b', lw=5, alpha=0.5)

或者，可以调用分布对象（作为函数）以固定形状和位置。这将返回一个保持给定参数固定的“冻结”RV 对象。

冻结分布并显示冻结的 pmf：

>>> rv = nchypergeom_wallenius(M, n, N, odds)
>>> ax.vlines(x, 0, rv.pmf(x), colors='k', linestyles='-', lw=1,
...         label='frozen pmf')
>>> ax.legend(loc='best', frameon=False)
>>> plt.show()

../../_images/scipy-stats-nchypergeom_wallenius-1_00_00.png

检查cdf和ppf的准确性：

>>> prob = nchypergeom_wallenius.cdf(x, M, n, N, odds)
>>> np.allclose(x, nchypergeom_wallenius.ppf(prob, M, n, N, odds))
True

生成随机数：

>>> r = nchypergeom_wallenius.rvs(M, n, N, odds, size=1000)

方法

rvs(M, n, N, odds, loc=0, size=1, random_state=None)	随机变量。
pmf(k, M, n, N, odds, loc=0)	概率质量函数。
logpmf(k, M, n, N, odds, loc=0)	概率质量函数的对数。
cdf(k, M, n, N, odds, loc=0)	累积分布函数。
logcdf(k, M, n, N, odds, loc=0)	累积分布函数的对数。
sf(k, M, n, N, odds, loc=0)	生存函数（也定义为 `1 - cdf`，但 sf 有时更精确）。
logsf(k, M, n, N, odds, loc=0)	生存函数的对数。
ppf(q, M, n, N, odds, loc=0)	百分点函数（`cdf`的逆函数 — 百分位数）。
isf(q, M, n, N, odds, loc=0)	逆生存函数（`sf`的逆函数）。
stats(M, n, N, odds, loc=0, moments=’mv’)	均值（‘m’）、方差（‘v’）、偏度（‘s’）和/或峰度（‘k’）。
entropy(M, n, N, odds, loc=0)	RV 的（微分）熵。
expect(func, args=(M, n, N, odds), loc=0, lb=None, ub=None, conditional=False)	关于分布的函数（单参数）的期望值。
median(M, n, N, odds, loc=0)	分布的中位数。
mean(M, n, N, odds, loc=0)	分布的均值。
var(M, n, N, odds, loc=0)	分布的方差。
std(M, n, N, odds, loc=0)	分布的标准差。
interval(confidence, M, n, N, odds, loc=0)	以中位数为中心的等面积置信区间。

`scipy.stats.nhypergeom`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.nhypergeom.html#scipy.stats.nhypergeom

scipy.stats.nhypergeom = <scipy.stats._discrete_distns.nhypergeom_gen object>

负超几何离散随机变量。

考虑一个包含(M)个球的盒子：(n)个红球和(M-n)个蓝球。我们从盒子中随机抽取球，一次一个，且不放回，直到我们选出(r)个蓝球。nhypergeom是我们选出的红球数(k)的分布。

作为rv_discrete类的一个实例，nhypergeom对象从中继承了一组通用方法（请参阅下文完整列表），并针对此特定分布提供了详细信息。

另请参阅

hypergeom，binom，nbinom

笔记

用于表示形状参数（M、n和r）的符号在各地并非普遍接受。请参阅示例以了解此处使用的定义。

概率质量函数定义如下，

[f(k; M, n, r) = \frac{{{k+r-1}\choose{k}}{{M-r-k}\choose{n-k}}} {{M \choose n}}]

对于(k \in [0, n])，(n \in [0, M])，(r \in [0, M-n])，二项式系数为：

[\binom{n}{k} \equiv \frac{n!}{k! (n - k)!}.]

它等同于观察(k)个成功在(k+r-1)个样本中，其中第(k+r)个样本是失败。前者可以建模为超几何分布。后者的概率只是剩余失败数(M-n-(r-1))除以剩余总体大小(M-(k+r-1))。这种关系可以表示为：

[NHG(k;M,n,r) = HG(k;M,n,k+r-1)\frac{(M-n-(r-1))}{(M-(k+r-1))}]

其中(NHG)是负超几何分布的概率质量函数（PMF），而(HG)是超几何分布的 PMF。

上述概率质量函数以“标准化”形式定义。要移动分布，请使用loc参数。具体而言，nhypergeom.pmf(k, M, n, r, loc)等效于nhypergeom.pmf(k - loc, M, n, r)。

参考资料

[1]

负超几何分布在维基百科上的介绍：en.wikipedia.org/wiki/Negative_hypergeometric_distribution

[2]

来自Negative Hypergeometric Distribution（负超几何分布）

示例

>>> import numpy as np
>>> from scipy.stats import nhypergeom
>>> import matplotlib.pyplot as plt

假设我们有一组 20 只动物，其中 7 只是狗。那么如果我们想知道在一个样本中找到给定数量的狗（成功）在恰好 12 只非狗（失败）的样本中的概率，我们可以初始化一个冻结的分布并绘制概率质量函数：

>>> M, n, r = [20, 7, 12]
>>> rv = nhypergeom(M, n, r)
>>> x = np.arange(0, n+2)
>>> pmf_dogs = rv.pmf(x)

>>> fig = plt.figure()
>>> ax = fig.add_subplot(111)
>>> ax.plot(x, pmf_dogs, 'bo')
>>> ax.vlines(x, 0, pmf_dogs, lw=2)
>>> ax.set_xlabel('# of dogs in our group with given 12 failures')
>>> ax.set_ylabel('nhypergeom PMF')
>>> plt.show()

../../_images/scipy-stats-nhypergeom-1_00_00.png

除了使用冻结分布外，我们也可以直接使用nhypergeom的方法。例如，要获取概率质量函数，使用：

>>> prb = nhypergeom.pmf(x, M, n, r)

要生成随机数：

>>> R = nhypergeom.rvs(M, n, r, size=10)

要验证hypergeom和nhypergeom之间的关系，请使用：

>>> from scipy.stats import hypergeom, nhypergeom
>>> M, n, r = 45, 13, 8
>>> k = 6
>>> nhypergeom.pmf(k, M, n, r)
0.06180776620271643
>>> hypergeom.pmf(k, M, n, k+r-1) * (M - n - (r-1)) / (M - (k+r-1))
0.06180776620271644

方法

rvs(M, n, r, loc=0, size=1, random_state=None)	随机变量。
pmf(k, M, n, r, loc=0)	概率质量函数。
logpmf(k, M, n, r, loc=0)	概率质量函数的对数。
cdf(k, M, n, r, loc=0)	累积分布函数。
logcdf(k, M, n, r, loc=0)	累积分布函数的对数。
sf(k, M, n, r, loc=0)	生存函数（也定义为`1 - cdf`，但sf有时更精确）。
logsf(k, M, n, r, loc=0)	生存函数的对数。
ppf(q, M, n, r, loc=0)	百分点函数（`cdf`的逆函数 — 百分位数）。
isf(q, M, n, r, loc=0)	逆生存函数（`sf`的逆函数）。
stats(M, n, r, loc=0, moments=’mv’)	均值（‘m’）、方差（‘v’）、偏度（‘s’）、峰度（‘k’）。
entropy(M, n, r, loc=0)	随机变量的（微分）熵。
expect(func, args=(M, n, r), loc=0, lb=None, ub=None, conditional=False)	对于分布的函数（一个参数的）的期望值。
median(M, n, r, loc=0)	分布的中位数。
mean(M, n, r, loc=0)	分布的均值。
var(M, n, r, loc=0)	分布的方差。
std(M, n, r, loc=0)	分布的标准偏差。
interval(confidence, M, n, r, loc=0)	中位数周围面积相等的置信区间。

`scipy.stats.planck`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.planck.html#scipy.stats.planck

scipy.stats.planck = <scipy.stats._discrete_distns.planck_gen object>

Planck 离散指数随机变量。

作为 rv_discrete 类的一个实例，planck 对象继承了一组通用方法（下面详细列出），并根据此特定分布进行了补充。

另请参阅

geom

注释

planck 的概率质量函数如下：

[f(k) = (1-\exp(-\lambda)) \exp(-\lambda k)]

对于 (k \ge 0) 和 (\lambda > 0)。

planck 将 (\lambda) 视为形状参数。Planck 分布可以写成以 p = 1 - \exp(-\lambda) 为参数的几何分布（geom），并且以 loc = -1 进行了平移。

上述概率质量函数定义为“标准化”形式。使用 loc 参数进行分布偏移。具体而言，planck.pmf(k, lambda_, loc) 与 planck.pmf(k - loc, lambda_) 完全等价。

示例

>>> import numpy as np
>>> from scipy.stats import planck
>>> import matplotlib.pyplot as plt
>>> fig, ax = plt.subplots(1, 1)

计算前四个矩：

>>> lambda_ = 0.51
>>> mean, var, skew, kurt = planck.stats(lambda_, moments='mvsk')

显示概率质量函数（pmf）：

>>> x = np.arange(planck.ppf(0.01, lambda_),
...               planck.ppf(0.99, lambda_))
>>> ax.plot(x, planck.pmf(x, lambda_), 'bo', ms=8, label='planck pmf')
>>> ax.vlines(x, 0, planck.pmf(x, lambda_), colors='b', lw=5, alpha=0.5)

或者，可以调用分布对象（作为函数）以固定形状和位置。这将返回一个“冻结”的 RV 对象，保存给定的参数。

冻结分布并显示冻结的 pmf：

>>> rv = planck(lambda_)
>>> ax.vlines(x, 0, rv.pmf(x), colors='k', linestyles='-', lw=1,
...         label='frozen pmf')
>>> ax.legend(loc='best', frameon=False)
>>> plt.show()

../../_images/scipy-stats-planck-1_00_00.png

检查 cdf 和 ppf 的准确性：

>>> prob = planck.cdf(x, lambda_)
>>> np.allclose(x, planck.ppf(prob, lambda_))
True

生成随机数：

>>> r = planck.rvs(lambda_, size=1000)

方法

rvs(lambda_, loc=0, size=1, random_state=None)	随机变量。
pmf(k, lambda_, loc=0)	概率质量函数。
logpmf(k, lambda_, loc=0)	概率质量函数的对数。
cdf(k, lambda_, loc=0)	累积分布函数。
logcdf(k, lambda_, loc=0)	累积分布函数的对数。
sf(k, lambda_, loc=0)	生存函数（也定义为 `1 - cdf`，但 sf 有时更精确）。
logsf(k, lambda_, loc=0)	生存函数的对数。
ppf(q, lambda_, loc=0)	百分点函数（`cdf` 的反函数 — 百分位数）。
isf(q, lambda_, loc=0)	生存函数的反函数（`sf` 的反函数）。
stats(lambda_, loc=0, moments=’mv’)	均值（‘m’）、方差（‘v’）、偏度（‘s’）和/或峰度（‘k’）。
entropy(lambda_, loc=0)	随机变量的（微分）熵。
expect(func, args=(lambda_,), loc=0, lb=None, ub=None, conditional=False)	期望值，关于分布的一个函数（一个参数）。
median(lambda_, loc=0)	分布的中位数。
mean(lambda_, loc=0)	分布的均值。
var(lambda_, loc=0)	分布的方差。
std(lambda_, loc=0)	分布的标准差。
interval(confidence, lambda_, loc=0)	置信区间，围绕中位数具有相等面积。

`scipy.stats.poisson`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.poisson.html#scipy.stats.poisson

scipy.stats.poisson = <scipy.stats._discrete_distns.poisson_gen object>

一个泊松离散随机变量。

作为 rv_discrete 类的一个实例，poisson 对象继承了一系列通用方法（请参见下面的完整列表），并用这个特定分布的细节补充完整。

注意事项

poisson 的概率质量函数为：

[f(k) = \exp(-\mu) \frac{\mu^k}{k!}]

对于 (k \ge 0)。

poisson 以 (\mu \geq 0) 作为形状参数。当 (\mu = 0) 时，pmf 方法在分位点 (k = 0) 处返回 1.0。

上述概率质量函数以“标准化”形式定义。使用 loc 参数来进行分布的移动。具体来说，poisson.pmf(k, mu, loc) 等同于 poisson.pmf(k - loc, mu)。

示例

>>> import numpy as np
>>> from scipy.stats import poisson
>>> import matplotlib.pyplot as plt
>>> fig, ax = plt.subplots(1, 1)

计算前四个矩：

>>> mu = 0.6
>>> mean, var, skew, kurt = poisson.stats(mu, moments='mvsk')

展示概率质量函数 (pmf):

>>> x = np.arange(poisson.ppf(0.01, mu),
...               poisson.ppf(0.99, mu))
>>> ax.plot(x, poisson.pmf(x, mu), 'bo', ms=8, label='poisson pmf')
>>> ax.vlines(x, 0, poisson.pmf(x, mu), colors='b', lw=5, alpha=0.5)

或者，可以像调用函数一样使用分布对象来固定形状和位置。这将返回一个固定了给定参数的“冻结”随机变量对象。

冻结分布并展示冻结的 pmf：

>>> rv = poisson(mu)
>>> ax.vlines(x, 0, rv.pmf(x), colors='k', linestyles='-', lw=1,
...         label='frozen pmf')
>>> ax.legend(loc='best', frameon=False)
>>> plt.show()

../../_images/scipy-stats-poisson-1_00_00.png

检查 cdf 和 ppf 的准确性：

>>> prob = poisson.cdf(x, mu)
>>> np.allclose(x, poisson.ppf(prob, mu))
True

生成随机数：

>>> r = poisson.rvs(mu, size=1000)

方法

rvs(mu, loc=0, size=1, random_state=None)	随机变量。
pmf(k, mu, loc=0)	概率质量函数。
logpmf(k, mu, loc=0)	概率质量函数的对数。
cdf(k, mu, loc=0)	累积分布函数。
logcdf(k, mu, loc=0)	累积分布函数的对数。
sf(k, mu, loc=0)	生存函数（也定义为 `1 - cdf`，但 sf 有时更准确）。
logsf(k, mu, loc=0)	生存函数的对数。
ppf(q, mu, loc=0)	百分位点函数（`cdf` 的逆 — 百分位数）。
isf(q, mu, loc=0)	逆生存函数（`sf` 的逆）。
stats(mu, loc=0, moments=’mv’)	均值（‘m’）、方差（‘v’）、偏度（‘s’）、及/或峰度（‘k’）。
entropy(mu, loc=0)	随机变量的（微分）熵。
expect(func, args=(mu,), loc=0, lb=None, ub=None, conditional=False)	期望值函数（具有一个参数的函数）相对于分布。
median(mu, loc=0)	分布的中位数。
mean(mu, loc=0)	分布的均值。
var(mu, loc=0)	分布的方差。
std(mu, loc=0)	分布的标准差。
interval(confidence, mu, loc=0)	中位数周围具有相等面积的置信区间。

`scipy.stats.randint`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.randint.html#scipy.stats.randint

scipy.stats.randint = <scipy.stats._discrete_distns.randint_gen object>

一个均匀离散随机变量。

作为 rv_discrete 类的一个实例，randint 对象继承了一些通用方法（见下面的完整列表），并且根据具体分布补充了特定细节。

注意

randint 的概率质量函数为：

[f(k) = \frac{1}{\texttt{high} - \texttt{low}}]

对于 (k \in {\texttt{low}, \dots, \texttt{high} - 1})。

randint 接受 low 和 high 作为形状参数。

上述概率质量函数定义为“标准化”形式。要转换分布，请使用 loc 参数。具体而言，randint.pmf(k, low, high, loc) 与 randint.pmf(k - loc, low, high) 完全等价。

示例

>>> import numpy as np
>>> from scipy.stats import randint
>>> import matplotlib.pyplot as plt
>>> fig, ax = plt.subplots(1, 1)

计算前四个时刻：

>>> low, high = 7, 31
>>> mean, var, skew, kurt = randint.stats(low, high, moments='mvsk')

显示概率质量函数 (pmf)：

>>> x = np.arange(low - 5, high + 5)
>>> ax.plot(x, randint.pmf(x, low, high), 'bo', ms=8, label='randint pmf')
>>> ax.vlines(x, 0, randint.pmf(x, low, high), colors='b', lw=5, alpha=0.5)

或者，可以调用分布对象（作为函数）来固定形状和位置。这将返回一个“冻结”的随机变量对象，保持给定参数不变。

冻结分布并显示冻结的 pmf：

>>> rv = randint(low, high)
>>> ax.vlines(x, 0, rv.pmf(x), colors='k', linestyles='-',
...           lw=1, label='frozen pmf')
>>> ax.legend(loc='lower center')
>>> plt.show()

../../_images/scipy-stats-randint-1_00_00.png

检查累积分布函数（cdf）与其逆函数百分点函数（ppf）之间的关系：

>>> q = np.arange(low, high)
>>> p = randint.cdf(q, low, high)
>>> np.allclose(q, randint.ppf(p, low, high))
True

生成随机数：

>>> r = randint.rvs(low, high, size=1000)

方法

rvs(low, high, loc=0, size=1, random_state=None)	随机变量。
pmf(k, low, high, loc=0)	概率质量函数。
logpmf(k, low, high, loc=0)	概率质量函数的对数。
cdf(k, low, high, loc=0)	累积分布函数。
logcdf(k, low, high, loc=0)	累积分布函数的对数。
sf(k, low, high, loc=0)	生存函数（也定义为 `1 - cdf`，但 sf 有时更精确）。
logsf(k, low, high, loc=0)	生存函数的对数。
ppf(q, low, high, loc=0)	百分点函数（`cdf` 的逆函数，即百分位数）。
isf(q, low, high, loc=0)	逆生存函数（`sf` 的逆函数）。
stats(low, high, loc=0, moments=’mv’)	均值（‘m’）、方差（‘v’）、偏度（‘s’）、峰度（‘k’）。
entropy(low, high, loc=0)	随机变量的（微分）熵。
expect(func, args=(low, high), loc=0, lb=None, ub=None, conditional=False)	计算函数（一个参数）相对于分布的期望值。
median(low, high, loc=0)	分布的中位数。
mean(low, high, loc=0)	分布的均值。
var(low, high, loc=0)	分布的方差。
std(low, high, loc=0)	分布的标准差。
interval(confidence, low, high, loc=0)	置信区间，中位数周围面积相等。

`scipy.stats.skellam`

原文链接：scipy.stats.skellam

scipy.stats.skellam = <scipy.stats._discrete_distns.skellam_gen object>

一个斯凯拉姆离散随机变量。

作为 rv_discrete 类的一个实例，skellam 对象继承了一系列通用方法（请参阅下面的完整列表），并针对这个特定分布补充了特定细节。

注释

两个相关或不相关泊松随机变量差的概率分布。

设 (k_1) 和 (k_2) 是两个期望值分别为 (\lambda_1) 和 (\lambda_2) 的泊松分布随机变量。那么，(k_1 - k_2) 符合参数为 (\mu_1 = \lambda_1 - \rho \sqrt{\lambda_1 \lambda_2}) 和 (\mu_2 = \lambda_2 - \rho \sqrt{\lambda_1 \lambda_2}) 的斯凯拉姆分布，其中 (\rho) 是 (k_1) 和 (k_2) 之间的相关系数。如果两个泊松分布随机变量是独立的，则 (\rho = 0)。

参数 (\mu_1) 和 (\mu_2) 必须严格为正数。

详细信息请参见：斯凯拉姆分布

skellam 以 (\mu_1) 和 (\mu_2) 作为形状参数。

上述概率质量函数以“标准化”形式定义。使用 loc 参数来改变分布位置。具体而言，skellam.pmf(k, mu1, mu2, loc) 与 skellam.pmf(k - loc, mu1, mu2) 完全等价。

示例

>>> import numpy as np
>>> from scipy.stats import skellam
>>> import matplotlib.pyplot as plt
>>> fig, ax = plt.subplots(1, 1)

计算前四个矩：

>>> mu1, mu2 = 15, 8
>>> mean, var, skew, kurt = skellam.stats(mu1, mu2, moments='mvsk')

显示概率质量函数（pmf）：

>>> x = np.arange(skellam.ppf(0.01, mu1, mu2),
...               skellam.ppf(0.99, mu1, mu2))
>>> ax.plot(x, skellam.pmf(x, mu1, mu2), 'bo', ms=8, label='skellam pmf')
>>> ax.vlines(x, 0, skellam.pmf(x, mu1, mu2), colors='b', lw=5, alpha=0.5)

或者，可以调用分布对象（作为函数）以固定形状和位置。这将返回一个持有给定参数固定的“冻结”随机变量对象。

冻结分布并显示冻结的 pmf：

>>> rv = skellam(mu1, mu2)
>>> ax.vlines(x, 0, rv.pmf(x), colors='k', linestyles='-', lw=1,
...         label='frozen pmf')
>>> ax.legend(loc='best', frameon=False)
>>> plt.show()

../../_images/scipy-stats-skellam-1_00_00.png

检查 cdf 和 ppf 的准确性：

>>> prob = skellam.cdf(x, mu1, mu2)
>>> np.allclose(x, skellam.ppf(prob, mu1, mu2))
True

生成随机数：

>>> r = skellam.rvs(mu1, mu2, size=1000)

方法

rvs(mu1, mu2, loc=0, size=1, random_state=None)	随机变量。
pmf(k, mu1, mu2, loc=0)	概率质量函数。
logpmf(k, mu1, mu2, loc=0)	概率质量函数的对数。
cdf(k, mu1, mu2, loc=0)	累积分布函数。
logcdf(k, mu1, mu2, loc=0)	累积分布函数的对数。
sf(k, mu1, mu2, loc=0)	生存函数（也定义为 `1 - cdf`，但 sf 有时更精确）。
logsf(k, mu1, mu2, loc=0)	生存函数的对数。
ppf(q, mu1, mu2, loc=0)	百分点函数（`cdf` 的反函数 — 百分位数）。
isf(q, mu1, mu2, loc=0)	逆生存函数（`sf` 的反函数）。
stats(mu1, mu2, loc=0, moments=’mv’)	均值（‘m’）、方差（‘v’）、偏度（‘s’）和/或峰度（‘k’）。
entropy(mu1, mu2, loc=0)	随机变量的（微分）熵。
expect(func, args=(mu1, mu2), loc=0, lb=None, ub=None, conditional=False)	对分布的一个参数函数（一个参数）的期望值。
median(mu1, mu2, loc=0)	分布的中位数。
mean(mu1, mu2, loc=0)	分布的均值。
var(mu1, mu2, loc=0)	分布的方差。
std(mu1, mu2, loc=0)	分布的标准差。
interval(confidence, mu1, mu2, loc=0)	中位数周围等面积置信区间。

`scipy.stats.yulesimon`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.yulesimon.html#scipy.stats.yulesimon

scipy.stats.yulesimon = <scipy.stats._discrete_distns.yulesimon_gen object>

Yule-Simon 离散随机变量。

作为 rv_discrete 类的一个实例，yulesimon 对象继承了一系列通用方法（下面列出完整列表），并通过特定于此特定分布的细节完善它们。

注释

yulesimon 的概率质量函数如下：

[f(k) = \alpha B(k, \alpha+1)]

对于 (k=1,2,3,...)，其中 (\alpha>0)。这里 (B) 是 scipy.special.beta 函数。

随机变量的采样基于[1]第 553 页第 6.3 节。我们的符号映射到通过 (\alpha=a-1) 引用的逻辑。

详细信息请参见维基百科条目[2]。

参考文献

[1]

Devroye, Luc. “非均匀随机变量生成”，（1986 年）斯普林格出版社，纽约。

[2]

en.wikipedia.org/wiki/Yule-Simon_distribution

上述概率质量函数定义为“标准化”形式。要移动分布，请使用 loc 参数。具体地说，yulesimon.pmf(k, alpha, loc) 与 yulesimon.pmf(k - loc, alpha) 完全等效。

示例

>>> import numpy as np
>>> from scipy.stats import yulesimon
>>> import matplotlib.pyplot as plt
>>> fig, ax = plt.subplots(1, 1)

计算前四个时刻：

>>> alpha = 11
>>> mean, var, skew, kurt = yulesimon.stats(alpha, moments='mvsk')

显示概率质量函数 (pmf)：

>>> x = np.arange(yulesimon.ppf(0.01, alpha),
...               yulesimon.ppf(0.99, alpha))
>>> ax.plot(x, yulesimon.pmf(x, alpha), 'bo', ms=8, label='yulesimon pmf')
>>> ax.vlines(x, 0, yulesimon.pmf(x, alpha), colors='b', lw=5, alpha=0.5)

或者，可以调用分布对象（作为函数）以固定形状和位置。这将返回一个“冻结”的 RV 对象，保持给定参数不变。

冻结分布并显示冻结的 pmf：

>>> rv = yulesimon(alpha)
>>> ax.vlines(x, 0, rv.pmf(x), colors='k', linestyles='-', lw=1,
...         label='frozen pmf')
>>> ax.legend(loc='best', frameon=False)
>>> plt.show()

../../_images/scipy-stats-yulesimon-1_00_00.png

检查 cdf 和 ppf 的准确性：

>>> prob = yulesimon.cdf(x, alpha)
>>> np.allclose(x, yulesimon.ppf(prob, alpha))
True

生成随机数：

>>> r = yulesimon.rvs(alpha, size=1000)

方法

rvs(alpha, loc=0, size=1, random_state=None)	随机变量。
pmf(k, alpha, loc=0)	概率质量函数。
logpmf(k, alpha, loc=0)	概率质量函数的对数。
cdf(k, alpha, loc=0)	累积分布函数。
logcdf(k, alpha, loc=0)	累积分布函数的对数。
sf(k, alpha, loc=0)	生存函数（也定义为 `1 - cdf`，但 sf 有时更精确）。
logsf(k, alpha, loc=0)	生存函数的对数。
ppf(q, alpha, loc=0)	百分位点函数（`cdf` 的反函数 — 百分位数）。
isf(q, alpha, loc=0)	逆生存函数（`sf` 的逆）。
stats(alpha, loc=0, moments=’mv’)	均值（‘m’）、方差（‘v’）、偏度（‘s’）、峰度（‘k’）。
entropy(alpha, loc=0)	RV 的（微分）熵。
expect(func, args=(alpha,), loc=0, lb=None, ub=None, conditional=False)	对分布中一个（一元）函数的期望值。
median(alpha, loc=0)	分布的中位数。
mean(alpha, loc=0)	分布的均值。
var(alpha, loc=0)	分布的方差。
std(alpha, loc=0)	分布的标准差。
interval(confidence, alpha, loc=0)	置信区间，围绕中位数具有相等面积。

`scipy.stats.zipf`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.zipf.html#scipy.stats.zipf

scipy.stats.zipf = <scipy.stats._discrete_distns.zipf_gen object>

一个 Zipf（Zeta）离散随机变量。

作为 rv_discrete 类的一个实例，zipf 对象继承了一组通用方法（下面详细列出），并补充了特定于此特定分布的细节。

另见

zipfian

注意

zipf 的概率质量函数是：

[f(k, a) = \frac{1}{\zeta(a) k^a}]

对于 (k \ge 1), (a > 1)。

zipf 将 (a > 1) 作为形状参数。(\zeta) 是黎曼 zeta 函数（scipy.special.zeta)

Zipf 分布也被称为 zeta 分布，是 Zipfian 分布的一个特例（zipfian）。

上述概率质量函数以“标准化”形式定义。要移动分布，请使用 loc 参数。具体来说，zipf.pmf(k, a, loc) 与 zipf.pmf(k - loc, a) 是完全等价的。

参考文献

[1]

“Zeta Distribution”，维基百科，en.wikipedia.org/wiki/Zeta_distribution

示例

>>> import numpy as np
>>> from scipy.stats import zipf
>>> import matplotlib.pyplot as plt
>>> fig, ax = plt.subplots(1, 1)

计算前四个时刻：

>>> a = 6.5
>>> mean, var, skew, kurt = zipf.stats(a, moments='mvsk')

显示概率质量函数（pmf）：

>>> x = np.arange(zipf.ppf(0.01, a),
...               zipf.ppf(0.99, a))
>>> ax.plot(x, zipf.pmf(x, a), 'bo', ms=8, label='zipf pmf')
>>> ax.vlines(x, 0, zipf.pmf(x, a), colors='b', lw=5, alpha=0.5)

或者，可以调用分布对象（作为函数）来固定形状和位置。这将返回一个“冻结”的 RV 对象，其中包含给定的参数。

冻结分布并显示冻结的 pmf：

>>> rv = zipf(a)
>>> ax.vlines(x, 0, rv.pmf(x), colors='k', linestyles='-', lw=1,
...         label='frozen pmf')
>>> ax.legend(loc='best', frameon=False)
>>> plt.show()

../../_images/scipy-stats-zipf-1_00_00.png

检查 cdf 和 ppf 的准确性：

>>> prob = zipf.cdf(x, a)
>>> np.allclose(x, zipf.ppf(prob, a))
True

生成随机数：

>>> r = zipf.rvs(a, size=1000)

确认 zipf 是 zipfian 的大 n 极限。

>>> import numpy as np
>>> from scipy.stats import zipf, zipfian
>>> k = np.arange(11)
>>> np.allclose(zipf.pmf(k, a), zipfian.pmf(k, a, n=10000000))
True

方法

rvs(a, loc=0, size=1, random_state=None)	随机变量。
pmf(k, a, loc=0)	概率质量函数。
logpmf(k, a, loc=0)	概率质量函数的对数。
cdf(k, a, loc=0)	累积分布函数。
logcdf(k, a, loc=0)	累积分布函数的对数。
sf(k, a, loc=0)	生存函数（也定义为 `1 - cdf`，但有时 sf 更准确）。
logsf(k, a, loc=0)	生存函数的对数。
ppf(q, a, loc=0)	百分位点函数（`cdf` 的逆函数 —— 百分位数）。
isf(q, a, loc=0)	生存函数的逆函数（`sf` 的逆）。
stats(a, loc=0, moments=’mv’)	均值（‘m’）、方差（‘v’）、偏度（‘s’）、峰度（‘k’）。
entropy(a, loc=0)	随机变量的（微分）熵。
expect(func, args=(a,), loc=0, lb=None, ub=None, conditional=False)	对于给定分布的函数（一个参数）的期望值。
median(a, loc=0)	分布的中位数。
mean(a, loc=0)	分布的均值。
var(a, loc=0)	分布的方差。
std(a, loc=0)	分布的标准差。
interval(confidence, a, loc=0)	中位数周围等面积的置信区间。

`scipy.stats.zipfian`

Original text：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.zipfian.html#scipy.stats.zipfian

scipy.stats.zipfian = <scipy.stats._discrete_distns.zipfian_gen object>

A Zipfian discrete random variable.

As an instance of the rv_discrete class, zipfian object inherits from it a collection of generic methods (see below for the full list), and completes them with details specific for this particular distribution.

rvs(a, n, loc=0, size=1, random_state=None)	随机变量。
pmf(k, a, n, loc=0)	概率质量函数。
logpmf(k, a, n, loc=0)	概率质量函数的对数。
cdf(k, a, n, loc=0)	累积分布函数。
logcdf(k, a, n, loc=0)	累积分布函数的对数。
sf(k, a, n, loc=0)	生存函数（也定义为 `1 - cdf`，但 sf 有时更精确）。
logsf(k, a, n, loc=0)	生存函数的对数。
ppf(q, a, n, loc=0)	百分位点函数（`cdf` 的反函数 — 百分位数）。
isf(q, a, n, loc=0)	逆生存函数（`sf` 的反函数）。
stats(a, n, loc=0, moments=’mv’)	均值（‘m’），方差（‘v’），偏度（‘s’），以及/或峰度（‘k’）。
entropy(a, n, loc=0)	随机变量的（微分）熵。
expect(func, args=(a, n), loc=0, lb=None, ub=None, conditional=False)	函数（一个参数）关于分布的期望值。
median(a, n, loc=0)	分布的中位数。
mean(a, n, loc=0)	分布的均值。
var(a, n, loc=0)	分布的方差。
std(a, n, loc=0)	分布的标准差。
interval(confidence, a, n, loc=0)	置信区间，围绕中位数具有相等的区域。

`scipy.stats.describe`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.describe.html#scipy.stats.describe

scipy.stats.describe(a, axis=0, ddof=1, bias=True, nan_policy='propagate')

计算传递数组的几个描述性统计。

参数：

a：类似于数组

输入数据。

轴：整数或 None，可选

计算统计量的轴。默认为 0。如果为 None，则在整个数组a上计算。

ddof：整数，可选

自由度增量（仅适用于方差）。默认为 1。

偏差：布尔值，可选

如果为 False，则对偏度和峰度的计算进行了统计偏差校正。

nan_policy：{‘propagate’，‘raise’，‘omit’}，可选

定义输入数据包含 NaN 时的处理方式。可用选项如下（默认为‘propagate’）：

‘propagate’：返回 nan
‘raise’：抛出一个错误
‘omit’：执行忽略 nan 值的计算

观测数：整数或整数 ndarray

观察次数（沿着axis的数据长度）。当选择 nan_policy 为‘omit’时，每个轴切片的长度会分别计算。

minmax：ndarray 或浮点数的元组

沿给定轴的a的最小值和最大值。

均值：ndarray 或浮点数

沿给定轴的算术平均值。

方差：ndarray 或浮点数

沿给定轴的无偏方差；分母为观测次数减去 1。

偏度：ndarray 或浮点数

a沿给定轴的偏度，基于具有与观察数相等的分母的矩计算，即没有自由度校正。

峰度：ndarray 或浮点数

a沿给定轴的峰度（费舍尔）。峰度被标准化为正态分布为零。未使用任何自由度。

另请参阅

偏度，峰度

示例

>>> import numpy as np
>>> from scipy import stats
>>> a = np.arange(10)
>>> stats.describe(a)
DescribeResult(nobs=10, minmax=(0, 9), mean=4.5,
 variance=9.166666666666666, skewness=0.0,
 kurtosis=-1.2242424242424244)
>>> b = [[1, 2], [3, 4]]
>>> stats.describe(b)
DescribeResult(nobs=2, minmax=(array([1, 2]), array([3, 4])),
 mean=array([2., 3.]), variance=array([2., 2.]),
 skewness=array([0., 0.]), kurtosis=array([-2., -2.]))

`scipy.stats.gmean`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.gmean.html#scipy.stats.gmean

scipy.stats.gmean(a, axis=0, dtype=None, weights=None, *, nan_policy='propagate', keepdims=False)

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

与权重数组相关联的数组(a_i)的加权几何平均值是：

[\exp \left( \frac{ \sum_{i=1}^n w_i \ln a_i }{ \sum_{i=1}^n w_i } \right) , ,]

并且，在权重相等的情况下，它给出：

[\sqrt[n]{ \prod_{i=1}^n a_i } , .]

参数：

aarray_like

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

axisint 或 None，默认值：0

如果是 int，则是计算统计量的输入轴。输入的每个轴切片（例如行）的统计量将显示在输出的相应元素中。如果为None，则在计算统计量之前将会拉平输入。

dtypedtype，可选

在执行计算之前将输入数组强制转换为的类型。

weightsarray_like，可选

weights数组必须与a的形状广播兼容。默认为 None，即每个值的权重为 1.0。

nan_policy{'propagate', 'omit', 'raise'}

定义如何处理输入的 NaN。

propagate: 如果在计算统计量的轴切片（例如行）中存在 NaN，则输出的相应条目将是 NaN。
omit: 在执行计算时将省略 NaN。如果在计算统计量的轴切片中剩余的数据不足，则输出的相应条目将为 NaN。
raise: 如果存在 NaN，则会引发ValueError。

keepdimsbool，默认值：False

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

gmeanndarray

请参见上面的dtype参数。

另请参见

numpy.mean

算术平均值

numpy.average

加权平均值

hmean

调和平均

注意

从 SciPy 1.9 开始，将np.matrix输入（不建议新代码使用）转换为np.ndarray后再执行计算。在这种情况下，输出将是适当形状的标量或np.ndarray，而不是 2D 的np.matrix。同样地，忽略掩码数组的屏蔽元素，输出将是标量或np.ndarray，而不是具有mask=False的掩码数组。

参考文献

[1]

“加权几何平均值”，维基百科，en.wikipedia.org/wiki/Weighted_geometric_mean。

[2]

Grossman, J., Grossman, M., Katz, R., “Averages: A New Approach”, Archimedes Foundation, 1983

示例

>>> from scipy.stats import gmean
>>> gmean([1, 4])
2.0
>>> gmean([1, 2, 3, 4, 5, 6, 7])
3.3800151591412964
>>> gmean([1, 4, 7], weights=[3, 1, 3])
2.80668351922014

`scipy.stats.hmean`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.hmean.html#scipy.stats.hmean

scipy.stats.hmean(a, axis=0, dtype=None, *, weights=None, nan_policy='propagate', keepdims=False)

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

与权重 w_i 关联的数组 a_i 的加权调和平均值为：

[\frac{ \sum_{i=1}^n w_i }{ \sum_{i=1}^n \frac{w_i}{a_i} } , ,]

并且，使用相同的权重，它给出：

[\frac{ n }{ \sum_{i=1}^n \frac{1}{a_i} } , .]

参数：

aarray_like

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

axisint 或 None，默认：0

如果是整数，则为计算统计量的输入轴。输入的每个轴切片（例如行）的统计量将显示在输出的相应元素中。如果为None，则在计算统计量之前将展平输入。

dtypedtype，可选

返回数组的类型，以及元素被求和的累加器的类型。如果未指定 dtype，则默认为 a 的 dtype，除非 a 具有小于默认平台整数的精度的整数 dtype。在这种情况下，将使用默认平台整数。

weightsarray_like，可选

权重数组可以是 1-D（在这种情况下，其长度必须与给定 axis 上的 a 的大小相同），也可以与 a 的形状相同。默认值为 None，这会使每个值的权重为 1.0。

自版本 1.9 开始。

nan_policy{‘propagate’, ‘omit’, ‘raise’}

定义如何处理输入的 NaN。

propagate：如果在计算统计量的轴切片（例如行）中存在 NaN，则输出的相应条目将为 NaN。
omit：在执行计算时，将省略 NaN。如果在计算统计量的轴切片中剩余的数据不足，则输出的相应条目将为 NaN。
raise：如果存在 NaN，则会引发 ValueError。

keepdimsbool，默认：False

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

hmeanndarray

参见上面的 dtype 参数。

另请参阅

numpy.mean

算术平均值

numpy.average

加权平均值

gmean

几何平均值

注意

默认情况下，调和平均值在输入数组的单个维度上计算，axis=0，或者如果 axis=None，则在数组的所有值上计算。对于整数输入，使用 float64 的中间和返回值。

从 SciPy 1.9 开始，np.matrix 输入（不建议在新代码中使用）在执行计算之前会转换为np.ndarray。在这种情况下，输出将是一个标量或适当形状的np.ndarray，而不是 2D 的np.matrix。类似地，虽然屏蔽数组的屏蔽元素被忽略，输出将是一个标量或np.ndarray，而不是带有mask=False的屏蔽数组。

参考资料

[1]

“加权调和平均数”，维基百科，en.wikipedia.org/wiki/Harmonic_mean#Weighted_harmonic_mean

[2]

Ferger, F., “调和平均数的性质和使用”，美国统计协会杂志，第 26 卷，第 36-40 页，1931 年

示例

>>> from scipy.stats import hmean
>>> hmean([1, 4])
1.6000000000000001
>>> hmean([1, 2, 3, 4, 5, 6, 7])
2.6997245179063363
>>> hmean([1, 4, 7], weights=[3, 1, 3])
1.9029126213592233

`scipy.stats.pmean`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.pmean.html#scipy.stats.pmean

scipy.stats.pmean(a, p, *, axis=0, dtype=None, weights=None, nan_policy='propagate', keepdims=False)

沿指定轴计算加权幂均值。

数组 (a_i) 的加权幂均值，相关权重为 (w_i)，定义如下：

[\left( \frac{ \sum_{i=1}^n w_i a_i^p }{ \sum_{i=1}^n w_i } \right)^{ 1 / p } , ,]

并且，使用相等的权重，它给出：

[\left( \frac{ 1 }{ n } \sum_{i=1}^n a_i^p \right)^{ 1 / p } , .]

当 p=0 时，返回几何均值。

这个均值也称为广义均值或 Hölder 均值，不应与 Kolmogorov 广义均值混淆，后者也称为拟算术均值或广义 f-均值 [3]。

参数：

a数组样式

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

p整数或浮点数

指数。

axis整数或 None，默认为 0

如果是整数，则是要计算统计量的输入轴（例如行）。输入的每个轴切片的统计量将出现在输出的相应元素中。如果为 None，则在计算统计量之前将展平输入。

dtypedtype，可选

返回数组的类型及累加器，其中元素被求和。若未指定 dtype，则默认为 a 的 dtype，除非 a 的整数 dtype 的精度低于默认平台整数。这种情况下，将使用默认平台整数。

weights数组样式，可选

权重数组可以是 1-D 的（其长度必须是给定 axis 上 a 的大小），或者与 a 的形状相同。默认为 None，即每个值的权重为 1.0。

nan_policy{‘propagate’, ‘omit’, ‘raise’}

定义如何处理输入的 NaN。

propagate：如果计算统计量时轴切片（例如行）中存在 NaN，则输出的相应条目将为 NaN。
omit：在执行计算时将省略 NaN。如果沿着计算统计量的轴切片中的数据不足，则输出的相应条目将为 NaN。
raise: 如果存在 NaN，将引发 ValueError。

keepdims布尔值，默认为 False

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

返回值：

pmeanndarray，参见上述 dtype 参数。

输出数组，包含幂均值数值。

参见

numpy.average

加权平均

gmean

几何均值

hmean

调和均值

注意

幂均值是在输入数组的单个维度上计算的，默认为 axis=0，或者如果 axis=None，则在数组的所有值上计算。对于整数输入，使用 float64 类型的中间值和返回值。

1.9 版本中的新功能。

从 SciPy 1.9 开始，np.matrix 输入（不推荐新代码使用）在执行计算之前将转换为 np.ndarray。在这种情况下，输出将是适当形状的标量或 np.ndarray，而不是二维的 np.matrix。类似地，尽管掩码数组的掩码元素被忽略，输出将是标量或 np.ndarray，而不是带有 mask=False 的掩码数组。

参考文献

[1]

“广义均值”，维基百科，en.wikipedia.org/wiki/Generalized_mean

[2]

Norris, N., “广义均值函数的凸性质”，《数理统计学年刊》，第 8 卷，pp. 118-120，1937 年

[3]

Bullen, P.S., 《均值与它们的不等式手册》，2003 年

示例

>>> from scipy.stats import pmean, hmean, gmean
>>> pmean([1, 4], 1.3)
2.639372938300652
>>> pmean([1, 2, 3, 4, 5, 6, 7], 1.3)
4.157111214492084
>>> pmean([1, 4, 7], -2, weights=[3, 1, 3])
1.4969684896631954

当 p=-1 时，幂均值等于调和平均数：

>>> pmean([1, 4, 7], -1, weights=[3, 1, 3])
1.9029126213592233
>>> hmean([1, 4, 7], weights=[3, 1, 3])
1.9029126213592233

当 p=0 时，幂均值定义为几何平均数：

>>> pmean([1, 4, 7], 0, weights=[3, 1, 3])
2.80668351922014
>>> gmean([1, 4, 7], weights=[3, 1, 3])
2.80668351922014

`scipy.stats.kurtosis`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.kurtosis.html#scipy.stats.kurtosis

scipy.stats.kurtosis(a, axis=0, fisher=True, bias=True, nan_policy='propagate', *, keepdims=False)

计算数据集的峰度（Fisher 或 Pearson）。

峰度是四阶中心矩除以方差的平方。如果使用 Fisher 的定义，则从结果中减去 3.0，使正态分布的结果为 0.0。

如果偏差为 False，则使用 k 统计量计算峰度以消除来自有偏矩估计器的偏差。

使用 kurtosistest 查看结果是否接近正态分布。

参数：

a 数组

计算峰度的数据。

axis int 或 None，默认为 0

如果是整数，则为计算统计量的输入轴。输入的每个轴切片（例如行）的统计量将出现在输出的相应元素中。如果为 None，则在计算统计量之前会将输入展平。

fisher bool，可选

如果为 True，则使用 Fisher 的定义（正态 ==> 0.0）。如果为 False，则使用 Pearson 的定义（正态 ==> 3.0）。

bias bool，可选

如果为 False，则对统计偏差进行校正。

nan_policy {'propagate', 'omit', 'raise'}

定义如何处理输入的 NaN。

propagate：如果在计算统计量的轴切片（例如行）中存在 NaN，则输出的相应条目将为 NaN。
omit：在执行计算时将省略 NaN。如果在计算统计量的轴切片中剩余的数据不足，则输出的相应条目将为 NaN。
raise：如果存在 NaN，则会引发 ValueError。

keepdims bool，默认为 False

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

kurtosis 数组

沿轴计算值的峰度，当所有值相等时返回 NaN。

注意

自 SciPy 1.9 开始，np.matrix 输入（不建议新代码使用）在执行计算之前会转换为 np.ndarray。在这种情况下，输出将是适当形状的标量或 np.ndarray，而不是 2D 的 np.matrix。类似地，虽然忽略了掩码数组的掩码元素，但输出将是标量或 np.ndarray，而不是带有 mask=False 的掩码数组。

参考资料

[1]

Zwillinger 和 Kokoska（2000）。《CRC 标准概率和统计表格与公式》。Chapman & Hall：纽约。2000 年。

示例

在 Fisher 的定义中，正态分布的峰度为零。在下面的示例中，峰度接近零，因为它是从数据集而不是连续分布计算得出的。

>>> import numpy as np
>>> from scipy.stats import norm, kurtosis
>>> data = norm.rvs(size=1000, random_state=3)
>>> kurtosis(data)
-0.06928694200380558

具有较高峰度的分布尾部更重。在费舍尔的定义中，正态分布的峰度值为零，可以作为一个参考点。

>>> import matplotlib.pyplot as plt
>>> import scipy.stats as stats
>>> from scipy.stats import kurtosis

>>> x = np.linspace(-5, 5, 100)
>>> ax = plt.subplot()
>>> distnames = ['laplace', 'norm', 'uniform']

>>> for distname in distnames:
...     if distname == 'uniform':
...         dist = getattr(stats, distname)(loc=-2, scale=4)
...     else:
...         dist = getattr(stats, distname)
...     data = dist.rvs(size=1000)
...     kur = kurtosis(data, fisher=True)
...     y = dist.pdf(x)
...     ax.plot(x, y, label="{}, {}".format(distname, round(kur, 3)))
...     ax.legend()

拉普拉斯分布的尾部比正态分布更重。均匀分布（具有负峰度）的尾部最细。

../../_images/scipy-stats-kurtosis-1.png

`scipy.stats.mode`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.mode.html#scipy.stats.mode

scipy.stats.mode(a, axis=0, nan_policy='propagate', keepdims=False)

返回传递数组中众数（最常见）值的数组。

如果存在多个这样的值，则仅返回一个。还返回众数箱的计数。

参数：

aarray_like

要查找模式的数字，n 维数组。

axisint 或 None，默认为 0

如果是 int，则是计算输入的轴。输入的每个轴切片（例如行）的统计量将显示在输出的相应元素中。如果为None，则在计算统计量之前将被拉直。

nan_policy{‘propagate’, ‘omit’, ‘raise’}

定义如何处理输入 NaN 值。

propagate: 如果在计算统计量的轴片段（例如行）中存在 NaN，则输出的相应条目将为 NaN。
omit: 在执行计算时将省略 NaN。如果在计算统计量的轴片段中剩余的数据不足，则输出的相应条目将为 NaN。
raise: 如果存在 NaN，则会引发ValueError。

keepdimsbool，默认为 False

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

modendarray

众数值数组。

countndarray

每个模式的计数数组。

注释

使用numpy.unique计算众数。在 NumPy 版本 1.21 及之后的版本中，即使具有不同二进制表示的所有 NaN 也被视为等效，并计为同一值的不同实例。

根据惯例，空数组的众数为 NaN，相关计数为零。

从 SciPy 1.9 开始，np.matrix输入（不建议新代码使用）在执行计算之前将被转换为np.ndarray。在这种情况下，输出将是适当形状的标量或np.ndarray，而不是 2D 的np.matrix。同样，尽管被屏蔽数组的屏蔽元素被忽略，输出将是标量或np.ndarray，而不是具有mask=False的屏蔽数组。

示例

>>> import numpy as np
>>> a = np.array([[3, 0, 3, 7],
...               [3, 2, 6, 2],
...               [1, 7, 2, 8],
...               [3, 0, 6, 1],
...               [3, 2, 5, 5]])
>>> from scipy import stats
>>> stats.mode(a, keepdims=True)
ModeResult(mode=array([[3, 0, 6, 1]]), count=array([[4, 2, 2, 1]]))

要获取整个数组的模式，请指定axis=None：

>>> stats.mode(a, axis=None, keepdims=True)
ModeResult(mode=[[3]], count=[[5]])
>>> stats.mode(a, axis=None, keepdims=False)
ModeResult(mode=3, count=5)

`scipy.stats.moment`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.moment.html#scipy.stats.moment

scipy.stats.moment(a, moment=1, axis=0, nan_policy='propagate', *, center=None, keepdims=False)

计算样本的平均值关于均值的第 n 阶矩。

矩是一组点形状的特定定量测量。由于其与偏度和峰度的密切关系，通常用于计算偏度和峰度系数。

参数：

aarray_like

输入数组。

momentint 或 int 的 array_like，可选

返回的中心矩的顺序。默认为 1。

轴int 或 None，默认：0

如果是 int，则是计算统计量的输入轴。输入的每个轴切片（例如行）的统计量将显示在输出的相应元素中。如果为None，则在计算统计量之前将拉平输入。

nan_policy{‘propagate’, ‘omit’, ‘raise’}

定义如何处理输入的 NaN。

propagate：如果在计算统计量的轴切片（例如行）中存在 NaN，则输出的相应条目将为 NaN。
omit：在执行计算时将忽略 NaN。如果沿着计算统计量的轴切片中数据不足，则输出的相应条目将为 NaN。
raise：如果存在 NaN，则会引发ValueError。

中心float 或 None，可选

用于计算矩的点。这可以是样本均值、原点或任何其他点。如果None（默认），则计算中心作为样本均值。

keepdimsbool，默认：False

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

关于center的第 n 阶矩ndarray 或 float

沿给定轴或如果 axis 为 None 则所有值的适当矩。矩计算的分母是观察数，不进行自由度校正。

另请参见

kurtosis, skew, describe

注

数据样本的第 k 阶矩：

[m_k = \frac{1}{n} \sum_{i = 1}^n (x_i - c)^k]

其中n是样本数，c是计算矩的中心。此函数使用平方的指数计算[1]以提高效率。

请注意，如果a是一个空数组（a.size == 0），则具有一个元素的数组moment（moment.size == 1）将与标量moment（np.isscalar(moment)）处理方式相同。这可能会产生意外形状的数组。

自 SciPy 1.9 开始，np.matrix 输入（不建议新代码使用）在执行计算之前会被转换为 np.ndarray。在这种情况下，输出将是适当形状的标量或者 np.ndarray，而不是一个 2D 的 np.matrix。同样，当忽略掩码数组的掩码元素时，输出将是一个标量或者 np.ndarray，而不是带有 mask=False 的掩码数组。

参考文献

[1]

eli.thegreenplace.net/2009/03/21/efficient-integer-exponentiation-algorithms

示例

>>> from scipy.stats import moment
>>> moment([1, 2, 3, 4, 5], moment=1)
0.0
>>> moment([1, 2, 3, 4, 5], moment=2)
2.0

`scipy.stats.expectile`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.expectile.html#scipy.stats.expectile

scipy.stats.expectile(a, alpha=0.5, *, weights=None)

计算指定水平的期望分位数。

期望分位数在相同方式上是期望的泛化，如分位数是中位数的泛化。水平 alpha = 0.5 处的期望分位数是均值（平均值）。更多细节请参阅注释。

参数：

aarray_like

包含期望分位数的数字的数组。

alphafloat，默认值：0.5

分位数的水平；例如，alpha=0.5 给出了平均值。

weightsarray_like，可选

与 a 中的值相关联的权重数组。 weights 必须与 a 的形状可广播。默认值为 None，即每个值的权重为 1.0。整数值的权重元素的作用类似于重复相应观察中的 a 那么多次。有关更多详细信息，请参阅注释。

返回值：

expectilendarray

样本的经验分位数在水平 alpha 处。

另请参阅

numpy.mean

算术平均值

numpy.quantile

分位数

注释

通常情况下，具有累积分布函数（CDF）(F) 的随机变量 (X) 的水平 (\alpha) 处的分位数由以下方程的唯一解 (t) 给出：

[\alpha E((X - t)+) = (1 - \alpha) E((t - X)+) ,.]

这里，((x)_+ = \max(0, x)) 是 (x) 的正部分。这个方程也可以等价地写作：

[\alpha \int_t^\infty (x - t)\mathrm{d}F(x) = (1 - \alpha) \int_{-\infty}^t (t - x)\mathrm{d}F(x) ,.]

样本 (a_i)（数组 a）的经验分位数在水平 (\alpha) 处（alpha（数组 weights），它读作 (F_a(x) = \frac{1}{\sum_i w_i} \sum_i w_i 1_{a_i \leq x})，其中指示函数 (1_{A})。这导致了在水平 alpha 处的经验分位数的定义，作为以下方程的唯一解 (t)：

[\alpha \sum_{i=1}^n w_i (a_i - t)+ = (1 - \alpha) \sum{i=1}^n w_i (t - a_i)_+ ,.]

对于 (\alpha=0.5)，这简化为加权平均。此外，(\alpha) 越大，分位数的值越大。

最后，水平 (\alpha) 处的期望分位数也可以写成一个最小化问题。通常使用的选择是

[\operatorname{argmin}t E(\lvert 1{t\geq X} - \alpha\rvert(t - X)²) ,.]

参考文献

[1]

W. K. Newey 和 J. L. Powell（1987 年），“非对称最小二乘估计和检验”，《计量经济学》, 55, 819-847。

[2]

T. Gneiting (2009). “Making and Evaluating Point Forecasts,” 美国统计协会杂志, 106, 746 - 762. DOI:10.48550/arXiv.0912.0902

Examples

>>> import numpy as np
>>> from scipy.stats import expectile
>>> a = [1, 4, 2, -1]
>>> expectile(a, alpha=0.5) == np.mean(a)
True
>>> expectile(a, alpha=0.2)
0.42857142857142855
>>> expectile(a, alpha=0.8)
2.5714285714285716
>>> weights = [1, 3, 1, 1]

SciPy-1-12-中文文档-五十九-

SciPy 1.12 中文文档（五十九）

scipy.stats.nbinom

scipy.stats.nchypergeom_fisher

scipy.stats.nchypergeom_wallenius

scipy.stats.nhypergeom

scipy.stats.planck

scipy.stats.poisson

scipy.stats.randint

scipy.stats.skellam

scipy.stats.yulesimon

scipy.stats.zipf

scipy.stats.zipfian

scipy.stats.describe

scipy.stats.gmean

scipy.stats.hmean

scipy.stats.pmean

scipy.stats.kurtosis

scipy.stats.mode

scipy.stats.moment

scipy.stats.expectile

`scipy.stats.nbinom`

`scipy.stats.nchypergeom_fisher`

`scipy.stats.nchypergeom_wallenius`

`scipy.stats.nhypergeom`

`scipy.stats.planck`

`scipy.stats.poisson`

`scipy.stats.randint`

`scipy.stats.skellam`

`scipy.stats.yulesimon`

`scipy.stats.zipf`

`scipy.stats.zipfian`

`scipy.stats.describe`

`scipy.stats.gmean`

`scipy.stats.hmean`

`scipy.stats.pmean`

`scipy.stats.kurtosis`

`scipy.stats.mode`

`scipy.stats.moment`

`scipy.stats.expectile`