SciPy-1-12-中文文档-二十一-

SciPy 1.12 中文文档（二十一）

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

scipy.special.diric

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.diric.html#scipy.special.diric

scipy.special.diric(x, n)

周期性 sinc 函数，也称为 Dirichlet 函数。

Dirichlet 函数的定义如下：

diric(x, n) = sin(x * n/2) / (n * sin(x / 2)), 

其中 n 是一个正整数。

参数：

xarray_like

输入数据

nint

定义周期性的整数。

返回：

diricndarray

示例

>>> import numpy as np
>>> from scipy import special
>>> import matplotlib.pyplot as plt 

>>> x = np.linspace(-8*np.pi, 8*np.pi, num=201)
>>> plt.figure(figsize=(8, 8));
>>> for idx, n in enumerate([2, 3, 4, 9]):
...     plt.subplot(2, 2, idx+1)
...     plt.plot(x, special.diric(x, n))
...     plt.title('diric, n={}'.format(n))
>>> plt.show() 

以下示例演示了 diric 给出矩形脉冲的傅里叶系数的幅度（模去符号和缩放）。

抑制那些实际上为 0 的值的输出：

>>> np.set_printoptions(suppress=True) 

使用 k 个 1 创建长度为 m 的信号 x：

>>> m = 8
>>> k = 3
>>> x = np.zeros(m)
>>> x[:k] = 1 

使用 FFT 计算 x 的傅里叶变换，并检查系数的幅度：

>>> np.abs(np.fft.fft(x))
array([ 3\.        ,  2.41421356,  1\.        ,  0.41421356,  1\.        ,
 0.41421356,  1\.        ,  2.41421356]) 

现在使用 diric 找到相同的值（符号上相同）。我们乘以 k 来考虑 numpy.fft.fft 和 diric 不同的缩放惯例：

>>> theta = np.linspace(0, 2*np.pi, m, endpoint=False)
>>> k * special.diric(theta, k)
array([ 3\.        ,  2.41421356,  1\.        , -0.41421356, -1\.        ,
 -0.41421356,  1\.        ,  2.41421356]) 

scipy.special.euler

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.euler.html#scipy.special.euler

scipy.special.euler(n)

欧拉数 E(0), E(1), …, E(n)。

欧拉数 [1] 也被称为割线数。

因为 euler(n) 返回浮点数值，对于大的 n 并不给出精确值。第一个不精确值是 E(22)。

参数：

n 整数

返回应返回的欧拉数的最高索引。

返回：

ndarray

欧拉数 [E(0), E(1), …, E(n)]。包括所有为零的奇数欧拉数。

参考文献

[1]

序列 A122045, 整数序列在线百科全书, oeis.org/A122045

[2]

张, 善杰 和 金, 建明. “特殊函数的计算”, John Wiley and Sons, 1996. people.sc.fsu.edu/~jburkardt/f77_src/special_functions/special_functions.html

示例

>>> import numpy as np
>>> from scipy.special import euler
>>> euler(6)
array([  1.,   0.,  -1.,   0.,   5.,   0., -61.]) 

>>> euler(13).astype(np.int64)
array([      1,       0,      -1,       0,       5,       0,     -61,
 0,    1385,       0,  -50521,       0, 2702765,       0]) 

>>> euler(22)[-1]  # Exact value of E(22) is -69348874393137901.
-69348874393137976.0 

scipy.special.expn

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

scipy.special.expn(n, x, out=None) = <ufunc 'expn'>

广义指数积分 En。

对于整数 (n \geq 0) 和实数 (x \geq 0)，广义指数积分被定义为 [dlmf]

[E_n(x) = x^{n - 1} \int_x^\infty \frac{e^{-t}}{tn} dt.]

参数：

n 数组类型

非负整数

x 数组类型

实数参数

out ndarray，可选

函数结果的可选输出数组

返回：

标量或者 ndarray

广义指数积分的值

另请参见

exp1

当 (n = 1) 时的特例 (E_n)。

expi

当 (n = 1) 时与 (E_n) 相关。

参考资料

[dlmf]

数学函数数字图书馆，8.19.2 dlmf.nist.gov/8.19#E2

示例

>>> import numpy as np
>>> import scipy.special as sc 

其定义域是非负的 n 和 x。

>>> sc.expn(-1, 1.0), sc.expn(1, -1.0)
(nan, nan) 

当 (n = 1, 2) 时，在 x = 0 处有极点；对于更大的 (n)，它等于 1 / (n - 1)。

>>> sc.expn([0, 1, 2, 3, 4], 0)
array([       inf,        inf, 1\.        , 0.5       , 0.33333333]) 

当 (n = 0) 时简化为 exp(-x) / x。

>>> x = np.array([1, 2, 3, 4])
>>> sc.expn(0, x)
array([0.36787944, 0.06766764, 0.01659569, 0.00457891])
>>> np.exp(-x) / x
array([0.36787944, 0.06766764, 0.01659569, 0.00457891]) 

当 (n = 1) 时简化为 exp1。

>>> sc.expn(1, x)
array([0.21938393, 0.04890051, 0.01304838, 0.00377935])
>>> sc.exp1(x)
array([0.21938393, 0.04890051, 0.01304838, 0.00377935]) 

scipy.special.exp1

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.exp1.html#scipy.special.exp1

scipy.special.exp1(z, out=None) = <ufunc 'exp1'>

指数积分 E1。

对于复数 (z \ne 0)，指数积分可以定义为 [1]

[E_1(z) = \int_z^\infty \frac{e^{-t}}{t} dt,]

其路径不穿过负实轴或通过原点。

参数：

z：array_like

实数或复数参数。

outndarray，可选

函数结果的可选输出数组

返回：

标量或 ndarray

指数积分 (E1) 的值

参见

expi

指数积分 (Ei)

expn

(E_1)的泛化

注意

对于 (x > 0)，它与指数积分 (Ei) 相关（参见 expi）。

[E_1(x) = -Ei(-x).]

参考文献

[1]

数字数学函数库，6.2.1 dlmf.nist.gov/6.2#E1

例子

>>> import numpy as np
>>> import scipy.special as sc 

在 0 处有极点。

>>> sc.exp1(0)
inf 

它在负实轴上有一个分支切口。

>>> sc.exp1(-1)
nan
>>> sc.exp1(complex(-1, 0))
(-1.8951178163559368-3.141592653589793j)
>>> sc.exp1(complex(-1, -0.0))
(-1.8951178163559368+3.141592653589793j) 

它沿着正实轴逼近 0。

>>> sc.exp1([1, 10, 100, 1000])
array([2.19383934e-01, 4.15696893e-06, 3.68359776e-46, 0.00000000e+00]) 

它与 expi 有关。

>>> x = np.array([1, 2, 3, 4])
>>> sc.exp1(x)
array([0.21938393, 0.04890051, 0.01304838, 0.00377935])
>>> -sc.expi(-x)
array([0.21938393, 0.04890051, 0.01304838, 0.00377935]) 

scipy.special.expi

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

scipy.special.expi(x, out=None) = <ufunc 'expi'>

指数积分 Ei。

对于实数(x)，指数积分定义为[1]

[Ei(x) = \int_{-\infty}^x \frac{e^t}{t} dt.]

对于(x > 0)，积分理解为柯西主值。

它通过在区间((0, \infty))上的函数的解析延拓来扩展到复平面。复数变体在负实轴上有一个分支切割。

参数：

x数组样式

实数或复数值参数

outndarray，可选

函数结果的可选输出数组

返回：

标量或 ndarray

指数积分的值

另见

exp1

指数积分(E_1)

expn

广义指数积分(E_n)

注

指数积分(E_1)和(Ei)满足关系

[E_1(x) = -Ei(-x)]

对于(x > 0)。

参考资料

[1]

数字数学函数库，6.2.5 dlmf.nist.gov/6.2#E5

示例

>>> import numpy as np
>>> import scipy.special as sc 

它与exp1有关。

>>> x = np.array([1, 2, 3, 4])
>>> -sc.expi(-x)
array([0.21938393, 0.04890051, 0.01304838, 0.00377935])
>>> sc.exp1(x)
array([0.21938393, 0.04890051, 0.01304838, 0.00377935]) 

复数变体在负实轴上有一个分支切割。

>>> sc.expi(-1 + 1e-12j)
(-0.21938393439552062+3.1415926535894254j)
>>> sc.expi(-1 - 1e-12j)
(-0.21938393439552062-3.1415926535894254j) 

当复数变体接近分支切割时，实部接近实变体的值。

>>> sc.expi(-1)
-0.21938393439552062 

SciPy 实现在分支切割处返回复值的实变体。

>>> sc.expi(complex(-1, 0.0))
(-0.21938393439552062-0j)
>>> sc.expi(complex(-1, -0.0))
(-0.21938393439552062-0j) 

scipy.special.factorial

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.factorial.html#scipy.special.factorial

scipy.special.factorial(n, exact=False)

数字或数字数组的阶乘。

非负整数n的阶乘是小于或等于n的所有正整数的乘积：

n! = n * (n - 1) * (n - 2) * ... * 1 

参数：

n整数或整数数组

输入值。如果n < 0，则返回值为 0。

exact布尔型，可选

若为 True，则使用长整数算术精确计算答案。若为 False，则使用快速浮点数逼近方法使用gamma函数。默认为 False。

返回：

nf浮点数或整数或数组

n的阶乘，根据exact返回整数或浮点数。

注意事项

对于exact=True的数组，阶乘仅计算一次，对于最大的输入，每个其他结果在过程中计算。如果需要，输出数据类型增加到int64或object。

若exact=False，使用 gamma 函数逼近阶乘：

[n! = \Gamma(n+1)]

示例

>>> import numpy as np
>>> from scipy.special import factorial
>>> arr = np.array([3, 4, 5])
>>> factorial(arr, exact=False)
array([   6.,   24.,  120.])
>>> factorial(arr, exact=True)
array([  6,  24, 120])
>>> factorial(5, exact=True)
120 

scipy.special.factorial2

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.factorial2.html#scipy.special.factorial2

scipy.special.factorial2(n, exact=False)

双阶乘。

这是阶乘，每隔一个值跳过。例如，7!! = 7 * 5 * 3 * 1。可以数值上近似为：

n!! = 2 ** (n / 2) * gamma(n / 2 + 1) * sqrt(2 / pi)  n odd
    = 2 ** (n / 2) * gamma(n / 2 + 1)                 n even
    = 2 ** (n / 2) * (n / 2)!                         n even 

参数：

nint 或 array_like

计算 n!!。如果 n < 0，返回值为 0。

exactbool，可选

结果可以使用上述伽马公式快速近似计算（默认）。如果设置 exact 为 True，则使用整数算术精确计算答案。

返回：

nfffloat 或 int

n 的双阶乘，作为 int 或 float，具体取决于 exact。

示例

>>> from scipy.special import factorial2
>>> factorial2(7, exact=False)
array(105.00000000000001)
>>> factorial2(7, exact=True)
105 

scipy.special.factorialk

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

scipy.special.factorialk(n, k, exact=True)

n 的 k 阶多阶乘，n(!!…!)。

这是跳过 k 值的 n 的多阶乘。例如，

factorialk(17, 4) = 17!!!! = 17 * 13 * 9 * 5 * 1

特别地，对于任何整数 n，我们有

factorialk(n, 1) = factorial(n)

factorialk(n, 2) = factorial2(n)

参数：

nint 或 array_like

计算多阶乘。如果 n < 0，则返回值为 0。

kint

多阶乘的顺序。

exactbool，可选

如果 exact 设置为 True，则使用整数算术精确计算答案。

返回：

valint

n 的多阶乘。

引发异常：

未实现错误

当 exact 为 False 时引发异常

示例

>>> from scipy.special import factorialk
>>> factorialk(5, 1, exact=True)
120
>>> factorialk(5, 3, exact=True)
10 

scipy.special.shichi

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

scipy.special.shichi(x, out=None) = <ufunc 'shichi'>

双曲正弦和余弦积分。

双曲正弦积分为

[\int_0^x \frac{\sinh{t}}{t}dt]

双曲余弦积分为

[\gamma + \log(x) + \int_0^x \frac{\cosh{t} - 1}{t} dt]

其中(\gamma)是欧拉常数，(\log)是对数的主分支[1]。

参数：

x数组样式

计算双曲正弦和余弦积分的实数或复数点。

outndarray 的元组，可选

可选输出数组用于函数结果

返回：

si标量或 ndarray

x的双曲正弦积分

ci标量或 ndarray

x的双曲余弦积分

参见

sici

正弦和余弦积分。

exp1

指数积分 E1。

expi

指数积分 Ei。

注意

对于实数参数x < 0，chi是双曲余弦积分的实部。对于这样的点，chi(x)和chi(x + 0j)相差一个因子1j*pi。

对于实数参数，通过调用 Cephes 的[2]shichi例程计算函数。对于复数参数，该算法基于 Mpmath 的[3]shi和chi例程。

参考资料

[1]

Milton Abramowitz 和 Irene A. Stegun，编辑。《数学函数手册：公式、图形和数学表》。纽约：多佛尔，1972 年。（见第 5.2 节。）

[2]

Cephes 数学函数库，www.netlib.org/cephes/

[3]

Fredrik Johansson 及其它人。“mpmath: 一个用于任意精度浮点数算术的 Python 库”（版本 0.19）mpmath.org/

示例

>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> from scipy.special import shichi, sici 

shichi 接受实数或复数输入：

>>> shichi(0.5)
(0.5069967498196671, -0.05277684495649357)
>>> shichi(0.5 + 2.5j)
((0.11772029666668238+1.831091777729851j),
 (0.29912435887648825+1.7395351121166562j)) 

双曲正弦和余弦积分 Shi(z)和 Chi(z)与正弦和余弦积分 Si(z)和 Ci(z)相关

• Shi(z) = -iSi(iz)

• Chi(z) = Ci(-iz) + ipi/2

>>> z = 0.25 + 5j
>>> shi, chi = shichi(z)
>>> shi, -1j*sici(1j*z)[0]            # Should be the same.
((-0.04834719325101729+1.5469354086921228j),
 (-0.04834719325101729+1.5469354086921228j))
>>> chi, sici(-1j*z)[1] + 1j*np.pi/2  # Should be the same.
((-0.19568708973868087+1.556276312103824j),
 (-0.19568708973868087+1.556276312103824j)) 

绘制在实轴上评估的函数：

>>> xp = np.geomspace(1e-8, 4.0, 250)
>>> x = np.concatenate((-xp[::-1], xp))
>>> shi, chi = shichi(x) 

>>> fig, ax = plt.subplots()
>>> ax.plot(x, shi, label='Shi(x)')
>>> ax.plot(x, chi, '--', label='Chi(x)')
>>> ax.set_xlabel('x')
>>> ax.set_title('Hyperbolic Sine and Cosine Integrals')
>>> ax.legend(shadow=True, framealpha=1, loc='lower right')
>>> ax.grid(True)
>>> plt.show() 

scipy.special.sici

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

scipy.special.sici(x, out=None) = <ufunc 'sici'>

正弦和余弦积分。

正弦积分是

[\int_0^x \frac{\sin{t}}{t}dt]

而余弦积分为

[\gamma + \log(x) + \int_0^x \frac{\cos{t} - 1}{t}dt]

其中 (\gamma) 是欧拉常数，(\log) 是对数的主分支 [1]。

参数：

xarray_like

计算正弦和余弦积分的实数或复数点。

out的 ndarray 元组，可选

可选的输出数组用于函数结果

返回：

si标量或 ndarray

正弦积分在 x

ci标量或 ndarray

x 处的余弦积分

另请参阅

shichi

双曲正弦和余弦积分。

exp1

指数积分 E1。

expi

指数积分 Ei。

注意

对于实数参数，当 x < 0 时，ci 是余弦积分的实部。对于这样的点，ci(x) 和 ci(x + 0j) 相差一个因子 1j*pi。

对于实数参数，通过调用 Cephes 的 [2] sici 程序计算。对于复数参数，算法基于 Mpmath 的 [3] si 和 ci 程序。

参考文献

[1] (1,2)

Milton Abramowitz 和 Irene A. Stegun 编，Handbook of Mathematical Functions with Formulas, Graphs, and Mathematical Tables。New York: Dover, 1972.（参见第 5.2 节。）

[2]

Cephes 数学函数库，www.netlib.org/cephes/

[3]

Fredrik Johansson 和其他人，“mpmath: a Python library for arbitrary-precision floating-point arithmetic”（版本 0.19）mpmath.org/

示例

>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> from scipy.special import sici, exp1 

sici 接受实数或复数输入：

>>> sici(2.5)
(1.7785201734438267, 0.2858711963653835)
>>> sici(2.5 + 3j)
((4.505735874563953+0.06863305018999577j),
(0.0793644206906966-2.935510262937543j)) 

对于右半平面的 z，正弦和余弦积分与指数积分 E1（在 SciPy 中实现为 scipy.special.exp1）相关

• Si(z) = (E1(iz) - E1(-iz))/2i + pi/2

• Ci(z) = -(E1(iz) + E1(-iz))/2

见 [1]（方程 5.2.21 和 5.2.23）。

我们可以验证以下关系：

>>> z = 2 - 3j
>>> sici(z)
((4.54751388956229-1.3991965806460565j),
(1.408292501520851+2.9836177420296055j)) 

>>> (exp1(1j*z) - exp1(-1j*z))/2j + np.pi/2  # Same as sine integral
(4.54751388956229-1.3991965806460565j) 

>>> -(exp1(1j*z) + exp1(-1j*z))/2            # Same as cosine integral
(1.408292501520851+2.9836177420296055j) 

绘制在实轴上评估的函数；虚线水平线在 pi/2 和 -pi/2 处：

>>> x = np.linspace(-16, 16, 150)
>>> si, ci = sici(x) 

>>> fig, ax = plt.subplots()
>>> ax.plot(x, si, label='Si(x)')
>>> ax.plot(x, ci, '--', label='Ci(x)')
>>> ax.legend(shadow=True, framealpha=1, loc='upper left')
>>> ax.set_xlabel('x')
>>> ax.set_title('Sine and Cosine Integrals')
>>> ax.axhline(np.pi/2, linestyle=':', alpha=0.5, color='k')
>>> ax.axhline(-np.pi/2, linestyle=':', alpha=0.5, color='k')
>>> ax.grid(True)
>>> plt.show() 

scipy.special.softmax

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

scipy.special.softmax(x, axis=None)

计算 softmax 函数。

softmax 函数通过计算每个元素的指数除以所有元素的指数之和来转换集合的每个元素。 也就是说，如果 x 是一维 numpy 数组：

softmax(x) = np.exp(x)/sum(np.exp(x)) 

参数：

xarray_like

输入数组。

轴int 或 int 元组，可选

计算值的轴。 默认为 None，softmax 将在整个数组 x 上计算。

返回：

sndarray

与 x 相同形状的数组。 结果将沿指定轴总和为 1。

注意事项

对于向量 ( x = {x_0, x_1, ..., x_{n-1}} )，softmax 函数 (\sigma(x)) 的公式为：

[\sigma(x)_j = \frac{e^{x_j}}{\sum_k e^{x_k}}]

softmax 函数是 logsumexp 的梯度。

该实现使用移位来避免溢出。 更多详细信息见 [1]。

新版本 1.2.0 中引入。

参考文献

[1]

P. Blanchard, D.J. Higham, N.J. Higham, “精确计算 log-sum-exp 和 softmax 函数”, IMA 数值分析杂志, Vol.41(4), DOI:10.1093/imanum/draa038.

示例

>>> import numpy as np
>>> from scipy.special import softmax
>>> np.set_printoptions(precision=5) 

>>> x = np.array([[1, 0.5, 0.2, 3],
...               [1,  -1,   7, 3],
...               [2,  12,  13, 3]])
... 

在整个数组上计算 softmax 转换。

>>> m = softmax(x)
>>> m
array([[  4.48309e-06,   2.71913e-06,   2.01438e-06,   3.31258e-05],
 [  4.48309e-06,   6.06720e-07,   1.80861e-03,   3.31258e-05],
 [  1.21863e-05,   2.68421e-01,   7.29644e-01,   3.31258e-05]]) 

>>> m.sum()
1.0 

沿第一轴（即列）计算 softmax 转换。

>>> m = softmax(x, axis=0) 

>>> m
array([[  2.11942e-01,   1.01300e-05,   2.75394e-06,   3.33333e-01],
 [  2.11942e-01,   2.26030e-06,   2.47262e-03,   3.33333e-01],
 [  5.76117e-01,   9.99988e-01,   9.97525e-01,   3.33333e-01]]) 

>>> m.sum(axis=0)
array([ 1.,  1.,  1.,  1.]) 

沿第二轴（即行）计算 softmax 转换。

>>> m = softmax(x, axis=1)
>>> m
array([[  1.05877e-01,   6.42177e-02,   4.75736e-02,   7.82332e-01],
 [  2.42746e-03,   3.28521e-04,   9.79307e-01,   1.79366e-02],
 [  1.22094e-05,   2.68929e-01,   7.31025e-01,   3.31885e-05]]) 

>>> m.sum(axis=1)
array([ 1.,  1.,  1.]) 

scipy.special.log_softmax

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

scipy.special.log_softmax(x, axis=None)

计算 softmax 函数的对数。

原则上：

log_softmax(x) = log(softmax(x)) 

但使用更精确的实现。

参数：

x 类似数组

输入数组。

axis 整数或整数元组，可选

计算值的轴。默认为 None，softmax 将在整个数组 x 上计算。

返回：

s 数组或标量

与 x 具有相同形状的数组。结果的指数将沿指定轴总和为 1。如果 x 是标量，则返回标量。

注意事项

log_softmax 比使用使 softmax 饱和的输入更精确的 np.log(softmax(x)) 更准确（见下面的示例）。

新版本为 1.5.0。

示例

>>> import numpy as np
>>> from scipy.special import log_softmax
>>> from scipy.special import softmax
>>> np.set_printoptions(precision=5) 

>>> x = np.array([1000.0, 1.0]) 

>>> y = log_softmax(x)
>>> y
array([   0., -999.]) 

>>> with np.errstate(divide='ignore'):
...   y = np.log(softmax(x))
...
>>> y
array([  0., -inf]) 

scipy.special.spence

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.spence.html#scipy.special.spence

scipy.special.spence(z, out=None) = <ufunc 'spence'>

Spence 函数，也称为二阶对数函数。

它的定义如下

[\int_1^z \frac{\log(t)}{1 - t}dt]

对于复数 (z)，积分的路径避开对数的分支切割。Spence 函数在除了负实轴外的所有地方都是解析的。

参数：

zarray_like

评估 Spence 函数的点

outndarray，可选项

可选的输出数组以获取函数结果

返回：

s标量或 ndarray

计算得到的 Spence 函数值

注意事项

通过积分定义 Spence 函数的另一种约定如下：

[-\int_0^z \frac{\log(1 - t)}{t}dt;]

这是我们的 spence(1 - z)。

示例

>>> import numpy as np
>>> from scipy.special import spence
>>> import matplotlib.pyplot as plt 

该函数定义适用于复数输入：

>>> spence([1-1j, 1.5+2j, 3j, -10-5j])
array([-0.20561676+0.91596559j, -0.86766909-1.39560134j,
 -0.59422064-2.49129918j, -1.14044398+6.80075924j]) 

对于复数输入的分支切割，即负实轴，函数在具有正虚部的 z 上返回限制。例如，在以下情况下，请注意输出的虚部对于 z = -2 和 z = -2 - 1e-8j 的符号变化：

>>> spence([-2 + 1e-8j, -2, -2 - 1e-8j])
array([2.32018041-3.45139229j, 2.32018042-3.4513923j ,
 2.32018041+3.45139229j]) 

函数在实数输入处的分支切割处返回 nan：

>>> spence(-1.5)
nan 

验证一些特定值：spence(0) = pi**2/6，spence(1) = 0 和 spence(2) = -pi**2/12。

>>> spence([0, 1, 2])
array([ 1.64493407,  0\.        , -0.82246703])
>>> np.pi**2/6, -np.pi**2/12
(1.6449340668482264, -0.8224670334241132) 

验证身份：

spence(z) + spence(1 - z) = pi**2/6 - log(z)*log(1 - z) 

>>> z = 3 + 4j
>>> spence(z) + spence(1 - z)
(-2.6523186143876067+1.8853470951513935j)
>>> np.pi**2/6 - np.log(z)*np.log(1 - z)
(-2.652318614387606+1.885347095151394j) 

绘制正实数输入的函数。

>>> fig, ax = plt.subplots()
>>> x = np.linspace(0, 6, 400)
>>> ax.plot(x, spence(x))
>>> ax.grid()
>>> ax.set_xlabel('x')
>>> ax.set_title('spence(x)')
>>> plt.show() 

scipy.special.zeta

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.zeta.html#scipy.special.zeta

scipy.special.zeta(x, q=None, out=None)

黎曼或 Hurwitz zeta 函数。

参数:

x 浮点数数组

输入数据，必须为实数

q 浮点数数组, 可选项

输入数据，必须为实数。默认情况是瑞曼 zeta。

out 数组, 可选项

计算得到的数值的输出数组。

返回:

out 数组

zeta(x)的数值。

另见

zetac

说明

两个参数的版本是 Hurwitz zeta 函数

[\zeta(x, q) = \sum_{k=0}^{\infty} \frac{1}{(k + q)^x};]

有关详细信息，请参见[dlmf]。 当q = 1时，瑞曼 zeta 函数对应的是该情形。

参考资料

[dlmf]

NIST，数字数学函数数字化图书馆, dlmf.nist.gov/25.11#i

例子

>>> import numpy as np
>>> from scipy.special import zeta, polygamma, factorial 

一些特定数值:

>>> zeta(2), np.pi**2/6
(1.6449340668482266, 1.6449340668482264) 

>>> zeta(4), np.pi**4/90
(1.0823232337111381, 1.082323233711138) 

与polygamma函数的关系:

>>> m = 3
>>> x = 1.25
>>> polygamma(m, x)
array(2.782144009188397)
>>> (-1)**(m+1) * factorial(m) * zeta(m+1, x)
2.7821440091883969 

scipy.special.zetac

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

scipy.special.zetac(x, out=None) = <ufunc 'zetac'>

黎曼 zeta 函数减 1。

此函数定义如下

[\zeta(x) = \sum_{k=2}^{\infty} 1 / k^x,]

其中 x > 1。对于 x < 1，进行解析延伸计算。有关黎曼 zeta 函数的更多信息，请参见[dlmf]。

参数：

x 浮点数的数组

计算 zeta(x) - 1 的值的位置（必须是实数）。

out ndarray，可选

函数结果的可选输出数组

返回：

标量或 ndarray

zeta(x) - 1 的值。

另请参阅

zeta

参考文献

[dlmf]

NIST 数学函数数字图书馆 dlmf.nist.gov/25

例子

>>> import numpy as np
>>> from scipy.special import zetac, zeta 

一些特殊值：

>>> zetac(2), np.pi**2/6 - 1
(0.64493406684822641, 0.6449340668482264) 

>>> zetac(-1), -1.0/12 - 1
(-1.0833333333333333, -1.0833333333333333) 

比较zetac(x)和zeta(x) - 1对于大的x：

>>> zetac(60), zeta(60) - 1
(8.673617380119933e-19, 0.0) 

scipy.special.cbrt

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

scipy.special.cbrt(x, out=None) = <ufunc 'cbrt'>

x 的逐元素立方根。

参数：

xarray_like

x 必须包含实数。

outndarray，可选

函数值的可选输出数组

返回值：

标量或者 ndarray

x 中每个值的立方根。

示例

>>> from scipy.special import cbrt 

>>> cbrt(8)
2.0
>>> cbrt([-8, -3, 0.125, 1.331])
array([-2\.        , -1.44224957,  0.5       ,  1.1       ]) 

scipy.special.exp10

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

scipy.special.exp10(x, out=None) = <ufunc 'exp10'>

逐元素计算10**x。

参数：

xarray_like

x必须包含实数。

outndarray，可选

函数值的可选输出数组

返回值：

标量或数组

逐元素计算10**x。

示例

>>> import numpy as np
>>> from scipy.special import exp10 

>>> exp10(3)
1000.0
>>> x = np.array([[-1, -0.5, 0], [0.5, 1, 1.5]])
>>> exp10(x)
array([[  0.1       ,   0.31622777,   1\.        ],
 [  3.16227766,  10\.        ,  31.6227766 ]]) 

scipy.special.exp2

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

scipy.special.exp2(x, out=None) = <ufunc 'exp2'>

逐元素计算2**x。

参数：

xarray_like

x必须包含实数。

输出ndarray，可选

函数值的可选输出数组

返回值：

标量或 ndarray

2**x，逐元素计算。

示例

>>> import numpy as np
>>> from scipy.special import exp2 

>>> exp2(3)
8.0
>>> x = np.array([[-1, -0.5, 0], [0.5, 1, 1.5]])
>>> exp2(x)
array([[ 0.5       ,  0.70710678,  1\.        ],
 [ 1.41421356,  2\.        ,  2.82842712]]) 

scipy.special.radian

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.radian.html#scipy.special.radian

scipy.special.radian(d, m, s, out=None) = <ufunc 'radian'>

将角度从度转换为弧度。

返回用弧度表示的角度，其中包括度(d)、分钟(m)和秒(s)。

参数：

darray_like

度，可以是实值。

marray_like

分钟，可以是实值。

sarray_like

秒，可以是实值。

outndarray，可选

函数结果的可选输出数组。

返回：

标量或者 ndarray

输入的数值以弧度为单位。

示例

>>> import scipy.special as sc 

指定角度的方式有很多种。

>>> sc.radian(90, 0, 0)
1.5707963267948966
>>> sc.radian(0, 60 * 90, 0)
1.5707963267948966
>>> sc.radian(0, 0, 60**2 * 90)
1.5707963267948966 

输入可以是实值。

>>> sc.radian(1.5, 0, 0)
0.02617993877991494
>>> sc.radian(1, 30, 0)
0.02617993877991494 

scipy.special.cosdg

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.cosdg.html#scipy.special.cosdg

scipy.special.cosdg(x, out=None) = <ufunc 'cosdg'>

角度x的余弦，单位为度。

参数：

xarray_like

给定的角度，单位为度。

outndarray，可选

函数结果的可选输出数组。

返回：

标量或 ndarray

输入的余弦。

另请参见

sindg, tandg, cotdg

Examples

>>> import numpy as np
>>> import scipy.special as sc 

比直接使用余弦更准确。

>>> x = 90 + 180 * np.arange(3)
>>> sc.cosdg(x)
array([-0.,  0., -0.])
>>> np.cos(x * np.pi / 180)
array([ 6.1232340e-17, -1.8369702e-16,  3.0616170e-16]) 

scipy.special.sindg

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.sindg.html#scipy.special.sindg

scipy.special.sindg(x, out=None) = <ufunc 'sindg'>

输入角度x的正弦值。

参数：

xarray_like

角度，以度为单位。

outndarray，可选

函数结果的可选输出数组。

返回：

标量或 ndarray

输入角度的正弦值。

参见

cosdg，tandg，cotdg

示例

>>> import numpy as np
>>> import scipy.special as sc 

比直接使用正弦更精确。

>>> x = 180 * np.arange(3)
>>> sc.sindg(x)
array([ 0., -0.,  0.])
>>> np.sin(x * np.pi / 180)
array([ 0.0000000e+00,  1.2246468e-16, -2.4492936e-16]) 

scipy.special.tandg

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

scipy.special.tandg(x, out=None) = <ufunc 'tandg'>

给定以度为单位的角度x的正切。

参数：

xarray_like

角度，以度为单位。

outndarray，可选

可选的输出数组，用于函数结果。

返回：

标量或 ndarray

输入处的正切值。

参见

sindg，cosdg，cotdg

示例

>>> import numpy as np
>>> import scipy.special as sc 

比直接使用正切更精确。

>>> x = 180 * np.arange(3)
>>> sc.tandg(x)
array([0., 0., 0.])
>>> np.tan(x * np.pi / 180)
array([ 0.0000000e+00, -1.2246468e-16, -2.4492936e-16]) 

scipy.special.cotdg

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

scipy.special.cotdg(x, out=None) = <ufunc 'cotdg'>

给定以度数表示的角度 x 的余切。

参数：

xarray_like

角度，以度数给出。

outndarray, 可选

可选的输出数组用于函数结果。

返回值：

标量或者 ndarray

输入的余切值。

参见

sindg, cosdg, tandg

示例

>>> import numpy as np
>>> import scipy.special as sc 

比直接使用余切函数更加精确。

>>> x = 90 + 180 * np.arange(3)
>>> sc.cotdg(x)
array([0., 0., 0.])
>>> 1 / np.tan(x * np.pi / 180)
array([6.1232340e-17, 1.8369702e-16, 3.0616170e-16]) 

scipy.special.log1p

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.log1p.html#scipy.special.log1p

scipy.special.log1p(x, out=None) = <ufunc 'log1p'>

当x接近零时，计算 log(1 + x)。

参数：

x，array_like

实数或复数输入。

out，可选的 ndarray

函数结果的可选输出数组。

返回：

标量或 ndarray

log(1 + x) 的值。

参见

expm1, cosm1

示例

>>> import numpy as np
>>> import scipy.special as sc 

对于x接近 0，这比直接使用log(1 + x)更精确。请注意，在下面的例子中，1 + 1e-17 == 1可达双精度。

>>> sc.log1p(1e-17)
1e-17
>>> np.log(1 + 1e-17)
0.0 

scipy.special.expm1

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.expm1.html#scipy.special.expm1

scipy.special.expm1(x, out=None) = <ufunc 'expm1'>

计算 exp(x) - 1。

当 x 接近零时，exp(x) 接近 1，因此在计算 exp(x) - 1 时可能会遭受灾难性的精度损失。expm1(x) 的实现旨在避免 x 接近零时发生的精度损失。

参数：

x 数组样式

x 必须包含实数。

out ndarray，可选

函数值的可选输出数组

返回：

标量或者 ndarray

逐元素计算 exp(x) - 1。

示例

>>> import numpy as np
>>> from scipy.special import expm1 

>>> expm1(1.0)
1.7182818284590451
>>> expm1([-0.2, -0.1, 0, 0.1, 0.2])
array([-0.18126925, -0.09516258,  0\.        ,  0.10517092,  0.22140276]) 

exp(7.5e-13) - 1 的确切值是：

7.5000000000028125000000007031250000001318...*10**-13. 

这里是 expm1(7.5e-13) 的结果：

>>> expm1(7.5e-13)
7.5000000000028135e-13 

将其与 exp(7.5e-13) - 1 比较，其中减法导致“灾难性”的精度损失：

>>> np.exp(7.5e-13) - 1
7.5006667543675576e-13 

scipy.special.cosm1

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

scipy.special.cosm1(x, out=None) = <ufunc 'cosm1'>

当x接近零时，用于计算cos(x) - 1。

参数：

x：array_like

实数值的参数。

out：ndarray，可选

函数结果的可选输出数组。

返回：

标量或者 ndarray

值为cos(x) - 1。

参见

expm1，log1p

示例

>>> import numpy as np
>>> import scipy.special as sc 

对于x接近 0，比直接计算cos(x) - 1更精确。

>>> x = 1e-30
>>> np.cos(x) - 1
0.0
>>> sc.cosm1(x)
-5.0000000000000005e-61 

scipy.special.powm1

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

scipy.special.powm1(x, y, out=None) = <ufunc 'powm1'>

计算x**y - 1。

当y接近 0 或x接近 1 时，此函数非常有用。

该函数仅适用于实数类型（与numpy.power不同，后者接受复数输入）。

参数：

xarray_like

底数。必须是实数类型（即整数或浮点数，而不是复数）。

yarray_like

指数。必须是实数类型（即整数或浮点数，而不是复数）。

返回：

array_like

计算结果

注意事项

新版本 1.10.0 中推出。

该基础代码仅适用于单精度和双精度浮点数。与numpy.power不同，输入为整数的powm1会被转换为浮点数，而复数输入则不被接受。

请注意以下边界情况：

• powm1(x, 0)对于任何x都会返回 0，包括 0、inf和nan。

• powm1(1, y)对于任何y都将返回 0，包括nan和inf。

示例

>>> import numpy as np
>>> from scipy.special import powm1 

>>> x = np.array([1.2, 10.0, 0.9999999975])
>>> y = np.array([1e-9, 1e-11, 0.1875])
>>> powm1(x, y)
array([ 1.82321557e-10,  2.30258509e-11, -4.68749998e-10]) 

可以验证这些结果中的相对误差都小于 2.5e-16。

将其与x**y - 1的结果进行比较，其中相对误差都大于 8e-8：

>>> x**y - 1
array([ 1.82321491e-10,  2.30258035e-11, -4.68750039e-10]) 

scipy.special.round

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.round.html#scipy.special.round

scipy.special.round(x, out=None) = <ufunc 'round'>

四舍五入到最接近的整数。

返回最接近x的整数。如果x恰好以 0.5 结尾，则选择最接近的偶数整数。

参数：

x：array_like

实值输入。

out：ndarray，可选

用于函数结果的可选输出数组。

返回：

标量或 ndarray

x元素的最接近整数。结果为浮点类型，而非整数类型。

示例

>>> import scipy.special as sc 

它四舍五入为偶数。

>>> sc.round([0.5, 1.5])
array([0., 2.]) 

scipy.special.xlogy

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.xlogy.html#scipy.special.xlogy

scipy.special.xlogy(x, y, out=None) = <ufunc 'xlogy'>

计算 x*log(y)，如果 x = 0 则结果为 0。

参数：

xarray_like

乘法器

yarray_like

参数

out数组，可选

函数结果的可选输出数组

返回：

z标量或数组

计算 x*log(y)

注意

计算中使用的对数函数是自然对数。

从版本 0.13.0 开始新增。

示例

我们可以使用此函数来计算二元逻辑损失，也称为二元交叉熵。这种损失函数用于二元分类问题，定义如下：

[L = 1/n * \sum_{i=0}^n -(y_ilog(y_pred_i) + (1-y_i)log(1-y_pred_i))]

我们可以将参数 x 和 y 定义为 y 和 y_pred，y 是实际标签的数组，这里可以是 0 或 1。y_pred 是相对于正类（1）的预测概率数组。

>>> import numpy as np
>>> from scipy.special import xlogy
>>> y = np.array([0, 1, 0, 1, 1, 0])
>>> y_pred = np.array([0.3, 0.8, 0.4, 0.7, 0.9, 0.2])
>>> n = len(y)
>>> loss = -(xlogy(y, y_pred) + xlogy(1 - y, 1 - y_pred)).sum()
>>> loss /= n
>>> loss
0.29597052165495025 

较低的损失通常更好，因为它表明预测与实际标签相似。在这个例子中，由于我们的预测概率接近实际标签，我们得到的总体损失是合理低且适当的。

scipy.special.xlog1py

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.xlog1py.html#scipy.special.xlog1py

scipy.special.xlog1py(x, y, out=None) = <ufunc 'xlog1py'>

计算 x*log1p(y)，使得当 x = 0 时结果为 0。

参数：

x：类似数组

乘法器

y：类似数组

参数

out：数组，可选

函数结果的可选输出数组

返回：

z：标量或者数组

计算得到的 x*log1p(y)

注意

新版本 0.13.0 中新增。

示例

本例展示了如何使用该函数计算几何离散随机变量的概率质量函数的对数。几何分布的概率质量函数定义如下：

[f(k) = (1-p)^{k-1} p]

其中( p )是单次成功的概率，( 1-p )是单次失败的概率，( k )是获得第一个成功的尝试次数。

>>> import numpy as np
>>> from scipy.special import xlog1py
>>> p = 0.5
>>> k = 100
>>> _pmf = np.power(1 - p, k - 1) * p
>>> _pmf
7.888609052210118e-31 

如果我们取 k 为相对较大的数，概率质量函数的值可能会变得非常低。在这种情况下，取概率质量函数的对数可能更合适，因为对数函数可以将值变换到更适合处理的比例。

>>> _log_pmf = xlog1py(k - 1, -p) + np.log(p)
>>> _log_pmf
-69.31471805599453 

我们可以通过将 log pmf 的指数取出来来确认我们获得了接近原始 pmf 值的值。

>>> _orig_pmf = np.exp(_log_pmf)
>>> np.isclose(_pmf, _orig_pmf)
True 

scipy.special.logsumexp

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

scipy.special.logsumexp(a, axis=None, b=None, keepdims=False, return_sign=False)

计算输入元素的指数之和的对数。

参数：

aarray_like

输入数组。

axisNone 或 int 或 int 元组，可选

要对其求和的轴或轴。默认情况下 axis 为 None，将对所有元素求和。

自版本 0.11.0 起新增。

barray-like，可选

exp(a) 的缩放因子必须与 a 具有相同的形状或可广播到 a。这些值可以为负，以实现减法。

自版本 0.12.0 起新增。

keepdimsbool，可选

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

自版本 0.15.0 起新增。

return_signbool，可选

如果设置为 True，则结果将是包含符号信息的一对；如果为 False，则负数结果将返回为 NaN。默认为 False（无符号信息）。

自版本 0.16.0 起新增。

返回：

resndarray

结果 np.log(np.sum(np.exp(a))) 以更稳定的方式计算。如果给定 b，则返回 np.log(np.sum(b*np.exp(a)))。

sgnndarray

如果 return_sign 设置为 True，则将返回与结果匹配的浮点数数组和 +1、0 或 -1，具体取决于结果的符号。如果设置为 False，则只返回一个结果。

另请参阅

numpy.logaddexp，numpy.logaddexp2

注意

NumPy 有一个 logaddexp 函数，非常类似于 logsumexp，但只处理两个参数。logaddexp.reduce 与此函数类似，但可能不太稳定。

示例

>>> import numpy as np
>>> from scipy.special import logsumexp
>>> a = np.arange(10)
>>> logsumexp(a)
9.4586297444267107
>>> np.log(np.sum(np.exp(a)))
9.4586297444267107 

带有权重

>>> a = np.arange(10)
>>> b = np.arange(10, 0, -1)
>>> logsumexp(a, b=b)
9.9170178533034665
>>> np.log(np.sum(b*np.exp(a)))
9.9170178533034647 

返回一个标志符号

>>> logsumexp([1,2],b=[1,-1],return_sign=True)
(1.5413248546129181, -1.0) 

请注意，logsumexp 不直接支持掩码数组。要在掩码数组上使用它，请将掩码转换为零权重：

>>> a = np.ma.array([np.log(2), 2, np.log(3)],
...                  mask=[False, True, False])
>>> b = (~a.mask).astype(int)
>>> logsumexp(a.data, b=b), np.log(5)
1.6094379124341005, 1.6094379124341005 

scipy.special.exprel

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

scipy.special.exprel(x, out=None) = <ufunc 'exprel'>

相对误差的指数形式，(exp(x) - 1)/x。

当x接近零时，exp(x)接近 1，因此在计算exp(x) - 1时可能会出现严重的精度损失。 exprel(x) 被实现以避免x接近零时出现的精度损失。

参数:

xndarray

输入数组。 x必须包含实数。

outndarray，可选

该功能值的可选输出数组

返回值:

标量或 ndarray

(exp(x) - 1)/x，按元素计算。

另请参阅

expm1

注意事项

在 0.17.0 版中新增。

例子

>>> import numpy as np
>>> from scipy.special import exprel 

>>> exprel(0.01)
1.0050167084168056
>>> exprel([-0.25, -0.1, 0, 0.1, 0.25])
array([ 0.88479687,  0.95162582,  1\.        ,  1.05170918,  1.13610167]) 

比较exprel(5e-9)与朴素计算的结果。准确值为1.00000000250000000416...。

>>> exprel(5e-9)
1.0000000025 

>>> (np.exp(5e-9) - 1)/5e-9
0.99999999392252903 

scipy.special.sinc

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

scipy.special.sinc(x)

返回归一化的 sinc 函数。

对于任何参数(x\ne 0)，sinc 函数等于(\sin(\pi x)/(\pi x))。 sinc(0)取极限值 1，使得sinc不仅在任何地方连续，而且在无限可微。

注意事项

注意在定义中使用的π的归一化因子。 这是信号处理中最常用的定义。 使用sinc(x / np.pi)可以获得在数学中更常见的未归一化 sinc 函数(\sin(x)/x)。

参数：

x数组

数组（可能是多维的）的值，用于计算sinc(x)。

返回：

输出数组

sinc(x)，与输入的形状相同。

注意事项

名称 sinc 简称为“sine cardinal”或“sinus cardinalis”。

sinc 函数在各种信号处理应用中使用，包括抗混叠、Lanczos 重采样滤波器的构建和插值。

对于离散时间信号的带限插值，理想的插值核心与 sinc 函数成比例。

参考文献

[1]

Weisstein, Eric W. “Sinc 函数。” From MathWorld–A Wolfram Web Resource. mathworld.wolfram.com/SincFunction.html

[2]

维基百科，“Sinc 函数”，[zh.wikipedia.org/wiki/Sinc 函数](https://zh.wikipedia.org/wiki/Sinc 函数)

示例

>>> import matplotlib.pyplot as plt
>>> x = np.linspace(-4, 4, 41)
>>> np.sinc(x)
 array([-3.89804309e-17,  -4.92362781e-02,  -8.40918587e-02, # may vary
 -8.90384387e-02,  -5.84680802e-02,   3.89804309e-17,
 6.68206631e-02,   1.16434881e-01,   1.26137788e-01,
 8.50444803e-02,  -3.89804309e-17,  -1.03943254e-01,
 -1.89206682e-01,  -2.16236208e-01,  -1.55914881e-01,
 3.89804309e-17,   2.33872321e-01,   5.04551152e-01,
 7.56826729e-01,   9.35489284e-01,   1.00000000e+00,
 9.35489284e-01,   7.56826729e-01,   5.04551152e-01,
 2.33872321e-01,   3.89804309e-17,  -1.55914881e-01,
 -2.16236208e-01,  -1.89206682e-01,  -1.03943254e-01,
 -3.89804309e-17,   8.50444803e-02,   1.26137788e-01,
 1.16434881e-01,   6.68206631e-02,   3.89804309e-17,
 -5.84680802e-02,  -8.90384387e-02,  -8.40918587e-02,
 -4.92362781e-02,  -3.89804309e-17]) 

>>> plt.plot(x, np.sinc(x))
[<matplotlib.lines.Line2D object at 0x...>]
>>> plt.title("Sinc Function")
Text(0.5, 1.0, 'Sinc Function')
>>> plt.ylabel("Amplitude")
Text(0, 0.5, 'Amplitude')
>>> plt.xlabel("X")
Text(0.5, 0, 'X')
>>> plt.show() 

统计函数（scipy.stats）

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

该模块包含大量的概率分布、汇总和频率统计、相关函数和统计检验、掩码统计、核密度估计、拟蒙特卡洛功能等。

统计学是一个非常广泛的领域，SciPy 范围之外的主题由其他包涵盖。其中一些最重要的是：

• statsmodels: 回归、线性模型、时间序列分析，扩展到 scipy.stats 也覆盖的主题。

• Pandas: 表格数据、时间序列功能，与其他统计语言的接口。

• PyMC: 贝叶斯统计建模，概率机器学习。

• scikit-learn: 分类、回归、模型选择。

• Seaborn: 统计数据可视化。

• rpy2: Python 到 R 的桥梁。

概率分布

每个单变量分布都是 rv_continuous 的子类实例（对于离散分布为 rv_discrete）：

rv_continuous([momtype, a, b, xtol, ...])	用于子类化的通用连续随机变量类。
rv_discrete([a, b, name, badvalue, ...])	一个用于子类化的通用离散随机变量类。
rv_histogram(histogram, *args[, density])	根据直方图生成分布。

连续分布

alpha	Alpha 连续随机变量。
anglit	Anglit 连续随机变量。
arcsine	Arcsine 连续随机变量。
argus	Argus 分布。
beta	Beta 连续随机变量。
betaprime	Beta prime 连续随机变量。
bradford	一种 Bradford 连续随机变量。
burr	一种 Burr（类型 III）连续随机变量。
burr12	一个 Burr（类型 XII）连续随机变量。
cauchy	一个柯西连续随机变量。
chi	一个卡连续随机变量。
chi2	一个卡方连续随机变量。
cosine	余弦连续随机变量。
crystalball	Crystalball 分布
dgamma	一个双伽玛连续随机变量。
dweibull	一个双韦伯连续随机变量。
erlang	一个 Erlang 连续随机变量。
expon	一个指数连续随机变量。
exponnorm	一个指数修改正态连续随机变量。
exponweib	一个指数化韦伯连续随机变量。
exponpow	一种指数幂连续随机变量。
f	一个 F 连续随机变量。
fatiguelife	一个疲劳寿命（Birnbaum-Saunders）连续随机变量。
fisk	一个 Fisk 连续随机变量。
foldcauchy	一个折叠柯西连续随机变量。
foldnorm	一个折叠正态连续随机变量。
genlogistic	一个广义逻辑连续随机变量。
gennorm	一个广义正态连续随机变量。
genpareto	一个广义 Pareto 连续随机变量。
genexpon	一个广义指数连续随机变量。
genextreme	一个广义极值连续随机变量。
gausshyper	一个 Gauss 超几何连续随机变量。
gamma	一个 Gamma 连续随机变量。
gengamma	一个广义 Gamma 连续随机变量。
genhalflogistic	一个广义半 Logistic 连续随机变量。
genhyperbolic	一个广义双曲连续随机变量。
geninvgauss	一个广义逆高斯连续随机变量。
gibrat	一个 Gibrat 连续随机变量。
gompertz	一个 Gompertz（或截尾 Gumbel）连续随机变量。
gumbel_r	一个右偏 Gumbel 连续随机变量。
gumbel_l	一个左偏 Gumbel 连续随机变量。
halfcauchy	一个半 Cauchy 连续随机变量。
halflogistic	一个半 Logistic 连续随机变量。
halfnorm	一个半正态连续随机变量。
halfgennorm	一个广义正态连续随机变量的上半部分。
hypsecant	一个双曲正切连续随机变量。
invgamma	反 Gamma 连续随机变量。
invgauss	逆高斯连续随机变量。
invweibull	反 Weibull 连续随机变量。
jf_skew_t	Jones 和 Faddy 偏态 t 分布。
johnsonsb	Johnson SB 连续随机变量。
johnsonsu	Johnson SU 连续随机变量。
kappa4	Kappa 4 参数分布。
kappa3	Kappa 3 参数分布。
ksone	Kolmogorov-Smirnov 单侧检验统计量分布。
kstwo	Kolmogorov-Smirnov 双侧检验统计量分布。
kstwobign	缩放 Kolmogorov-Smirnov 双侧检验统计量的极限分布。
laplace	Laplace 连续随机变量。
laplace_asymmetric	非对称 Laplace 连续随机变量。
levy	Levy 连续随机变量。
levy_l	左偏 Levy 连续随机变量。
levy_stable	Levy 稳定连续随机变量。
logistic	逻辑斯蒂（或 Sech 平方）连续随机变量。
loggamma	对数 Gamma 连续随机变量。
loglaplace	对数拉普拉斯连续随机变量。
lognorm	对数正态连续随机变量。
loguniform	一个对数均匀或倒数连续随机变量。
lomax	一个 Lomax（第二类帕累托）连续随机变量。
maxwell	一个麦克斯韦连续随机变量。
mielke	一个 Mielke Beta-Kappa / Dagum 连续随机变量。
moyal	一个莫耶连续随机变量。
nakagami	一个中村连续随机变量。
ncx2	一个非中心卡方连续随机变量。
ncf	一个非中心 F 分布连续随机变量。
nct	一个非中心学生 t 连续随机变量。
norm	一个正态连续随机变量。
norminvgauss	一个正态逆高斯连续随机变量。
pareto	一个帕累托连续随机变量。
pearson3	一个皮尔逊类型 III 连续随机变量。
powerlaw	一个幂函数连续随机变量。
powerlognorm	一个功率对数正态连续随机变量。
powernorm	一个幂正态连续随机变量。
rdist	一个服从 R 分布（对称贝塔分布）的连续随机变量。
rayleigh	一个瑞利连续随机变量。
rel_breitwigner	一个相对论布莱特-温格随机变量。
rice	一个瑞丝连续随机变量。
recipinvgauss	倒数反高斯连续随机变量。
semicircular	半圆形连续随机变量。
skewcauchy	偏斜 Cauchy 随机变量。
skewnorm	偏斜正态随机变量。
studentized_range	学生化范围连续随机变量。
t	学生 t 连续随机变量。
trapezoid	梯形连续随机变量。
triang	三角形连续随机变量。
truncexpon	截断指数连续随机变量。
truncnorm	截断正态连续随机变量。
truncpareto	上截断 Pareto 连续随机变量。
truncweibull_min	双截断 Weibull 最小连续随机变量。
tukeylambda	Tukey-Lamdba 连续随机变量。
uniform	均匀分布连续随机变量。
vonmises	Von Mises 连续随机变量。
vonmises_line	Von Mises 连续随机变量。
wald	Wald 连续随机变量。
weibull_min	Weibull 最小连续随机变量。
weibull_max	Weibull 最大连续随机变量。
wrapcauchy	包裹 Cauchy 连续随机变量。

一元连续分布的 fit 方法使用最大似然估计来拟合数据集到分布。fit 方法可以接受常规数据或被审查数据。被审查的数据使用 CensoredData 类的实例表示。

CensoredData([未审查, 左, 右, 间隔])	该类的实例表示被审查的数据。

多元分布

multivariate_normal	多元正态分布随机变量。
matrix_normal	矩阵正态分布随机变量。
dirichlet	狄利克雷分布随机变量。
dirichlet_multinomial	狄利克雷-多项式分布随机变量。
wishart	Wishart 分布随机变量。
invwishart	逆 Wishart 分布随机变量。
multinomial	多项式分布随机变量。
special_ortho_group	特殊正交矩阵 (SO(N)) 随机变量。
ortho_group	正交矩阵 (O(N)) 随机变量。
unitary_group	U(N) 矩阵值随机变量。
random_correlation	随机相关矩阵。
multivariate_t	多元 t 分布随机变量。
multivariate_hypergeom	多元超几何分布随机变量。
random_table	独立样本的固定边际和的列联表。
uniform_direction	一个向量值均匀分布的方向。
vonmises_fisher	一个 von Mises-Fisher 变量。

scipy.stats.multivariate_normal 方法接受以下类的实例来表示协方差。

Covariance()	协方差矩阵的表示

离散分布

bernoulli	一个伯努利离散随机变量。
betabinom	一个贝塔二项式离散随机变量。
betanbinom	一个贝塔负二项式离散随机变量。
binom	一个二项式离散随机变量。
boltzmann	一个 Boltzmann（截断离散指数）随机变量。
dlaplace	一个拉普拉斯离散随机变量。
geom	一个几何离散随机变量。
hypergeom	一个超几何离散随机变量。
logser	一个对数（Log-Series, Series）离散随机变量。
nbinom	一个负二项式离散随机变量。
nchypergeom_fisher	一个 Fisher 的非中心超几何离散随机变量。
nchypergeom_wallenius	一个 Wallenius 的非中心超几何离散随机变量。
nhypergeom	一个负超几何离散随机变量。
planck	一个 Planck 离散指数随机变量。
poisson	一个泊松离散随机变量。
randint	一个均匀离散随机变量。
skellam	一个 Skellam 离散随机变量。
yulesimon	一个 Yule-Simon 离散随机变量。
zipf	一个 Zipf（Zeta）离散随机变量。
zipfian	一个 Zipfian 离散随机变量。

下面给出了统计函数的概述。其中许多函数在scipy.stats.mstats中有类似版本，适用于掩码数组。

摘要统计

describe(a[, axis, ddof, bias, nan_policy])	计算传递数组的几个描述性统计量。
gmean(a[, axis, dtype, weights, nan_policy, ...])	计算沿指定轴的加权几何平均值。
hmean(a[, axis, dtype, weights, nan_policy, ...])	计算沿指定轴的加权调和平均值。
pmean(a, p, *[, axis, dtype, weights, ...])	计算沿指定轴的加权幂均值。
kurtosis(a[, axis, fisher, bias, ...])	计算数据集的峰度（Fisher 或 Pearson）。
mode(a[, axis, nan_policy, keepdims])	返回传递数组中最常见的值的数组。
moment(a[, moment, axis, nan_policy, ...])	计算样本关于均值的第 n 阶矩。
expectile(a[, alpha, weights])	计算指定水平的期望分位数。
skew(a[, axis, bias, nan_policy, keepdims])	计算数据集的样本偏度。
kstat(data[, n, axis, nan_policy, keepdims])	返回第 n 个 k-统计量（目前 1<=n<=4）。
kstatvar(data[, n, axis, nan_policy, keepdims])	返回 k-统计量方差的无偏估计。
tmean(a[, limits, inclusive, axis, ...])	计算修剪均值。
tvar(a[, limits, inclusive, axis, ddof, ...])	计算修剪方差。
tmin(a[, lowerlimit, axis, inclusive, ...])	计算修剪后的最小值。
tmax(a[, upperlimit, axis, inclusive, ...])	计算修剪后的最大值。
tstd(a[, limits, inclusive, axis, ddof, ...])	计算修剪样本标准差。
tsem(a[, limits, inclusive, axis, ddof, ...])	计算修剪均值标准误差。
variation(a[, axis, nan_policy, ddof, keepdims])	计算变异系数。
find_repeats(arr)	查找重复项及重复计数。
rankdata(a[, method, axis, nan_policy])	分配数据排名，适当处理并列情况。
tiecorrect(rankvals)	Mann-Whitney U 检验和 Kruskal-Wallis H 检验的结带校正因子。
trim_mean(a, proportiontocut[, axis])	返回修剪分布两端后的数组均值。
gstd(a[, axis, ddof])	计算数组的几何标准差。
iqr(x[, axis, rng, scale, nan_policy, ...])	计算沿指定轴的四分位距。
sem(a[, axis, ddof, nan_policy, keepdims])	计算均值的标准误差。
bayes_mvs(data[, alpha])	均值、方差和标准差的贝叶斯置信区间。
mvsdist(data)	数据的均值、方差和标准差的‘冻结’分布。
entropy(pk[, qk, base, axis, nan_policy, ...])	计算给定分布的香农熵/相对熵。
differential_entropy(values, *[, ...])	给定分布样本，估计差分熵。
median_abs_deviation(x[, axis, center, ...])	计算给定轴向数据的中位数绝对偏差。

频率统计

cumfreq(a[, numbins, defaultreallimits, weights])	使用直方图函数返回累积频率直方图。
percentileofscore(a, score[, kind, nan_policy])	计算得分相对于得分列表的百分位等级。
scoreatpercentile(a, per[, limit, ...])	计算输入序列在给定百分位数处的分数。
relfreq(a[, numbins, defaultreallimits, weights])	使用直方图函数返回相对频率直方图。
binned_statistic(x, values[, statistic, ...])	计算一个或多个数据集的分箱统计量。
binned_statistic_2d(x, y, values[, ...])	计算一个或多个数据集的二维分箱统计量。
binned_statistic_dd(sample, values[, ...])	计算数据集的多维分箱统计量。

假设检验及相关函数

SciPy 包含许多用于执行假设检验的函数，这些函数返回一个检验统计量和 p 值，其中一些还返回置信区间或其他相关信息。

下面的标题基于其中函数的常见用法，但由于统计程序种类繁多，任何试图粗略分类的尝试都将是不完美的。另外，请注意，同一标题内的测试通常不能互换（例如，许多测试具有不同的分布假设）。

一样本检验 / 成对样本检验

一样本检验通常用于评估单一样本是否来自指定分布或具有指定属性的分布（例如零均值）。

ttest_1samp(a, popmean[, axis, nan_policy, ...])	计算一个组分数的均值的 T 检验。
binomtest(k, n[, p, alternative])	执行一个测试，检验成功的概率是否为 p。
quantile_test(x, *[, q, p, alternative])	执行一个分位数检验，并计算分位数的置信区间。
skewtest(a[, axis, nan_policy, alternative])	测试偏斜是否与正态分布不同。
kurtosistest(a[, axis, nan_policy, alternative])	测试数据集是否具有正常峰度。
normaltest(a[, axis, nan_policy])	测试样本是否与正态分布不同。
jarque_bera(x, *[, axis, nan_policy, keepdims])	对样本数据执行 Jarque-Bera 拟合优度检验。
shapiro(x)	执行 Shapiro-Wilk 正态性检验。
anderson(x[, dist])	Anderson-Darling 检验用于来自特定分布的数据。
cramervonmises(rvs, cdf[, args, axis, ...])	执行单样本 Cramér-von Mises 拟合优度检验。
ks_1samp(x, cdf[, args, alternative, ...])	执行单样本 Kolmogorov-Smirnov 拟合优度检验。
goodness_of_fit(dist, data, *[, ...])	执行拟合优度检验，将数据与分布族比较。
chisquare(f_obs[, f_exp, ddof, axis])	计算单向卡方检验。
power_divergence(f_obs[, f_exp, ddof, axis, ...])	Cressie-Read 力度分散统计量和拟合优度检验。

配对样本检验通常用于评估两个样本是否来自同一分布；它们与下面的独立样本检验不同之处在于，一个样本中的每个观测值被视为与另一个样本中一个密切相关的观测值配对（例如，在一对观测值之间控制环境因素，但在不同对之间不控制）。它们也可以被解释或用作单样本检验（例如，对配对观测值之间的差异的均值或中位数进行检验）。

ttest_rel(a, b[, axis, nan_policy, ...])	计算两个相关样本 a 和 b 的 t 检验。
wilcoxon(x[, y, zero_method, correction, ...])	计算 Wilcoxon 符号秩检验。

关联/相关性检验

这些检验通常用于评估多个样本中配对观测值之间或多变量观测值坐标之间是否存在关系（例如线性关系）。

linregress(x[, y, alternative])	计算两组测量值的线性最小二乘回归。
pearsonr(x, y, *[, alternative, method])	Pearson 相关系数和用于测试非相关性的 p 值。
spearmanr(a[, b, axis, nan_policy, alternative])	计算具有相关 p 值的 Spearman 相关系数。
pointbiserialr(x, y)	计算一点双列相关系数及其 p 值。
kendalltau(x, y, *[, initial_lexsort, ...])	计算 Kendall's tau，一种用于有序数据的相关度量。
weightedtau(x, y[, rank, weigher, additive])	计算 Kendall's (\tau)的加权版本。
somersd(x[, y, alternative])	计算 Somers' D，一种有序关联的非对称度量。
siegelslopes(y[, x, method])	计算一组点（x，y）的 Siegel 估计量。
theilslopes(y[, x, alpha, method])	计算一组点（x，y）的 Theil-Sen 估计量。
page_trend_test(data[, ranked, ...])	执行 Page 趋势检验，用于衡量不同处理之间的观测趋势。
multiscale_graphcorr(x, y[, ...])	计算多尺度图相关性（MGC）检验统计量。

这些关联性检验用于处理列联表样本。支持函数可在scipy.stats.contingency中找到。

chi2_contingency(observed[, correction, lambda_])	在列联表中检验变量的独立性的卡方检验。
fisher_exact(table[, alternative])	在 2x2 列联表上执行 Fisher 精确检验。
barnard_exact(table[, alternative, pooled, n])	在 2x2 列联表上执行 Barnard 精确检验。
boschloo_exact(table[, alternative, n])	在 2x2 列联表上执行 Boschloo 精确检验。

独立样本检验

独立样本检验通常用于评估多个样本是否独立地从相同分布或具有共同属性（例如均值相等的不同分布）中抽取。

有些测试特别用于比较两个样本。

ttest_ind_from_stats(mean1, std1, nobs1, ...)	根据描述统计量对两个独立样本的均值进行 T 检验。
poisson_means_test(k1, n1, k2, n2, *[, ...])	执行泊松均值检验，也称为"E-test"。
ttest_ind(a, b[, axis, equal_var, ...])	计算两个独立样本的 T 检验得分。
mannwhitneyu(x, y[, use_continuity, ...])	对两个独立样本执行 Mann-Whitney U 秩和检验。
bws_test(x, y, *[, alternative, method])	对两个独立样本执行 Baumgartner-Weiss-Schindler 测试。
ranksums(x, y[, alternative, axis, ...])	计算威尔科克森秩和检验统计量，适用于两个样本。
brunnermunzel(x, y[, alternative, ...])	计算布伦纳-门泽尔（Brunner-Munzel）检验，适用于样本 x 和 y。
mood(x, y[, axis, alternative])	执行穆德（Mood）检验以检验尺度参数的等性。
ansari(x, y[, alternative, axis, ...])	执行安萨里-布拉德利检验（Ansari-Bradley test）以检验尺度参数的等性。
cramervonmises_2samp(x, y[, method, axis, ...])	执行双样本克拉默-冯·米泽斯检验（Cramér-von Mises test）。
epps_singleton_2samp(x, y[, t, axis, ...])	计算艾普斯-辛格尔顿（Epps-Singleton，ES）检验统计量。
ks_2samp(data1, data2[, alternative, ...])	执行双样本科尔莫哥洛夫-斯米尔诺夫（Kolmogorov-Smirnov）检验。
kstest(rvs, cdf[, args, N, alternative, ...])	执行（单样本或双样本）科尔莫哥洛夫-斯米尔诺夫（Kolmogorov-Smirnov）检验。

其他测试方法适用于多个样本。

f_oneway(*samples[, axis])	执行单因素方差分析（one-way ANOVA）。
tukey_hsd(*args)	执行图基（Tukey）的 HSD 检验，用于比较多个处理的均值是否相等。
dunnett(*samples, control[, alternative, ...])	执行邓纳特（Dunnett）检验，对多个样本均值与控制组进行多重比较。
kruskal(*samples[, nan_policy, axis, keepdims])	计算克鲁斯卡尔-沃利斯（Kruskal-Wallis H-test）独立样本的检验。
alexandergovern(*samples[, nan_policy])	执行亚历山大·戈弗恩检验（Alexander Govern test）。
fligner(*samples[, center, proportiontocut, ...])	执行弗里格纳-基林检验（Fligner-Killeen test）以检验方差的等性。
levene(*samples[, center, proportiontocut, ...])	执行莱文检验（Levene test）以检验方差的等性。
bartlett(*samples[, axis, nan_policy, keepdims])	执行巴特利特等方差检验。
median_test(*samples[, ties, correction, ...])	执行穆德中位数检验。
friedmanchisquare(*samples)	计算重复样本的弗里德曼检验。
anderson_ksamp(samples[, midrank, method])	k-样本的安德森-达宁检验。

重抽样和蒙特卡洛方法

下面的函数可以重现大多数上述函数的 p 值和置信区间结果，并且通常能在更广泛的条件下产生准确的结果。它们还可以用于执行假设检验并为自定义统计量生成置信区间。这种灵活性的代价是更高的计算需求和随机结果。

monte_carlo_test(data, rvs, statistic, *[, ...])	执行蒙特卡洛假设检验。
permutation_test(data, statistic, *[, ...])	在提供的数据上执行置换检验。
bootstrap(data, statistic, *[, n_resamples, ...])	计算统计量的双侧自举置信区间。

可以将以下对象的实例传递给一些假设检验函数，以执行假设检验的重抽样或蒙特卡洛版本。

MonteCarloMethod([n_resamples, batch, rvs])	蒙特卡洛假设检验的配置信息。
PermutationMethod([n_resamples, batch, ...])	排列假设检验的配置信息。
BootstrapMethod([n_resamples, batch, ...])	用于计算自举置信区间的配置信息。

多重假设检验和元分析

这些函数用于全面评估单个测试的结果。执行特定的多重假设检验（例如事后检验）的函数在上面列出。

combine_pvalues(pvalues[, method, weights])	从影响相同假设的独立测试中合并 p 值。
false_discovery_control(ps, *[, axis, method])	调整 p 值以控制假发现率。

下列函数与上述测试相关，但不属于上述分类。

准蒙特卡洛

• 准蒙特卡洛子模块 (scipy.stats.qmc)

  • 准蒙特卡洛

    • 引擎

      • scipy.stats.qmc.QMCEngine

      • scipy.stats.qmc.Sobol

      • scipy.stats.qmc.Halton

      • scipy.stats.qmc.LatinHypercube

      • scipy.stats.qmc.PoissonDisk

      • scipy.stats.qmc.MultinomialQMC

      • scipy.stats.qmc.MultivariateNormalQMC

    • 辅助工具

      • scipy.stats.qmc.discrepancy

      • scipy.stats.qmc.geometric_discrepancy

      • scipy.stats.qmc.update_discrepancy

      • scipy.stats.qmc.scale

  • 介绍准蒙特卡洛

    • 参考文献

列联表

• 列联表函数 (scipy.stats.contingency)

  • scipy.stats.contingency.chi2_contingency

    • chi2_contingency

  • scipy.stats.contingency.relative_risk

    • relative_risk

  • scipy.stats.contingency.odds_ratio

    • odds_ratio

  • scipy.stats.contingency.crosstab

    • crosstab

  • scipy.stats.contingency.association

    • association

  • scipy.stats.contingency.expected_freq

    • expected_freq

  • scipy.stats.contingency.margins

    • margins

遮罩统计函数

• 掩模数组的统计函数 (scipy.stats.mstats)

  • 摘要统计

    • scipy.stats.mstats.describe

      • describe

    • scipy.stats.mstats.gmean

      • gmean

    • scipy.stats.mstats.hmean

      • hmean

    • scipy.stats.mstats.kurtosis

      • kurtosis

    • scipy.stats.mstats.mode

      • mode

    • scipy.stats.mstats.mquantiles

      • mquantiles

    • scipy.stats.mstats.hdmedian

      • hdmedian

    • scipy.stats.mstats.hdquantiles

      • hdquantiles

    • scipy.stats.mstats.hdquantiles_sd

      • hdquantiles_sd

    • scipy.stats.mstats.idealfourths

      • idealfourths

    • scipy.stats.mstats.plotting_positions

      • plotting_positions

    • scipy.stats.mstats.meppf

      • meppf

    • scipy.stats.mstats.moment

      • moment

    • scipy.stats.mstats.skew

      • skew

    • scipy.stats.mstats.tmean

      • tmean

    • scipy.stats.mstats.tvar

      • tvar

    • scipy.stats.mstats.tmin

      • tmin

    • scipy.stats.mstats.tmax

      • tmax

    • scipy.stats.mstats.tsem

      • tsem

    • scipy.stats.mstats.variation

      • variation

    • scipy.stats.mstats.find_repeats

      • find_repeats

    • scipy.stats.mstats.sem

      • sem

    • scipy.stats.mstats.trimmed_mean

      • trimmed_mean

    • scipy.stats.mstats.trimmed_mean_ci

      • trimmed_mean_ci

    • scipy.stats.mstats.trimmed_std

      • trimmed_std

    • scipy.stats.mstats.trimmed_var

      • trimmed_var

  • 频率统计

    • scipy.stats.mstats.scoreatpercentile

      • scoreatpercentile

  • 相关函数

    • scipy.stats.mstats.f_oneway

      • f_oneway

    • scipy.stats.mstats.pearsonr

      • pearsonr

    • scipy.stats.mstats.spearmanr

      • spearmanr

    • scipy.stats.mstats.pointbiserialr

      • pointbiserialr

    • scipy.stats.mstats.kendalltau

      • kendalltau

    • scipy.stats.mstats.kendalltau_seasonal

      • kendalltau_seasonal

    • scipy.stats.mstats.linregress

      • linregress

    • scipy.stats.mstats.siegelslopes

      • siegelslopes

    • scipy.stats.mstats.theilslopes

      • theilslopes

    • scipy.stats.mstats.sen_seasonal_slopes

      • sen_seasonal_slopes

  • Statistical tests

    • scipy.stats.mstats.ttest_1samp

      • ttest_1samp

    • scipy.stats.mstats.ttest_onesamp

      • ttest_onesamp

    • scipy.stats.mstats.ttest_ind

      • ttest_ind

    • scipy.stats.mstats.ttest_rel

      • ttest_rel

    • scipy.stats.mstats.chisquare

      • chisquare

    • scipy.stats.mstats.kstest

      • kstest

    • scipy.stats.mstats.ks_2samp

      • ks_2samp

    • scipy.stats.mstats.ks_1samp

      • ks_1samp

    • scipy.stats.mstats.ks_twosamp

      • ks_twosamp

    • scipy.stats.mstats.mannwhitneyu

      • mannwhitneyu

    • scipy.stats.mstats.rankdata

      • rankdata

    • scipy.stats.mstats.kruskal

      • kruskal

    • scipy.stats.mstats.kruskalwallis

      • kruskalwallis

    • scipy.stats.mstats.friedmanchisquare

      • friedmanchisquare

    • scipy.stats.mstats.brunnermunzel

      • brunnermunzel

    • scipy.stats.mstats.skewtest

      • skewtest

    • scipy.stats.mstats.kurtosistest

      • kurtosistest

    • scipy.stats.mstats.normaltest

      • normaltest

  • Transformations

    • scipy.stats.mstats.obrientransform

      • obrientransform

    • scipy.stats.mstats.trim

      • trim

    • scipy.stats.mstats.trima

      • trima

    • scipy.stats.mstats.trimmed_stde

      • trimmed_stde

    • scipy.stats.mstats.trimr

      • trimr

    • scipy.stats.mstats.trimtail

      • trimtail

    • scipy.stats.mstats.trimboth

      • trimboth

    • scipy.stats.mstats.winsorize

      • winsorize

    • scipy.stats.mstats.zmap

      • zmap

    • scipy.stats.mstats.zscore

      • zscore

  • Other

    • scipy.stats.mstats.argstoarray

      • argstoarray

    • scipy.stats.mstats.count_tied_groups

      • count_tied_groups

    • scipy.stats.mstats.msign

      • msign

    • scipy.stats.mstats.compare_medians_ms

      • compare_medians_ms

    • scipy.stats.mstats.median_cihs

      • median_cihs

    • scipy.stats.mstats.mjci

      • mjci

    • scipy.stats.mstats.mquantiles_cimj

      • mquantiles_cimj

    • scipy.stats.mstats.rsh

      • rsh

其他统计功能

变换

boxcox(x[, lmbda, alpha, optimizer])	返回经 Box-Cox 幂变换后的数据集。
boxcox_normmax(x[, brack, method, optimizer])	计算输入数据的最佳 Box-Cox 变换参数。
boxcox_llf(lmb, data)	Box-Cox 对数似然函数。
yeojohnson(x[, lmbda])	返回经 Yeo-Johnson 幂变换后的数据集。
yeojohnson_normmax(x[, brack])	计算最佳 Yeo-Johnson 变换参数。
yeojohnson_llf(lmb, data)	Yeo-Johnson 对数似然函数。
obrientransform(*samples)	对输入数据执行 O'Brien 变换（任意数量的数组）。
sigmaclip(a[, low, high])	执行数组元素的迭代 sigma-clipping。
trimboth(a, proportiontocut[, axis])	从数组的两端切掉一定比例的项目。
trim1(a, proportiontocut[, tail, axis])	从数组分布的一个端切掉一定比例。
zmap(scores, compare[, axis, ddof, nan_policy])	计算相对 z 分数。
zscore(a[, axis, ddof, nan_policy])	计算 z 分数。
gzscore(a, *[, axis, ddof, nan_policy])	计算几何标准分数。

统计距离

wasserstein_distance(u_values, v_values[, ...])	计算两个 1D 分布之间的 Wasserstein 距离。
energy_distance(u_values, v_values[, ...])	计算两个 1D 分布之间的能量距离。

抽样

• Random Number Generators (scipy.stats.sampling)

  • 包装的生成器

    • 连续分布

      • scipy.stats.sampling.NumericalInverseHermite

      • scipy.stats.sampling.NumericalInversePolynomial

      • scipy.stats.sampling.TransformedDensityRejection

      • scipy.stats.sampling.SimpleRatioUniforms

      • scipy.stats.sampling.RatioUniforms

    • 离散分布

      • scipy.stats.sampling.DiscreteAliasUrn

      • scipy.stats.sampling.DiscreteGuideTable

    • 在 scipy.stats.sampling 中使用的警告/错误

      • scipy.stats.sampling.UNURANError

  • 预定义分布的生成器

    • scipy.stats.sampling.FastGeneratorInversion

      • FastGeneratorInversion

      • scipy.stats.sampling.FastGeneratorInversion.evaluate_error

      • scipy.stats.sampling.FastGeneratorInversion.ppf

      • scipy.stats.sampling.FastGeneratorInversion.qrvs

      • scipy.stats.sampling.FastGeneratorInversion.rvs

      • scipy.stats.sampling.FastGeneratorInversion.support

随机变量生成/累积分布函数反转

rvs_ratio_uniforms(pdf, umax, vmin, vmax[, ...])	使用比例-均匀分布方法从概率密度函数生成随机样本。

拟合/生存分析

fit(dist, data[, bounds, guess, method, ...])	将离散或连续分布拟合到数据。
ecdf(sample)	样本的经验累积分布函数。
logrank(x, y[, alternative])	通过对数秩检验比较两个样本的生存分布。

方向统计函数

directional_stats(samples, *[, axis, normalize])	计算方向数据的样本统计量。
circmean(samples[, high, low, axis, ...])	计算假定在范围内的样本的圆形平均值。
circvar(samples[, high, low, axis, ...])	计算假定在范围内的样本的圆形方差。
circstd(samples[, high, low, axis, ...])	计算假定在范围 [low to high] 内的样本的圆形标准差。

敏感性分析

sobol_indices(*, func, n[, dists, method, ...])	Sobol' 的全局敏感性指数。

绘图检验

ppcc_max(x[, brack, dist])	计算最大化 PPCC 的形状参数。
ppcc_plot(x, a, b[, dist, plot, N])	计算并可选择绘制概率图相关系数。
probplot(x[, sparams, dist, fit, plot, rvalue])	计算概率图的分位数，并可选择显示图。
boxcox_normplot(x, la, lb[, plot, N])	计算 Box-Cox 正态性图的参数，可选择显示。
yeojohnson_normplot(x, la, lb[, plot, N])	计算 Yeo-Johnson 正态性图的参数，可选择显示。

单变量和多变量核密度估计

gaussian_kde(dataset[, bw_method, weights])	使用高斯核估计的核密度估计的表示。

在 scipy.stats 中使用的警告/错误

DegenerateDataWarning([msg])	当数据退化且结果可能不可靠时发出警告。
ConstantInputWarning([msg])	当数据中的所有值完全相等时发出警告。
NearConstantInputWarning([msg])	当数据中的所有值几乎相等时发出警告。
FitError([msg])	表示将分布拟合到数据时的错误条件。

在 scipy.stats 中使用的结果类

警告

这些类是私有的，但在这里包含它们是因为其他统计函数返回它们的实例。不支持用户导入和实例化。

• 结果类

  • scipy.stats._result_classes.RelativeRiskResult

  • scipy.stats._result_classes.BinomTestResult

  • scipy.stats._result_classes.TukeyHSDResult

  • scipy.stats._result_classes.DunnettResult

  • scipy.stats._result_classes.PearsonRResult

  • scipy.stats._result_classes.FitResult

  • scipy.stats._result_classes.OddsRatioResult

  • scipy.stats._result_classes.TtestResult

  • scipy.stats._result_classes.ECDFResult

  • scipy.stats._result_classes.EmpiricalDistributionFunction

scipy.stats.rv_continuous

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

class scipy.stats.rv_continuous(momtype=1, a=None, b=None, xtol=1e-14, badvalue=None, name=None, longname=None, shapes=None, seed=None)

用于派生的通用连续随机变量类。

rv_continuous 是一个基类，用于构建连续随机变量的具体分布类和实例。不能直接作为分布使用。

参数：

momtypeint, optional

用于使用的通用矩计算类型：0 表示概率密度函数（pdf），1（默认）表示累积分布函数（ppf）。

afloat, optional

分布的下支撑界限，默认为负无穷。

bfloat, optional

分布的上支撑界限，默认为正无穷。

xtolfloat, optional

用于通用累积分布函数计算的固定点计算容差。

badvaluefloat, optional

结果数组中指示违反某些参数限制的值，默认为 np.nan。

namestr, optional

实例的名称。该字符串用于构建分布的默认示例。

longnamestr, optional

该字符串用作当子类没有自己的文档字符串时返回的文档字符串的第一行的一部分。注意：longname 存在于向后兼容性中，不要用于新的子类。

shapesstr, optional

分布的形状。例如，对于一个需要两个整数作为其两个形状参数的分布，形状可以是 "m, n"。如果未提供，形状参数将从私有方法 _pdf 和 _cdf 的签名中推断。

seed{None, int, numpy.random.Generator, numpy.random.RandomState}, optional

如果 seed 为 None（或 np.random），则使用 numpy.random.RandomState 单例。如果 seed 是整数，则使用一个新的 RandomState 实例，并使用 seed 进行种子化。如果 seed 已经是 Generator 或 RandomState 实例，则使用该实例。

注意事项

分布类实例的公共方法（例如 pdf、cdf）检查其参数，并将有效的参数传递给私有的计算方法（例如 _pdf、_cdf）。对于 pdf(x)，如果 x 在分布的支撑范围内，则认为是有效的。形状参数是否有效由 _argcheck 方法决定（默认为检查其参数是否严格为正数）。

子类化

可通过子类化rv_continuous类并至少重新定义_pdf或_cdf方法（归一化为位置 0 和比例 1）来定义新的随机变量。

如果对你的随机变量进行正参数检查不正确，则还需要重新定义_argcheck方法。

对于大多数 scipy.stats 分布，支持区间不依赖于形状参数。x位于支持区间内等同于self.a <= x <= self.b。如果支持端点中的任一端点取决于形状参数，则 i）分布必须实现_get_support方法；和 ii）这些依赖端点必须从分布调用rv_continuous初始化器中省略。

正确，但可能缓慢的默认值适用于其余方法，但为了速度和/或准确性，可以重写：

_logpdf, _cdf, _logcdf, _ppf, _rvs, _isf, _sf, _logsf 

默认方法_rvs依赖于 cdf 的逆_ppf，应用于均匀随机变量。为了有效生成随机变量，可以重新定义默认的_ppf（例如，如果逆 cdf 可以用显式形式表示），或者在自定义的_rvs方法中实现抽样方法。

如果可能的话，应该重写_isf、_sf或_logsf。主要原因是为了提高数值精度：例如，生存函数_sf计算为1 - _cdf，如果_cdf(x)接近于 1，则可能会丢失精度。

可由子类重写的方法

_rvs
_pdf
_cdf
_sf
_ppf
_isf
_stats
_munp
_entropy
_argcheck
_get_support 

存在额外的（内部和私有的）通用方法，用于交叉检查和调试，但在直接调用时可能在所有情况下都有效。

关于shapes的说明：子类无需显式指定它们。在这种情况下，shapes将从覆盖方法的签名中自动推断出来（pdf、cdf等）。如果因某种原因你希望避免依赖内省，你可以在实例构造函数中将shapes明确指定为参数。

冻结分布

通常情况下，必须为每次调用分布方法提供形状参数（以及可选的位置和比例参数）。

或者，可以通过调用对象（作为函数）来固定形状、位置和比例参数，返回一个“冻结”的连续随机变量对象：

rv = generic(<shape(s)>, loc=0, scale=1)

rv_frozen对象具有相同的方法，但固定给定的形状、位置和比例

统计

统计数据默认使用数值积分计算。为了提速，可以重新定义使用_stats：

• 获取形状参数并返回 mu、mu2、g1、g2
• 如果无法计算其中之一，请将其返回为 None
• 也可以使用关键字参数 moments 进行定义，它是由 “m”、“v”、“s” 和/或 “k” 组成的字符串。只有出现在字符串中的组件才会被计算并按照 “m”、“v”、“s” 或 “k”的顺序返回，缺失值将返回为 None。

或者，您可以重写 _munp，它接受 n 和形状参数，并返回分布的第 n 个非中心矩。

深复制 / Pickling

如果分布或冻结分布进行了深复制（如进行了 pickle/unpickle 操作等），则任何底层随机数生成器也将被一同深复制。一个推论是，如果在复制前分布依赖于单例的随机状态，那么在复制后它将依赖于该随机状态的一个副本，并且np.random.seed将不再控制该状态。

示例

要创建一个新的高斯分布，我们将执行以下操作：

>>> from scipy.stats import rv_continuous
>>> class gaussian_gen(rv_continuous):
...     "Gaussian distribution"
...     def _pdf(self, x):
...         return np.exp(-x**2 / 2.) / np.sqrt(2.0 * np.pi)
>>> gaussian = gaussian_gen(name='gaussian') 

scipy.stats 分布是 实例，因此我们在这里子类化 rv_continuous 并创建一个实例。通过这样做，我们现在拥有一个由框架自动生成的具有所有相关方法的完全功能分布。

请注意，上面我们定义了一个标准正态分布，具有零均值和单位方差。通过使用 loc 和 scale 参数可以进行分布的移动和缩放：gaussian.pdf(x, loc, scale) 本质上计算 y = (x - loc) / scale 和 gaussian._pdf(y) / scale。

属性：

random_state

获取或设置用于生成随机变量的生成器对象。

方法

rvs(*args, **kwds)	给定类型的随机变量。
pdf(x, *args, **kwds)	给定随机变量的概率密度函数在 x 处的值。
logpdf(x, *args, **kwds)	给定随机变量的概率密度函数在 x 处的对数。
cdf(x, *args, **kwds)	给定随机变量的累积分布函数。
logcdf(x, *args, **kwds)	给定随机变量的累积分布函数在 x 处的对数。
sf(x, *args, **kwds)	给定随机变量的生存函数（1 - cdf）。
logsf(x, *args, **kwds)	给定 RV 的生存函数的对数。
ppf(q, *args, **kwds)	给定 RV 的累积分布函数（cdf 的反函数）的百分点函数在 q 处。
isf(q, *args, **kwds)	给定 RV 的逆生存函数（sf 的逆函数）在 q 处。
moment(order, *args, **kwds)	指定阶数的分布的非中心矩。
stats(*args, **kwds)	给定 RV 的一些统计量。
entropy(*args, **kwds)	RV 的微分熵。
expect([func, args, loc, scale, lb, ub, ...])	通过数值积分计算函数相对于分布的期望值。
median(*args, **kwds)	分布的中位数。
mean(*args, **kwds)	分布的均值。
std(*args, **kwds)	分布的标准差。
var(*args, **kwds)	分布的方差。
interval(confidence, *args, **kwds)	置信区间，围绕中位数有相等的区域。
__call__(*args, **kwds)	冻结给定参数的分布。
fit(data, *args, **kwds)	返回数据的形状（如果适用）、位置和尺度参数的估计值。
fit_loc_scale(data, *args)	使用数据的第一和第二时刻估计 loc 和 scale 参数。
nnlf(theta, x)	负对数似然函数。
support(*args, **kwargs)	分布的支持区间。

scipy.stats.rv_discrete

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

class scipy.stats.rv_discrete(a=0, b=inf, name=None, badvalue=None, moment_tol=1e-08, values=None, inc=1, longname=None, shapes=None, seed=None)

一个通用的离散随机变量类，用于派生子类。

rv_discrete 是一个基类，用于构造特定的分布类和离散随机变量实例。它也可以用于根据支持点列表和对应概率构造任意分布。

参数：

a浮点数, 可选

分布的支持下限，默认为 0

b浮点数, 可选

分布的支持上限，默认为正无穷大

moment_tol浮点数, 可选

用于通用矩计算的容差。

values两个 array_like 元组, 可选

(xk, pk) 其中 xk 是整数，pk 是介于 0 和 1 之间的非零概率，满足 sum(pk) = 1。xk 和 pk 必须具有相同的形状，并且 xk 必须是唯一的。

inc整数, 可选

分布支持的增量。默认为 1.（未测试其他值）

badvalue浮点数, 可选

结果数组中指示某些参数限制违规值的值，默认为 np.nan。

name字符串, 可选

实例的名称。此字符串用于构造分布的默认示例。

longname字符串, 可选

此字符串用作在子类没有自己的文档字符串时返回的文档字符串的第一行的一部分。注意：longname 仅用于向后兼容性，不要用于新的子类。

shapes字符串, 可选

分布的形状。例如，“m, n” 表示一个接受两个整数作为其所有方法的两个形状参数的分布。如果未提供，形状参数将从实例的私有方法 _pmf 和 _cdf 的签名中推断。

seed{None, int, numpy.random.Generator, numpy.random.RandomState}, 可选

如果 seed 为 None（或 np.random），则使用 numpy.random.RandomState 单例。如果 seed 是整数，则使用一个新的 RandomState 实例，并使用 seed 进行种子初始化。如果 seed 已经是 Generator 或 RandomState 实例，则直接使用该实例。

注：

这个类类似于 rv_continuous。是否有效的形状参数由 _argcheck 方法决定（默认为检查其参数是否严格为正）。主要区别如下。

• 分布的支持是一组整数。

• 与概率密度函数 pdf（及其对应的私有 _pdf）不同，这个类定义了概率质量函数 pmf（及其对应的私有 _pmf）。

• 没有 scale 参数。

• 方法（例如 _cdf）的默认实现不适用于支持无下限的分布（即 a=-np.inf），因此必须进行覆盖。

要创建一个新的离散分布，我们需要执行以下操作：

>>> from scipy.stats import rv_discrete
>>> class poisson_gen(rv_discrete):
...     "Poisson distribution"
...     def _pmf(self, k, mu):
...         return exp(-mu) * mu**k / factorial(k) 

并创建一个实例：

>>> poisson = poisson_gen(name="poisson") 

请注意，上面我们定义了标准形式的泊松分布。通过在实例方法中提供 loc 参数，可以进行分布的偏移。例如，poisson.pmf(x, mu, loc) 将工作委托给 poisson._pmf(x-loc, mu)。

从概率列表创建离散分布

或者，您可以使用 values 关键字参数来构造定义在有限值集合 xk 上的任意离散随机变量 Prob{X=xk} = pk，方法是使用 rv_discrete 构造函数。

Deepcopying / Pickling

如果分布或冻结分布进行了深拷贝（序列化/反序列化等），则任何底层随机数生成器也将随之深拷贝。其含义是，如果分布在复制之前依赖于单例的 RandomState，则在复制后它将依赖于该随机状态的副本，并且 np.random.seed 将不再控制状态。

示例

自定义离散分布：

>>> import numpy as np
>>> from scipy import stats
>>> xk = np.arange(7)
>>> pk = (0.1, 0.2, 0.3, 0.1, 0.1, 0.0, 0.2)
>>> custm = stats.rv_discrete(name='custm', values=(xk, pk))
>>>
>>> import matplotlib.pyplot as plt
>>> fig, ax = plt.subplots(1, 1)
>>> ax.plot(xk, custm.pmf(xk), 'ro', ms=12, mec='r')
>>> ax.vlines(xk, 0, custm.pmf(xk), colors='r', lw=4)
>>> plt.show() 

随机数生成：

>>> R = custm.rvs(size=100) 

属性：

random_state

获取或设置用于生成随机变量的生成器对象。

方法

rvs(*args, **kwargs)	给定类型的随机变量。
pmf(k, *args, **kwds)	给定随机变量在 k 处的概率质量函数。
logpmf(k, *args, **kwds)	给定随机变量在 k 处的概率质量函数的对数。
cdf(k, *args, **kwds)	给定随机变量的累积分布函数。
logcdf(k, *args, **kwds)	给定随机变量在 k 处的累积分布函数的对数。
sf(k, *args, **kwds)	给定随机变量在 k 处的生存函数（1 - cdf）。
logsf(k, *args, **kwds)	给定随机变量的生存函数的对数。
ppf(q, *args, **kwds)	给定随机变量在 q 处的百分点函数（cdf的逆函数）。
isf(q, *args, **kwds)	给定随机变量在 q 处的逆生存函数（sf的逆函数）。
moment(order, *args, **kwds)	指定阶数的分布的非中心矩。
stats	给定随机变量的一些统计量。
entropy	随机变量的微分熵。
expect([func, args, loc, lb, ub, ...])	对于离散分布，通过数值求和计算函数关于分布的期望值。
median	分布的中位数。
mean	分布的均值。
std	分布的标准差。
var	分布的方差。
interval(confidence, *args, **kwds)	等面积置信区间，围绕中位数。
__call__(*args, **kwds)	对给定参数冻结分布。
support(*args, **kwargs)	分布的支持范围。

scipy.stats.rv_histogram

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

class scipy.stats.rv_histogram(histogram, *args, density=None, **kwargs)

生成由直方图给定的分布。这对于从分箱数据样本生成模板分布非常有用。

作为rv_continuous类的子类，rv_histogram从中继承了一系列通用方法（请参阅rv_continuous以获取完整列表），并根据提供的分箱数据样本的特性实现了这些方法。

参数：

histogramarray_like 的元组

包含两个 array_like 对象的元组。第一个包含 n 个箱的内容，第二个包含（n+1）个箱边界。特别地，接受numpy.histogram的返回值。

densitybool，可选

如果为 False，则假定直方图与每个箱中的计数成比例；否则，假定其与密度成比例。对于常数箱宽度，这两者是等效的，但在箱宽度变化时区分是重要的（见注释）。如果为 None（默认），则为向后兼容性设置density=True，但如果箱宽度可变，则发出警告。显式设置density以消除警告。

1.10.0 版本中的新功能。

笔记

当直方图具有不等的箱宽度时，统计学上有区分，即与每个箱中的计数成比例的直方图和与每个箱上的概率密度成比例的直方图。如果用其默认的density=False调用numpy.histogram，则生成的直方图是每个箱中的计数，因此应将density=False传递给rv_histogram。如果用density=True调用numpy.histogram，则生成的直方图是以概率密度为单位的，因此应将density=True传递给rv_histogram。为了避免警告，在输入直方图具有不等箱宽度时，始终显式传递density。

除了 loc 和 scale 之外，没有额外的形状参数。 pdf 被定义为从提供的直方图的分段函数。 cdf 是 pdf 的线性插值。

0.19.0 版本中的新功能。

示例

从 numpy 直方图创建一个 scipy.stats 分布

>>> import scipy.stats
>>> import numpy as np
>>> data = scipy.stats.norm.rvs(size=100000, loc=0, scale=1.5,
...                             random_state=123)
>>> hist = np.histogram(data, bins=100)
>>> hist_dist = scipy.stats.rv_histogram(hist, density=False) 

表现得像一个普通的 scipy rv_continuous 分布

>>> hist_dist.pdf(1.0)
0.20538577847618705
>>> hist_dist.cdf(2.0)
0.90818568543056499 

PDF 在直方图的最高（最低）箱子之上（之下）为零，由原始数据集的最大（最小）定义

>>> hist_dist.pdf(np.max(data))
0.0
>>> hist_dist.cdf(np.max(data))
1.0
>>> hist_dist.pdf(np.min(data))
7.7591907244498314e-05
>>> hist_dist.cdf(np.min(data))
0.0 

PDF 和 CDF 遵循直方图

>>> import matplotlib.pyplot as plt
>>> X = np.linspace(-5.0, 5.0, 100)
>>> fig, ax = plt.subplots()
>>> ax.set_title("PDF from Template")
>>> ax.hist(data, density=True, bins=100)
>>> ax.plot(X, hist_dist.pdf(X), label='PDF')
>>> ax.plot(X, hist_dist.cdf(X), label='CDF')
>>> ax.legend()
>>> fig.show() 

属性：

random_state

获取或设置用于生成随机变量的生成器对象。

方法：

__call__	固定给定参数的分布。
cdf	给定随机变量的累积分布函数。
entropy	随机变量的微分熵。
expect	使用数值积分计算分布函数对某个函数的期望值。
fit	从数据中返回形状（如果适用）、位置和尺度参数的估计。
fit_loc_scale	利用数据的第一和第二阶矩估计 loc 和 scale 参数。
freeze	固定给定参数的分布。
interval	中位数周围等面积的置信区间。
isf	给定随机变量的逆生存函数（给定 sf 的逆函数）在 q 处的值。
logcdf	给定随机变量 x 的累积分布函数的对数。
logpdf	给定随机变量 x 的概率密度函数的对数。
logsf	给定随机变量的生存函数的对数。
mean(*args, **kwds)	分布的均值。
median(*args, **kwds)	分布的中位数。
moment(order, *args, **kwds)	分布的非中心矩。
nnlf(theta, x)	负对数似然函数。
pdf(x, *args, **kwds)	给定随机变量在 x 处的概率密度函数。
ppf(q, *args, **kwds)	给定随机变量的百分点函数（cdf 的反函数），在 q 处的值。
rvs(*args, **kwds)	给定类型的随机变量。
sf(x, *args, **kwds)	给定随机变量的生存函数（1 - cdf）在 x 处的值。
stats(*args, **kwds)	给定随机变量的一些统计量。
std(*args, **kwds)	分布的标准差。
support(*args, **kwargs)	分布的支持区间。
var(*args, **kwds)	分布的方差。

scipy.stats.alpha

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

scipy.stats.alpha = <scipy.stats._continuous_distns.alpha_gen object>

一个阿尔法连续随机变量。

作为rv_continuous类的一个实例，alpha对象继承了一组通用方法（请参阅下面的完整列表），并使用特定于此特定分布的细节来完善它们。

注意事项

alpha的概率密度函数（[1]，[2]）为：

[f(x, a) = \frac{1}{x² \Phi(a) \sqrt{2\pi}} * \exp(-\frac{1}{2} (a-1/x)²)]

其中 (\Phi) 是正态分布函数，(x > 0)，(a > 0)。

alpha将 a 视为形状参数。

上述概率密度在“标准化”形式中定义。要移动和/或缩放分布，请使用 loc 和 scale 参数。具体而言，alpha.pdf(x, a, loc, scale) 在 y = (x - loc) / scale 的情况下等同于 alpha.pdf(y, a) / scale。请注意，移动分布的位置并不会使其成为“非中心”分布；某些分布的非中心广义化可以在单独的类中找到。

参考文献

[1]

Johnson, Kotz, 和 Balakrishnan，“Continuous Univariate Distributions, Volume 1”，第二版，John Wiley and Sons，第 173 页（1994 年）。

[2]

Anthony A. Salvia，“Alpha 分布的可靠性应用”，IEEE 可靠性期刊，Vol. R-34，No. 3，pp. 251-252（1985 年）。

示例

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

计算前四个矩：

>>> a = 3.57
>>> mean, var, skew, kurt = alpha.stats(a, moments='mvsk') 

显示概率密度函数（pdf）：

>>> x = np.linspace(alpha.ppf(0.01, a),
...                 alpha.ppf(0.99, a), 100)
>>> ax.plot(x, alpha.pdf(x, a),
...        'r-', lw=5, alpha=0.6, label='alpha pdf') 

或者，可以调用分布对象（作为函数）来固定形状、位置和比例参数。这会返回一个“冻结”的随机变量对象，其中给定的参数被固定。

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

>>> rv = alpha(a)
>>> ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf') 

检查 cdf 和 ppf 的准确性：

>>> vals = alpha.ppf([0.001, 0.5, 0.999], a)
>>> np.allclose([0.001, 0.5, 0.999], alpha.cdf(vals, a))
True 

生成随机数：

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

并比较直方图：

>>> ax.hist(r, density=True, bins='auto', histtype='stepfilled', alpha=0.2)
>>> ax.set_xlim([x[0], x[-1]])
>>> ax.legend(loc='best', frameon=False)
>>> plt.show() 

方法

rvs(a, loc=0, scale=1, size=1, random_state=None)	随机变量。
pdf(x, a, loc=0, scale=1)	概率密度函数。
logpdf(x, a, loc=0, scale=1)	概率密度函数的对数。
cdf(x, a, loc=0, scale=1)	累积分布函数。
logcdf(x, a, loc=0, scale=1)	累积分布函数的对数。
sf(x, a, loc=0, scale=1)	生存函数（也被定义为 1 - cdf，但 sf 有时更准确）。
logsf(x, a, loc=0, scale=1)	生存函数的对数。
ppf(q, a, loc=0, scale=1)	百分点函数（cdf的反函数 — 百分位数）。
isf(q, a, loc=0, scale=1)	逆生存函数（sf的逆函数）。
moment(order, a, loc=0, scale=1)	指定阶数的非中心矩。
stats(a, loc=0, scale=1, moments=’mv’)	均值（‘m’）、方差（‘v’）、偏度（‘s’）和/或峰度（‘k’）。
entropy(a, loc=0, scale=1)	随机变量的（微分）熵。
fit(data)	用于一般数据的参数估计。详见scipy.stats.rv_continuous.fit以获取关键字参数的详细文档。
**expect(func, args=(a,), loc=0, scale=1, lb=None, ub=None, conditional=False, kwds)	关于分布的一个参数函数（一个参数）的期望值。
median(a, loc=0, scale=1)	分布的中位数。
mean(a, loc=0, scale=1)	分布的均值。
var(a, loc=0, scale=1)	分布的方差。
std(a, loc=0, scale=1)	分布的标准差。
interval(confidence, a, loc=0, scale=1)	以中位数为中心的置信区间，区间内的面积相等。

scipy.stats.anglit

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

scipy.stats.anglit = <scipy.stats._continuous_distns.anglit_gen object>

一个 anglit 连续随机变量。

作为rv_continuous类的一个实例，anglit对象继承了一组通用方法（请参阅下面的完整列表），并根据此特定分布的详细信息完成它们。

注释

anglit的概率密度函数为：

[f(x) = \sin(2x + \pi/2) = \cos(2x)]

对于 (-\pi/4 \le x \le \pi/4)。

上述概率密度在“标准化”形式中定义。要移动和/或缩放分布，请使用loc和scale参数。具体来说，anglit.pdf(x, loc, scale)等同于 anglit.pdf(y) / scale，其中 y = (x - loc) / scale。请注意，移动分布的位置并不使其成为“非中心”分布；某些分布的非中心广义化是在单独的类中提供的。

示例

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

计算前四个时刻：

>>> mean, var, skew, kurt = anglit.stats(moments='mvsk') 

显示概率密度函数（pdf）：

>>> x = np.linspace(anglit.ppf(0.01),
...                 anglit.ppf(0.99), 100)
>>> ax.plot(x, anglit.pdf(x),
...        'r-', lw=5, alpha=0.6, label='anglit pdf') 

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

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

>>> rv = anglit()
>>> ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf') 

检查cdf和ppf的准确性：

>>> vals = anglit.ppf([0.001, 0.5, 0.999])
>>> np.allclose([0.001, 0.5, 0.999], anglit.cdf(vals))
True 

生成随机数：

>>> r = anglit.rvs(size=1000) 

并比较直方图：

>>> ax.hist(r, density=True, bins='auto', histtype='stepfilled', alpha=0.2)
>>> ax.set_xlim([x[0], x[-1]])
>>> ax.legend(loc='best', frameon=False)
>>> plt.show() 

方法

rvs(loc=0, scale=1, size=1, random_state=None)	随机变量。
pdf(x, loc=0, scale=1)	概率密度函数。
logpdf(x, loc=0, scale=1)	概率密度函数的对数。
cdf(x, loc=0, scale=1)	累积分布函数。
logcdf(x, loc=0, scale=1)	累积分布函数的对数。
sf(x, loc=0, scale=1)	生存函数（也定义为 1 - cdf，但有时sf更准确）。
logsf(x, loc=0, scale=1)	生存函数的对数。
ppf(q, loc=0, scale=1)	百分位点函数（cdf的反函数 —— 百分位数）。
isf(q, loc=0, scale=1)	逆生存函数（sf的逆）。
moment(order, loc=0, scale=1)	指定阶数的非中心矩。
stats(loc=0, scale=1, moments=’mv’)	均值（‘m’）、方差（‘v’）、偏度（‘s’）和/或峰度（‘k’）。
entropy(loc=0, scale=1)	随机变量的（微分）熵。
fit(data)	适用于一般数据的参数估计。详细文档参见scipy.stats.rv_continuous.fit。
**expect(func, args=(), loc=0, scale=1, lb=None, ub=None, conditional=False, kwds)	对分布中函数（一个参数）的期望值。
median(loc=0, scale=1)	分布的中位数。
mean(loc=0, scale=1)	分布的均值。
var(loc=0, scale=1)	分布的方差。
std(loc=0, scale=1)	分布的标准差。
interval(confidence, loc=0, scale=1)	置信区间，围绕中位数有相等的面积。

scipy.stats.arcsine

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

scipy.stats.arcsine = <scipy.stats._continuous_distns.arcsine_gen object>

一个正弦曲线的连续随机变量。

作为 rv_continuous 类的一个实例，arcsine 对象继承了一组通用方法（下面列出全部），并为特定分布的细节完善了这些方法。

注释

arcsine 的概率密度函数为：

[f(x) = \frac{1}{\pi \sqrt{x (1-x)}}]

对于 (0 < x < 1)。

上述概率密度在“标准化”形式中定义。使用 loc 和 scale 参数进行移位和/或缩放分布。具体而言，arcsine.pdf(x, loc, scale) 等同于 arcsine.pdf(y) / scale，其中 y = (x - loc) / scale。请注意，移动分布的位置并不使其成为“非中心”分布；一些分布的非中心推广可以在单独的类中找到。

示例

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

计算前四个矩：

>>> mean, var, skew, kurt = arcsine.stats(moments='mvsk') 

显示概率密度函数（pdf）：

>>> x = np.linspace(arcsine.ppf(0.01),
...                 arcsine.ppf(0.99), 100)
>>> ax.plot(x, arcsine.pdf(x),
...        'r-', lw=5, alpha=0.6, label='arcsine pdf') 

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

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

>>> rv = arcsine()
>>> ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf') 

检查cdf和ppf的准确性：

>>> vals = arcsine.ppf([0.001, 0.5, 0.999])
>>> np.allclose([0.001, 0.5, 0.999], arcsine.cdf(vals))
True 

生成随机数：

>>> r = arcsine.rvs(size=1000) 

并比较直方图：

>>> ax.hist(r, density=True, bins='auto', histtype='stepfilled', alpha=0.2)
>>> ax.set_xlim([x[0], x[-1]])
>>> ax.legend(loc='best', frameon=False)
>>> plt.show() 

方法

rvs(loc=0, scale=1, size=1, random_state=None)	随机变量。
pdf(x, loc=0, scale=1)	概率密度函数。
logpdf(x, loc=0, scale=1)	概率密度函数的对数。
cdf(x, loc=0, scale=1)	累积分布函数。
logcdf(x, loc=0, scale=1)	累积分布函数的对数。
sf(x, loc=0, scale=1)	生存函数（也定义为 1 - cdf，但sf有时更精确）。
logsf(x, loc=0, scale=1)	生存函数的对数。
ppf(q, loc=0, scale=1)	百分点函数（cdf 的逆 — 百分位数）。
isf(q, loc=0, scale=1)	逆生存函数（sf 的逆）。
moment(order, loc=0, scale=1)	指定阶数的非中心矩。
stats(loc=0, scale=1, moments=’mv’)	均值（‘m’）、方差（‘v’）、偏度（‘s’）和/或峰度（‘k’）。
entropy(loc=0, scale=1)	RV 的（微分）熵。
fit(data)	通用数据的参数估计值。详见scipy.stats.rv_continuous.fit以获取关键字参数的详细文档。
**expect(func, args=(), loc=0, scale=1, lb=None, ub=None, conditional=False, kwds)	对于分布的一个函数（一个参数）的期望值。
median(loc=0, scale=1)	分布的中位数。
mean(loc=0, scale=1)	分布的均值。
var(loc=0, scale=1)	分布的方差。
std(loc=0, scale=1)	分布的标准差。
interval(confidence, loc=0, scale=1)	置信区间，围绕中位数等面积。

scipy.stats.argus

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

scipy.stats.argus = <scipy.stats._continuous_distns.argus_gen object>

Argus 分布

作为 rv_continuous 类的一个实例，argus 对象继承了一组通用方法（请参阅下面的完整列表），并以此特定分布的详细信息补充它们。

注释

argus 的概率密度函数为：

[f(x, \chi) = \frac{\chi³}{\sqrt{2\pi} \Psi(\chi)} x \sqrt{1-x²} \exp(-\chi² (1 - x²)/2)]

对于 (0 < x < 1) 和 (\chi > 0)，其中

[\Psi(\chi) = \Phi(\chi) - \chi \phi(\chi) - 1/2]

其中 (\Phi) 和 (\phi) 分别是标准正态分布的 CDF 和 PDF。

argus 将 (\chi) 视为形状参数。

上述概率密度在“标准化”形式下定义。要移动和/或缩放分布，请使用 loc 和 scale 参数。具体而言，argus.pdf(x, chi, loc, scale) 等同于 argus.pdf(y, chi) / scale，其中 y = (x - loc) / scale。请注意，移动分布的位置并不使其成为“非中心”分布；某些分布的非中心推广可在单独的类中找到。

参考文献

[1]

“ARGUS 分布”，en.wikipedia.org/wiki/ARGUS_distribution

从版本 0.19.0 开始新增。

示例

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

计算前四阶矩：

>>> chi = 1
>>> mean, var, skew, kurt = argus.stats(chi, moments='mvsk') 

显示概率密度函数 (pdf)：

>>> x = np.linspace(argus.ppf(0.01, chi),
...                 argus.ppf(0.99, chi), 100)
>>> ax.plot(x, argus.pdf(x, chi),
...        'r-', lw=5, alpha=0.6, label='argus pdf') 

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

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

>>> rv = argus(chi)
>>> ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf') 

检查 cdf 和 ppf 的准确性：

>>> vals = argus.ppf([0.001, 0.5, 0.999], chi)
>>> np.allclose([0.001, 0.5, 0.999], argus.cdf(vals, chi))
True 

生成随机数：

>>> r = argus.rvs(chi, size=1000) 

并比较直方图：

>>> ax.hist(r, density=True, bins='auto', histtype='stepfilled', alpha=0.2)
>>> ax.set_xlim([x[0], x[-1]])
>>> ax.legend(loc='best', frameon=False)
>>> plt.show() 

方法

rvs(chi, loc=0, scale=1, size=1, random_state=None)	随机变量。
pdf(x, chi, loc=0, scale=1)	概率密度函数。
logpdf(x, chi, loc=0, scale=1)	概率密度函数的对数。
cdf(x, chi, loc=0, scale=1)	累积分布函数。
logcdf(x, chi, loc=0, scale=1)	累积分布函数的对数。
sf(x, chi, loc=0, scale=1)	生存函数（也定义为 1 - cdf，但 sf 有时更准确）。
logsf(x, chi, loc=0, scale=1)	生存函数的对数。
ppf(q, chi, loc=0, scale=1)	百分点函数（cdf 的反函数 — 百分位数）。
isf(q, chi, loc=0, scale=1)	逆生存函数（sf 的反函数）。
moment(order, chi, loc=0, scale=1)	指定阶数的非中心矩。
stats(chi, loc=0, scale=1, moments=’mv’)	均值（‘m’）、方差（‘v’）、偏度（‘s’）和/或峰度（‘k’）。
entropy(chi, loc=0, scale=1)	随机变量的（微分）熵。
fit(data)	通用数据的参数估计。详细文档请参见 scipy.stats.rv_continuous.fit。
**expect(func, args=(chi,), loc=0, scale=1, lb=None, ub=None, conditional=False, kwds)	函数期望值（一个参数）关于分布的。
median(chi, loc=0, scale=1)	分布的中位数。
mean(chi, loc=0, scale=1)	分布的均值。
var(chi, loc=0, scale=1)	分布的方差。
std(chi, loc=0, scale=1)	分布的标准差。
interval(confidence, chi, loc=0, scale=1)	置信区间，围绕中位数具有相等的面积。

scipy.stats.beta

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

scipy.stats.beta = <scipy.stats._continuous_distns.beta_gen object>

一个 beta 连续随机变量。

作为rv_continuous类的实例，beta对象继承了一组通用方法（下面详细列出），并且根据该特定分布补充了细节。

注意：

beta 的概率密度函数为：

[f(x, a, b) = \frac{\Gamma(a+b) x^{a-1} (1-x)^{b-1}} {\Gamma(a) \Gamma(b)}]

对于 (0 <= x <= 1), (a > 0), (b > 0)，其中 (\Gamma) 是 gamma 函数 (scipy.special.gamma)。

beta 接受(a)和(b)作为形状参数。

上述概率密度函数以“标准化”形式定义。使用 loc 和 scale 参数来进行移动和/或缩放分布。具体来说，beta.pdf(x, a, b, loc, scale) 与 beta.pdf(y, a, b) / scale 完全等价，其中 y = (x - loc) / scale。请注意，移动分布的位置并不会使其成为“非中心”分布；某些分布的非中心推广可以在单独的类中找到。

示例：

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

计算前四阶距：

>>> a, b = 2.31, 0.627
>>> mean, var, skew, kurt = beta.stats(a, b, moments='mvsk') 

显示概率密度函数 (pdf)：

>>> x = np.linspace(beta.ppf(0.01, a, b),
...                 beta.ppf(0.99, a, b), 100)
>>> ax.plot(x, beta.pdf(x, a, b),
...        'r-', lw=5, alpha=0.6, label='beta pdf') 

或者，可以通过调用分布对象（作为函数）来固定形状、位置和尺度参数。这会返回一个“冻结”的随机变量对象，其中包含给定的固定参数。

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

>>> rv = beta(a, b)
>>> ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf') 

检查 cdf 和 ppf 的精度：

>>> vals = beta.ppf([0.001, 0.5, 0.999], a, b)
>>> np.allclose([0.001, 0.5, 0.999], beta.cdf(vals, a, b))
True 

生成随机数：

>>> r = beta.rvs(a, b, size=1000) 

并比较直方图：

>>> ax.hist(r, density=True, bins='auto', histtype='stepfilled', alpha=0.2)
>>> ax.set_xlim([x[0], x[-1]])
>>> ax.legend(loc='best', frameon=False)
>>> plt.show() 

方法：

rvs(a, b, loc=0, scale=1, size=1, random_state=None)	随机变量。
pdf(x, a, b, loc=0, scale=1)	概率密度函数。
logpdf(x, a, b, loc=0, scale=1)	概率密度函数的对数。
cdf(x, a, b, loc=0, scale=1)	累积分布函数。
logcdf(x, a, b, loc=0, scale=1)	累积分布函数的对数。
sf(x, a, b, loc=0, scale=1)	生存函数（也被定义为 1 - cdf，但 sf 有时更精确）。
logsf(x, a, b, loc=0, scale=1)	生存函数的对数。
ppf(q, a, b, loc=0, scale=1)	百分位点函数（cdf 的逆函数 — 百分位数）。
isf(q, a, b, loc=0, scale=1)	逆生存函数（sf 的逆函数）。
moment(order, a, b, loc=0, scale=1)	指定阶的非中心矩。
stats(a, b, loc=0, scale=1, moments=’mv’)	均值（‘m’），方差（‘v’），偏度（‘s’），以及/或者峰度（‘k’）。
entropy(a, b, loc=0, scale=1)	随机变量的（微分）熵。
fit(data)	一般数据的参数估计。详细文档请参见 scipy.stats.rv_continuous.fit。
**expect(func, args=(a, b), loc=0, scale=1, lb=None, ub=None, conditional=False, kwds)	对分布的一个函数（一个参数的）的期望值。
median(a, b, loc=0, scale=1)	分布的中位数。
mean(a, b, loc=0, scale=1)	分布的均值。
var(a, b, loc=0, scale=1)	分布的方差。
std(a, b, loc=0, scale=1)	分布的标准差。
interval(confidence, a, b, loc=0, scale=1)	等概率置信区间的置信度。

scipy.stats.betaprime

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

scipy.stats.betaprime = <scipy.stats._continuous_distns.betaprime_gen object>

beta prime 连续随机变量。

作为rv_continuous类的实例，betaprime对象从中继承了一系列通用方法(下面列出了全部方法)，并使用特定于此特定分布的细节进行补充。

注释

betaprime的概率密度函数为:

[f(x, a, b) = \frac{x^{a-1} (1+x)^{-a-b}}{\beta(a, b)}]

当(x >= 0)，(a > 0)，(b > 0)时，其中(\beta(a, b))是 beta 函数(参见scipy.special.beta)。

betaprime以a和b作为形状参数。

该分布与beta分布相关: 如果(X)服从参数为(a, b)的 beta 分布，则(Y = X/(1-X))服从参数为(a, b)的 beta prime 分布([1])。

beta prime 分布是 F 分布的重新参数化版本。参数a和b以及scale = s的 beta prime 分布等效于参数d1 = 2*a，d2 = 2*b和scale = (a/b)*s的 F 分布。例如，

>>> from scipy.stats import betaprime, f
>>> x = [1, 2, 5, 10]
>>> a = 12
>>> b = 5
>>> betaprime.pdf(x, a, b, scale=2)
array([0.00541179, 0.08331299, 0.14669185, 0.03150079])
>>> f.pdf(x, 2*a, 2*b, scale=(a/b)*2)
array([0.00541179, 0.08331299, 0.14669185, 0.03150079]) 

上述概率密度定义为“标准化”形式。要转换和/或缩放分布，请使用loc和scale参数。具体地，betaprime.pdf(x, a, b, loc, scale)与y = (x - loc) / scale和betaprime.pdf(y, a, b) / scale是等价的。注意，移动分布的位置并不会使其成为“非中心”分布; 一些分布的非中心广义化可在单独的类中找到。

参考资料

[1]

Beta prime 分布，维基百科，en.wikipedia.org/wiki/Beta_prime_distribution

示例

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

计算前四个矩：

>>> a, b = 5, 6
>>> mean, var, skew, kurt = betaprime.stats(a, b, moments='mvsk') 

显示概率密度函数(pdf)：

>>> x = np.linspace(betaprime.ppf(0.01, a, b),
...                 betaprime.ppf(0.99, a, b), 100)
>>> ax.plot(x, betaprime.pdf(x, a, b),
...        'r-', lw=5, alpha=0.6, label='betaprime pdf') 

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

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

>>> rv = betaprime(a, b)
>>> ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf') 

检查cdf和ppf的准确性：

>>> vals = betaprime.ppf([0.001, 0.5, 0.999], a, b)
>>> np.allclose([0.001, 0.5, 0.999], betaprime.cdf(vals, a, b))
True 

生成随机数:

>>> r = betaprime.rvs(a, b, size=1000) 

并比较直方图:

>>> ax.hist(r, density=True, bins='auto', histtype='stepfilled', alpha=0.2)
>>> ax.set_xlim([x[0], x[-1]])
>>> ax.legend(loc='best', frameon=False)
>>> plt.show() 

方法

rvs(a, b, loc=0, scale=1, size=1, random_state=None)	随机变量。
pdf(x, a, b, loc=0, scale=1)	概率密度函数。
logpdf(x, a, b, loc=0, scale=1)	概率密度函数的对数。
cdf(x, a, b, loc=0, scale=1)	累积分布函数。
logcdf(x, a, b, loc=0, scale=1)	累积分布函数的对数。
sf(x, a, b, loc=0, scale=1)	生存函数（也定义为1 - cdf，但有时sf更精确）。
logsf(x, a, b, loc=0, scale=1)	生存函数的对数。
ppf(q, a, b, loc=0, scale=1)	百分位点函数（cdf的逆函数 — 百分位数）。
isf(q, a, b, loc=0, scale=1)	逆生存函数（sf的逆函数）。
moment(order, a, b, loc=0, scale=1)	指定阶数的非中心矩。
stats(a, b, loc=0, scale=1, moments=’mv’)	均值（‘m’）、方差（‘v’）、偏度（‘s’）、峰度（‘k’）。
entropy(a, b, loc=0, scale=1)	随机变量的（微分）熵。
fit(data)	通用数据的参数估计。详细文档请参见scipy.stats.rv_continuous.fit的关键字参数。
**expect(func, args=(a, b), loc=0, scale=1, lb=None, ub=None, conditional=False, kwds)	对于分布的一个参数函数的期望值。
median(a, b, loc=0, scale=1)	分布的中位数。
mean(a, b, loc=0, scale=1)	分布的均值。
var(a, b, loc=0, scale=1)	分布的方差。
std(a, b, loc=0, scale=1)	分布的标准偏差。
interval(confidence, a, b, loc=0, scale=1)	置信区间，围绕中位数有相等的面积。

scipy.stats.bradford

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

scipy.stats.bradford = <scipy.stats._continuous_distns.bradford_gen object>

一个布拉德福特连续随机变量。

作为 rv_continuous 类的一个实例，bradford 对象从中继承了一系列通用方法（请参见下文的完整列表），并通过特定于此特定分布的细节来完成它们。

注意事项

bradford 的概率密度函数为：

[f(x, c) = \frac{c}{\log(1+c) (1+cx)}]

对于 (0 <= x <= 1) 和 (c > 0)。

bradford 以 c 作为形状参数为 (c)。

上述概率密度在“标准化”形式下定义。使用 loc 和 scale 参数来移动和/或缩放分布。具体而言，bradford.pdf(x, c, loc, scale) 等效于 bradford.pdf(y, c) / scale，其中 y = (x - loc) / scale。请注意，移动分布的位置并不使其成为“非中心”分布；某些分布的非中心推广可以在单独的类中找到。

示例

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

计算前四个时刻：

>>> c = 0.299
>>> mean, var, skew, kurt = bradford.stats(c, moments='mvsk') 

显示概率密度函数（pdf）：

>>> x = np.linspace(bradford.ppf(0.01, c),
...                 bradford.ppf(0.99, c), 100)
>>> ax.plot(x, bradford.pdf(x, c),
...        'r-', lw=5, alpha=0.6, label='bradford pdf') 

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

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

>>> rv = bradford(c)
>>> ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf') 

检查cdf和ppf的准确性：

>>> vals = bradford.ppf([0.001, 0.5, 0.999], c)
>>> np.allclose([0.001, 0.5, 0.999], bradford.cdf(vals, c))
True 

生成随机数：

>>> r = bradford.rvs(c, size=1000) 

然后比较直方图：

>>> ax.hist(r, density=True, bins='auto', histtype='stepfilled', alpha=0.2)
>>> ax.set_xlim([x[0], x[-1]])
>>> ax.legend(loc='best', frameon=False)
>>> plt.show() 

方法

rvs(c, loc=0, scale=1, size=1, random_state=None)	随机变量。
pdf(x, c, loc=0, scale=1)	概率密度函数。
logpdf(x, c, loc=0, scale=1)	概率密度函数的对数。
cdf(x, c, loc=0, scale=1)	累积分布函数。
logcdf(x, c, loc=0, scale=1)	累积分布函数的对数。
sf(x, c, loc=0, scale=1)	生存函数（也定义为 1 - cdf，但sf有时更准确）。
logsf(x, c, loc=0, scale=1)	生存函数的对数。
ppf(q, c, loc=0, scale=1)	百分位点函数（cdf的逆 — 百分位数）。
isf(q, c, loc=0, scale=1)	逆生存函数（sf的逆）。
moment(order, c, loc=0, scale=1)	指定阶数的非中心时刻。
stats(c, loc=0, scale=1, moments=’mv’)	均值（‘m’）、方差（‘v’）、偏度（‘s’）、峰度（‘k’）。
entropy(c, loc=0, scale=1)	随机变量的（微分）熵。
fit(data)	适用于通用数据的参数估计。详见scipy.stats.rv_continuous.fit以获取关键字参数的详细文档。
**expect(func, args=(c,), loc=0, scale=1, lb=None, ub=None, conditional=False, kwds)	对于分布，基于一个参数的函数的期望值。
median(c, loc=0, scale=1)	分布的中位数。
mean(c, loc=0, scale=1)	分布的均值。
var(c, loc=0, scale=1)	分布的方差。
std(c, loc=0, scale=1)	分布的标准偏差。
interval(confidence, c, loc=0, scale=1)	中位数周围等面积的置信区间。

scipy.stats.burr

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

scipy.stats.burr = <scipy.stats._continuous_distns.burr_gen object>

一个 Burr（Type III）连续随机变量。

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

另见

fisk

这是 d=1 的 burr 或 burr12 的特例。

burr12

Burr Type XII 分布

mielke

Mielke Beta-Kappa / Dagum 分布

注意

burr 的概率密度函数为：

[f(x; c, d) = c d \frac{x^{-c - 1}} {{(1 + x^{-c})}{d + 1}}]

对于 (x >= 0) 和 (c, d > 0)。

burr 使用 c 和 d 作为形状参数，其中 (c) 和 (d)。

这是对应于 Burr 列表中第三个 CDF 的 PDF；具体来说，它是 Burr 论文中的方程（11）[1]。该分布通常也被称为 Dagum 分布[2]。如果参数 (c < 1)，则分布的均值不存在；如果 (c < 2)，则方差不存在[2]。如果 (c * d >= 1)，则 PDF 在左端点 (x = 0) 处是有限的。

上述概率密度在“标准化”形式下定义。要移动和/或缩放分布，请使用 loc 和 scale 参数。具体而言，burr.pdf(x, c, d, loc, scale) 在 y = (x - loc) / scale 的情况下与 burr.pdf(y, c, d) / scale 是完全等价的。请注意，移动分布的位置不会使其成为“非中心”分布；一些分布的非中心泛化可以在其他类中找到。

参考文献

[1]

Burr, I. W. “累积频率函数”, 数学统计年鉴, 13(2), pp 215-232 (1942).

[2] (1,2)

en.wikipedia.org/wiki/Dagum_distribution

[3]

Kleiber, Christian. “Dagum 分布指南。” 建模收入分布和洛伦兹曲线 pp 97-117 (2008).

示例

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

计算前四个时刻：

>>> c, d = 10.5, 4.3
>>> mean, var, skew, kurt = burr.stats(c, d, moments='mvsk') 

显示概率密度函数 (pdf)：

>>> x = np.linspace(burr.ppf(0.01, c, d),
...                 burr.ppf(0.99, c, d), 100)
>>> ax.plot(x, burr.pdf(x, c, d),
...        'r-', lw=5, alpha=0.6, label='burr pdf') 

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

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

>>> rv = burr(c, d)
>>> ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf') 

检查 cdf 和 ppf 的准确性：

>>> vals = burr.ppf([0.001, 0.5, 0.999], c, d)
>>> np.allclose([0.001, 0.5, 0.999], burr.cdf(vals, c, d))
True 

生成随机数：

>>> r = burr.rvs(c, d, size=1000) 

并比较直方图：

>>> ax.hist(r, density=True, bins='auto', histtype='stepfilled', alpha=0.2)
>>> ax.set_xlim([x[0], x[-1]])
>>> ax.legend(loc='best', frameon=False)
>>> plt.show() 

方法

rvs(c, d, loc=0, scale=1, size=1, random_state=None)	随机变量。
pdf(x, c, d, loc=0, scale=1)	概率密度函数。
logpdf(x, c, d, loc=0, scale=1)	概率密度函数的对数。
cdf(x, c, d, loc=0, scale=1)	累积分布函数。
logcdf(x, c, d, loc=0, scale=1)	累积分布函数的对数。
sf(x, c, d, loc=0, scale=1)	生存函数（也定义为 1 - cdf，但 sf 有时更精确）。
logsf(x, c, d, loc=0, scale=1)	生存函数的对数。
ppf(q, c, d, loc=0, scale=1)	百分点函数（cdf 的逆函数 — 百分位数）。
isf(q, c, d, loc=0, scale=1)	逆生存函数（sf 的逆函数）。
moment(order, c, d, loc=0, scale=1)	指定阶数的非中心矩。
stats(c, d, loc=0, scale=1, moments=’mv’)	均值（‘m’）、方差（‘v’）、偏度（‘s’）、及/或峰度（‘k’）。
entropy(c, d, loc=0, scale=1)	随机变量的（微分）熵。
fit(data)	通用数据的参数估计。详见 scipy.stats.rv_continuous.fit 获取关键字参数的详细文档。
**expect(func, args=(c, d), loc=0, scale=1, lb=None, ub=None, conditional=False, kwds)	相对于分布的函数（一个参数）的期望值。
median(c, d, loc=0, scale=1)	分布的中位数。
mean(c, d, loc=0, scale=1)	分布的均值。
var(c, d, loc=0, scale=1)	分布的方差。
std(c, d, loc=0, scale=1)	分布的标准差。
interval(confidence, c, d, loc=0, scale=1)	置信区间，围绕中位数具有相等的区域。

scipy.stats.burr12

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

scipy.stats.burr12 = <scipy.stats._continuous_distns.burr12_gen object>

一个 Burr（Type XII）连续随机变量。

作为 rv_continuous 类的一个实例，burr12 对象从中继承了一组通用方法（下面列出了完整清单），并补充了特定于该特定分布的细节。

另请参见

fisk

无论是 burr 还是 burr12 的特例，其中 d=1

burr

Burr Type III 分布

注意事项

burr12 的概率密度函数为：

[f(x; c, d) = c d \frac{x^{c-1}} {(1 + x^c){d + 1}}]

对于 (x >= 0) 和 (c, d > 0)。

burr12 以 c 和 d 作为形状参数。

这是对应于 Burr 名单中第十二 CDF 的 PDF；具体而言，这是 Burr 论文中的方程式（20）[1]。

上述概率密度以“标准化”形式定义。要移动和/或缩放分布，请使用 loc 和 scale 参数。具体来说，burr12.pdf(x, c, d, loc, scale) 与 y = (x - loc) / scale 的 burr12.pdf(y, c, d) / scale 完全等价。请注意，移动分布的位置并不使其成为“非中心”分布；某些分布的非中心推广可在单独的类中找到。

Burr 12 型分布有时也称为来自 NIST 的 Singh-Maddala 分布[2]。

参考资料

[1]

Burr, I. W. “累积频率函数”，数理统计学杂志，13(2)，第 215-232 页（1942 年）。

[2]

www.itl.nist.gov/div898/software/dataplot/refman2/auxillar/b12pdf.htm

[3]

“Burr 分布”，en.wikipedia.org/wiki/Burr_distribution

例子

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

计算前四个时刻：

>>> c, d = 10, 4
>>> mean, var, skew, kurt = burr12.stats(c, d, moments='mvsk') 

显示概率密度函数 (pdf)：

>>> x = np.linspace(burr12.ppf(0.01, c, d),
...                 burr12.ppf(0.99, c, d), 100)
>>> ax.plot(x, burr12.pdf(x, c, d),
...        'r-', lw=5, alpha=0.6, label='burr12 pdf') 

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

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

>>> rv = burr12(c, d)
>>> ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf') 

检查 cdf 和 ppf 的准确性：

>>> vals = burr12.ppf([0.001, 0.5, 0.999], c, d)
>>> np.allclose([0.001, 0.5, 0.999], burr12.cdf(vals, c, d))
True 

生成随机数：

>>> r = burr12.rvs(c, d, size=1000) 

并比较直方图：

>>> ax.hist(r, density=True, bins='auto', histtype='stepfilled', alpha=0.2)
>>> ax.set_xlim([x[0], x[-1]])
>>> ax.legend(loc='best', frameon=False)
>>> plt.show() 

方法

rvs(c, d, loc=0, scale=1, size=1, random_state=None)	随机变量。
pdf(x, c, d, loc=0, scale=1)	概率密度函数。
logpdf(x, c, d, loc=0, scale=1)	概率密度函数的对数。
cdf(x, c, d, loc=0, scale=1)	累积分布函数。
logcdf(x, c, d, loc=0, scale=1)	累积分布函数的对数。
sf(x, c, d, loc=0, scale=1)	生存函数（也定义为 1 - cdf，但 sf 有时更精确）。
logsf(x, c, d, loc=0, scale=1)	生存函数的对数。
ppf(q, c, d, loc=0, scale=1)	百分位点函数（cdf 的逆函数 — 百分位数）。
isf(q, c, d, loc=0, scale=1)	生存函数的逆函数（sf 的逆函数）。
moment(order, c, d, loc=0, scale=1)	指定阶数的非中心矩。
stats(c, d, loc=0, scale=1, moments=’mv’)	平均值(‘m’), 方差(‘v’), 偏度(‘s’), 和/或峰度(‘k’)。
entropy(c, d, loc=0, scale=1)	随机变量的（微分）熵。
fit(data)	通用数据的参数估计值。详细文档请参见 scipy.stats.rv_continuous.fit。
**expect(func, args=(c, d), loc=0, scale=1, lb=None, ub=None, conditional=False, kwds)	对于分布的函数（一个参数）的期望值。
median(c, d, loc=0, scale=1)	分布的中位数。
mean(c, d, loc=0, scale=1)	分布的均值。
var(c, d, loc=0, scale=1)	分布的方差。
std(c, d, loc=0, scale=1)	分布的标准差。
interval(confidence, c, d, loc=0, scale=1)	中位数周围面积相等的置信区间。

scipy.stats.cauchy

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

scipy.stats.cauchy = <scipy.stats._continuous_distns.cauchy_gen object>

一个柯西连续随机变量。

作为 rv_continuous 类的实例，cauchy 对象从中继承了一系列通用方法（完整列表见下文），并以特定于该分布的细节补充其功能。

注意事项

cauchy 的概率密度函数为

[f(x) = \frac{1}{\pi (1 + x²)}]

对于实数 (x)。

上述的概率密度在“标准化”形式中定义。使用 loc 和 scale 参数可以进行分布的平移和/或缩放。具体来说，cauchy.pdf(x, loc, scale) 在数学上等同于 cauchy.pdf(y) / scale，其中 y = (x - loc) / scale。请注意，改变分布的位置并不会使其成为“非中心”分布；某些分布的非中心泛化在单独的类中可用。

示例

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

计算前四个矩：

>>> mean, var, skew, kurt = cauchy.stats(moments='mvsk') 

显示概率密度函数 (pdf)：

>>> x = np.linspace(cauchy.ppf(0.01),
...                 cauchy.ppf(0.99), 100)
>>> ax.plot(x, cauchy.pdf(x),
...        'r-', lw=5, alpha=0.6, label='cauchy pdf') 

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

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

>>> rv = cauchy()
>>> ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf') 

检查 cdf 和 ppf 的准确性：

>>> vals = cauchy.ppf([0.001, 0.5, 0.999])
>>> np.allclose([0.001, 0.5, 0.999], cauchy.cdf(vals))
True 

生成随机数：

>>> r = cauchy.rvs(size=1000) 

并比较直方图：

>>> ax.hist(r, density=True, bins='auto', histtype='stepfilled', alpha=0.2)
>>> ax.set_xlim([x[0], x[-1]])
>>> ax.legend(loc='best', frameon=False)
>>> plt.show() 

方法

rvs(loc=0, scale=1, size=1, random_state=None)	随机变量。
pdf(x, loc=0, scale=1)	概率密度函数。
logpdf(x, loc=0, scale=1)	概率密度函数的对数。
cdf(x, loc=0, scale=1)	累积分布函数。
logcdf(x, loc=0, scale=1)	累积分布函数的对数。
sf(x, loc=0, scale=1)	生存函数（也定义为 1 - cdf，但有时 sf 更精确）。
logsf(x, loc=0, scale=1)	生存函数的对数。
ppf(q, loc=0, scale=1)	百分位点函数（cdf 的反函数 — 百分位数）。
isf(q, loc=0, scale=1)	逆生存函数（sf 的逆）。
moment(order, loc=0, scale=1)	指定阶数的非中心矩。
stats(loc=0, scale=1, moments=’mv’)	均值（‘m’），方差（‘v’），偏度（‘s’）和/或峰度（‘k’）。
entropy(loc=0, scale=1)	RV 的（微分）熵。
fit(data)	通用数据的参数估计。详细文档请参见 scipy.stats.rv_continuous.fit。
**expect(func, args=(), loc=0, scale=1, lb=None, ub=None, conditional=False, kwds)	计算分布函数关于函数（一个参数）的期望值。
median(loc=0, scale=1)	分布的中位数。
mean(loc=0, scale=1)	分布的均值。
var(loc=0, scale=1)	分布的方差。
std(loc=0, scale=1)	分布的标准差。
interval(confidence, loc=0, scale=1)	中位数周围具有相等面积的置信区间。

scipy.stats.chi

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

scipy.stats.chi = <scipy.stats._continuous_distns.chi_gen object>

一个卡方连续随机变量。

作为 rv_continuous 类的一个实例，chi 对象从中继承了一组通用方法（完整列表见下文），并且使用本特定分布的细节完成它们。

注意

chi 的概率密度函数为：

[f(x, k) = \frac{1}{2^{k/2-1} \Gamma \left( k/2 \right)} x^{k-1} \exp \left( -x²/2 \right)]

对于 (x \geq 0) 和 (k > 0)（在实现中称为自由度 df）。(\Gamma) 是 gamma 函数（scipy.special.gamma）。

chi的特殊情况包括：

• chi(1, loc, scale)相当于halfnorm
• chi(2, 0, scale)相当于rayleigh
• chi(3, 0, scale)相当于maxwell

chi 将 df 作为形状参数。

上述概率密度在“标准化”形式下定义。使用 loc 和 scale 参数来移位和/或缩放分布。具体地说，chi.pdf(x, df, loc, scale) 与 chi.pdf(y, df) / scale 完全等效，其中 y = (x - loc) / scale。请注意，将分布的位置移动并不使其成为“非中心”分布；一些分布的非中心推广可以在单独的类中找到。

示例

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

计算前四个时刻：

>>> df = 78
>>> mean, var, skew, kurt = chi.stats(df, moments='mvsk') 

显示概率密度函数（pdf）：

>>> x = np.linspace(chi.ppf(0.01, df),
...                 chi.ppf(0.99, df), 100)
>>> ax.plot(x, chi.pdf(x, df),
...        'r-', lw=5, alpha=0.6, label='chi pdf') 

或者，可以像调用函数一样调用分布对象，以修正形状、位置和比例参数。这将返回一个“冻结”的 RV 对象，其中给定的参数被固定。

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

>>> rv = chi(df)
>>> ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf') 

检查cdf和ppf的准确性：

>>> vals = chi.ppf([0.001, 0.5, 0.999], df)
>>> np.allclose([0.001, 0.5, 0.999], chi.cdf(vals, df))
True 

生成随机数：

>>> r = chi.rvs(df, size=1000) 

并比较直方图：

>>> ax.hist(r, density=True, bins='auto', histtype='stepfilled', alpha=0.2)
>>> ax.set_xlim([x[0], x[-1]])
>>> ax.legend(loc='best', frameon=False)
>>> plt.show() 

方法

rvs(df, loc=0, scale=1, size=1, random_state=None)	随机变量。
pdf(x, df, loc=0, scale=1)	概率密度函数。
logpdf(x, df, loc=0, scale=1)	概率密度函数的对数。
cdf(x, df, loc=0, scale=1)	累积分布函数。
logcdf(x, df, loc=0, scale=1)	累积分布函数的对数。
sf(x, df, loc=0, scale=1)	生存函数（也定义为 1 - cdf，但 sf 有时更精确）。
logsf(x, df, loc=0, scale=1)	生存函数的对数。
ppf(q, df, loc=0, scale=1)	百分位点函数（cdf的逆 — 百分位数）。
isf(q, df, loc=0, scale=1)	逆生存函数（sf的逆）。
moment(order, df, loc=0, scale=1)	指定阶数的非中心矩。
stats(df, loc=0, scale=1, moments=’mv’)	均值（‘m’）、方差（‘v’）、偏度（‘s’）和/或峰度（‘k’）。
entropy(df, loc=0, scale=1)	随机变量的（微分）熵。
fit(data)	通用数据的参数估计。详细文档请参见scipy.stats.rv_continuous.fit。
**expect(func, args=(df,), loc=0, scale=1, lb=None, ub=None, conditional=False, kwds)	函数（一个参数的）对分布的期望值。
median(df, loc=0, scale=1)	分布的中位数。
mean(df, loc=0, scale=1)	分布的均值。
var(df, loc=0, scale=1)	分布的方差。
std(df, loc=0, scale=1)	分布的标准偏差。
interval(confidence, df, loc=0, scale=1)	置信区间，围绕中位数具有相等面积。

scipy.stats.chi2

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

scipy.stats.chi2 = <scipy.stats._continuous_distns.chi2_gen object>

一个卡方连续随机变量。

对于非中心卡方分布，请参见 ncx2。

作为 rv_continuous 类的一个实例，chi2 对象继承了一组通用方法（详见下文的完整列表），并通过特定于该特定分布的细节完善了它们。

另请参阅

ncx2

注意事项

chi2 的概率密度函数为：

[f(x, k) = \frac{1}{2^{k/2} \Gamma \left( k/2 \right)} x^{k/2-1} \exp \left( -x/2 \right)]

对于 (x > 0) 和 (k > 0)（自由度，在实现中称为 df）。

chi2 将 df 作为形状参数。

卡方分布是伽马分布的一种特殊情况，其伽马参数为 a = df/2，loc = 0 和 scale = 2。

上述概率密度函数以“标准化”形式定义。要移动和/或缩放分布，请使用loc和scale参数。具体而言，chi2.pdf(x, df, loc, scale)与chi2.pdf(y, df) / scale等价，其中y = (x - loc) / scale。请注意，移动分布的位置不会使其成为“非中心”分布；某些分布的非中心泛化可在单独的类中找到。

示例

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

计算前四个时刻：

>>> df = 55
>>> mean, var, skew, kurt = chi2.stats(df, moments='mvsk') 

显示概率密度函数（pdf）：

>>> x = np.linspace(chi2.ppf(0.01, df),
...                 chi2.ppf(0.99, df), 100)
>>> ax.plot(x, chi2.pdf(x, df),
...        'r-', lw=5, alpha=0.6, label='chi2 pdf') 

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

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

>>> rv = chi2(df)
>>> ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf') 

检查 cdf 和 ppf 的准确性：

>>> vals = chi2.ppf([0.001, 0.5, 0.999], df)
>>> np.allclose([0.001, 0.5, 0.999], chi2.cdf(vals, df))
True 

生成随机数：

>>> r = chi2.rvs(df, size=1000) 

并比较直方图：

>>> ax.hist(r, density=True, bins='auto', histtype='stepfilled', alpha=0.2)
>>> ax.set_xlim([x[0], x[-1]])
>>> ax.legend(loc='best', frameon=False)
>>> plt.show() 

方法

- rvs(df, loc=0, scale=1, size=1, random_state=None) - 随机变量。

- pdf(x, df, loc=0, scale=1) - 概率密度函数。

- logpdf(x, df, loc=0, scale=1) - 概率密度函数的对数。

- cdf(x, df, loc=0, scale=1) - 累积分布函数。

- logcdf(x, df, loc=0, scale=1) - 累积分布函数的对数。

- sf(x, df, loc=0, scale=1) - 生存函数（也被定义为 1 - cdf，但 sf 有时更精确）。

- logsf(x, df, loc=0, scale=1) - 生存函数的对数。

- ppf(q, df, loc=0, scale=1) - 百分点函数（cdf 的反函数 — 百分位数）。

isf(q, df, loc=0, scale=1)

moment(order, df, loc=0, scale=1)

stats(df, loc=0, scale=1, moments=’mv’)

entropy(df, loc=0, scale=1)

fit(data)

**expect(func, args=(df,), loc=0, scale=1, lb=None, ub=None, conditional=False, kwds)

median(df, loc=0, scale=1)

mean(df, loc=0, scale=1)

var(df, loc=0, scale=1)

std(df, loc=0, scale=1)

interval(confidence, df, loc=0, scale=1)