NumPy-1-26-中文文档-十六-
NumPy 1.26 中文文档（十六）
numpy.amax
numpy.amax(a, axis=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)
返回数组的最大值或沿着一个轴的最大值。
amax 是 max 的别名。
参见
max
这个函数的别名
ndarray.max
等效方法
numpy.fmax
numpy.fmax(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'fmax'>
数组元素的逐元素最大值。
比较两个数组并返回一个包含逐元素最大值的新数组。如果要比较的元素中有一个是 NaN，则返回非 NaN 元素。如果两个元素都是 NaN，则返回第一个。后者的区别对于复杂 NaN 很重要，复杂 NaN 定义为至少有一个实部或虚部为 NaN。总体效果是在可能的情况下忽略 NaNs。
参数：
x1, x2array_like
包含要比较的元素的数组。如果x1.shape != x2.shape，它们必须能够广播到一个公共形状（该形状成为输出的形状）。
outndarray、None 或 ndarray 和 None 的元组，可选
存储结果的位置。如果提供，必须具有输入广播到的形状。如果未提供或为 None，则返回新分配的数组。作为关键字参数的元组必须具有与输出数目相等的长度。
wherearray_like，可选
此条件在输入上进行广播。条件为真的位置，out数组将被设置为 ufunc 结果。在其他地方，out数组将保留其原始值。请注意，如果通过默认out=None创建了未初始化的out数组，则其中条件为假的位置将保持未初始化状态。
**kwargs
对于其他关键字参数，请参见 ufunc 文档。
返回：
yndarray 或标量
x1和x2的逐元素最大值。如果x1和x2都是标量，则这是标量。
另请参阅
fmin
两个数组的逐元素最小值，忽略 NaNs。
maximum
两个数组的逐元素最大值，传播 NaNs。
amax
数组沿给定轴的最大值，传播 NaNs。
nanmax
沿着给定轴的数组的最大值，忽略 NaNs。
minimum，amin，nanmin
注释
新版本中添加 1.3.0。
当x1和x2都不是 NaN 时，fmax等同于np.where(x1 >= x2, x1, x2)，但它更快，可以进行正确的广播。
示例
>>> np.fmax([2, 3, 4], [1, 5, 2])
array([ 2., 5., 4.])
>>> np.fmax(np.eye(2), [0.5, 2])
array([[ 1\. , 2\. ],
[ 0.5, 2\. ]])
>>> np.fmax([np.nan, 0, np.nan],[0, np.nan, np.nan])
array([ 0., 0., nan])
numpy.nanmax
numpy.nanmax(a, axis=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)
返回数组的最大值或沿轴的最大值，忽略任何 NaN。当遇到全是 NaN 的片段时，会触发 RuntimeWarning 并返回该片段的 NaN。
参数：
aarray_like
包含所需最大值的数字的数组。如果 a 不是数组，则会尝试进行转换。
axis，可选
计算最大值的轴或轴。默认是计算扁平化数组的最大值。
out ndarray，可选
替代输出数组，用于放置结果。默认为 None；如果提供，必须具有与预期输出相同的形状，但必要时将进行类型转换。有关详细信息，请参见输出类型确定。
版本 1.8.0 中的新功能。
keepdims 布尔值，可选
如果设置为 True，则减少的轴将保留在结果中，作为大小为一的维度。使用此选项，结果将正确地广播到原始 a。
如果值与默认值不同，则 keepdims 将被传递给 ndarray 的子类的 max 方法。如果子类方法没有实现 keepdims，则会引发任何异常。
版本 1.8.0 中的新功能。
initial 标量，可选
输出元素的最小值。必须出现才能在空切片上进行计算。有关详细信息，请参见reduce。
版本 1.22.0 中的新功能。
where 布尔型数组，可选
用于比较最大值的元素。有关详细信息，请参见 reduce。
版本 1.22.0 中的新功能。
返回：
nanmaxndarray
与 a 形状相同的数组，其中指定的轴被移除。如果 a 是 0 维数组，或者轴为 None，那么会返回一个 ndarray 标量。返回与 a 相同的 dtype。
另请参阅
nanmin
数组沿指定轴的最小值，忽略任何 NaN。
amax
沿指定轴的数组的最大值，传播任何 NaN。
fmax
逐元素数组的最大值，忽略任何 NaN。
maximum
两个数组的逐元素最大值，传播任何 NaN。
isnan
显示哪些元素不是数字（NaN）。
isfinite
显示哪些元素既不是 NaN 也不是无穷大。
amin、fmin、minimum
注意事项
NumPy 使用 IEEE 标准二进制浮点数算术（IEEE 754）。这意味着不是一个数（NaN）并不等同于无穷大。正无穷大被视为一个非常大的数，负无穷大被视为一个非常小的（即负的）数。
如果输入是整数类型，则该函数等同于 np.max。
示例
>>> a = np.array([[1, 2], [3, np.nan]])
>>> np.nanmax(a)
3.0
>>> np.nanmax(a, axis=0)
array([3., 2.])
>>> np.nanmax(a, axis=1)
array([2., 3.])
当正无穷大和负无穷大存在时：
>>> np.nanmax([1, 2, np.nan, np.NINF])
2.0
>>> np.nanmax([1, 2, np.nan, np.inf])
inf
numpy.minimum
原文：
numpy.org/doc/1.26/reference/generated/numpy.minimum.html
numpy.minimum(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'minimum'>
数组元素的逐元素最小值。
比较两个数组并返回包含逐元素最小值的新数组。如果要比较的元素之一是 NaN，则返回该元素。如果两个元素都是 NaN，则返回第一个。后者的区别对于复数 NaN 很重要，复数 NaN 被定义为至少一个实部或虚部是 NaN。净效果是 NaN 被传播。
参数：
x1, x2array_like
包含要比较的元素的数组。如果x1.shape != x2.shape，它们必须可以广播到一个公共形状（这成为输出的形状）。
outndarray、None 或 ndarray 和 None 的元组，可选
存储结果的位置。如果提供，它必须具有输入广播到的形状。如果未提供或为 None，则返回一个新分配的数组。作为关键字参数的元组（仅为可能）必须具有与输出数量相等的长度。
wherearray_like，可选
此条件在输入上进行广播。在条件为真的位置，out 数组将设置为 ufunc 结果。在其他位置，out 数组将保留其原始值。请注意，如果通过默认out=None创建了未初始化的 out 数组，则其中条件为 False 的位置将保持未初始化。
**kwargs
对于其他仅限关键字参数，请参阅 ufunc 文档。
返回：
yndarray 或标量
x1 和 x2 的逐元素最小值。如果 x1 和 x2 都是标量，则为标量。
另请参见
maximum
两个数组的逐元素最大值，传播 NaN。
fmin
两个数组的逐元素最小值，忽略 NaN。
amin
给定轴向数组的最小值，传播 NaN。
nanmin
给定轴向的数组的最小值，忽略 NaN。
fmax, amax, nanmax
注意
当 x1 和 x2 都不是 NaN 时，最小值等同于 np.where(x1 <= x2, x1, x2)，但速度更快且进行适当的广播。
示例
>>> np.minimum([2, 3, 4], [1, 5, 2])
array([1, 3, 2])
>>> np.minimum(np.eye(2), [0.5, 2]) # broadcasting
array([[ 0.5, 0\. ],
[ 0\. , 1\. ]])
>>> np.minimum([np.nan, 0, np.nan],[0, np.nan, np.nan])
array([nan, nan, nan])
>>> np.minimum(-np.Inf, 1)
-inf
numpy.min
numpy.min(a, axis=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)
返回数组的最小值或沿轴的最小值。
参数：
a: array_like
输入数据。
axis: None 或 int 或 int 元组，可选
操作的轴或轴。默认情况下，使用扁平化的输入。
版本 1.7.0 中的新功能。
如果这是一组整数的元组，则最小值是在多个轴上选择的，而不是以前的单个轴或所有轴。
out: ndarray，可选
替代输出数组，用于放置结果。必须与预期输出具有相同的形状和缓冲区长度。有关更多详细信息，请参见输出类型确定。
keepdims: 布尔值，可选
如果设置为 True，则被缩减的轴将在结果中保留为大小为 1 的维度。通过此选项，结果将正确广播到输入数组。
如果传递了默认值，则keepdims将不会传递给ndarray的min子类的方法，但任何非默认值都会。如果子类的方法不实现keepdims，则会引发任何异常。
initial: 标量，可选
输出元素的最大值。必须存在以允许对空片进行计算。有关详细信息，请参见reduce。
版本 1.15.0 中的新功能。
where: 布尔值的 array_like，可选
用于比较最小值的元素。有关详细信息，请参见reduce。
版本 1.17.0 中的新功能。
返回：
min: ndarray 或标量
a的最小值。如果axis为 None，则结果是一个标量值。如果axis是一个 int，则结果是一个维度为a.ndim - 1的数组。如果axis是一个元组，则结果是一个维度为a.ndim - len(axis)的数组。
另请参见
沿着给定轴的数组的最大值，传播任何 NaN。
沿着给定轴的数组的最小值，忽略任何 NaN。
元素级别两个数组的最小值，传播任何 NaN。
元素级别两个数组的最小值，忽略任何 NaN。
返回最小值的索引。
注意事项
NaN 值会传递，即如果至少有一个项是 NaN，则对应的最小值也将是 NaN。要忽略 NaN 值（MATLAB 行为），请使用 nanmin。
不要使用min对 2 个数组进行逐个元素比较；当a.shape[0]为 2 时，minimum(a[0], a[1])比min(a, axis=0)更快。
例子
>>> a = np.arange(4).reshape((2,2))
>>> a
array([[0, 1],
[2, 3]])
>>> np.min(a) # Minimum of the flattened array
0
>>> np.min(a, axis=0) # Minima along the first axis
array([0, 1])
>>> np.min(a, axis=1) # Minima along the second axis
array([0, 2])
>>> np.min(a, where=[False, True], initial=10, axis=0)
array([10, 1])
>>> b = np.arange(5, dtype=float)
>>> b[2] = np.NaN
>>> np.min(b)
nan
>>> np.min(b, where=~np.isnan(b), initial=10)
0.0
>>> np.nanmin(b)
0.0
>>> np.min([[-50], [10]], axis=-1, initial=0)
array([-50, 0])
请注意，初始值被用作确定最小值的元素之一，与 Python 的 max 函数的默认参数不同，该参数仅用于空迭代器。
请注意，这与 Python 的default参数不同。
>>> np.min([6], initial=5)
5
>>> min([6], default=5)
6
numpy.amin
numpy.amin(a, axis=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)
返回数组或沿轴的最小值。
amin 是 min 的别名。
另请参见
min
此函数的别名
ndarray.min
等效的方法
numpy.fmin
numpy.fmin(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'fmin'>
数组元素的逐个最小值。
比较两个数组，并返回一个包含逐个元素最小值的新数组。如果被比较的元素中有一个 NaN，则返回非 nan 元素。如果两个元素都是 NaN，则返回第一个。后者对于复数 NaN 很重要，复数 NaN 被定义为至少其中一个实部或虚部是 NaN。净效果是尽可能忽略 NaN。
参数：
x1, x2array_like
包含要比较的元素的数组。如果x1.shape != x2.shape，它们必须能够广播到公共形状（这成为输出的形状）。
outndarray、None 或 ndarray 和 None 的元组，可选
一个位置，用于存储结果。如果提供，它必须具有输入广播到的形状。如果未提供或为 None，则返回一个新分配的数组。一个元组（仅作为关键字参数）的长度必须等于输出的数量。
wherearray_like, optional
此条件针对输入进行广播。在条件为 True 的位置，out数组将设置为 ufunc 结果。在其他地方，out数组将保留其原始值。请注意，如果通过默认的out=None创建了未初始化的out数组，在其中条件为 False 的位置将保持未初始化状态。
**kwargs
对于其他仅限关键字参数，请参见ufunc 文档。
返回：
yndarray 或标量
x1和x2的最小值，逐个元素。如果x1和x2都是标量，则为标量。
另请参见
两个数组的逐个最大值，忽略 NaN。
两个数组的逐个最小值，传播 NaN。
对于给定轴的数组的最小值，传播 NaN。
对于给定轴的数组的最小值，忽略 NaN。
注释
新版本 1.3.0 中。
当x1和x2都不是 NaN 时，np.where(x1 <= x2, x1, x2)等价于 fmin，但它更快，且可以进行正确的广播。
示例
>>> np.fmin([2, 3, 4], [1, 5, 2])
array([1, 3, 2])
>>> np.fmin(np.eye(2), [0.5, 2])
array([[ 0.5, 0\. ],
[ 0\. , 1\. ]])
>>> np.fmin([np.nan, 0, np.nan],[0, np.nan, np.nan])
array([ 0., 0., nan])
numpy.nanmin
numpy.nanmin(a, axis=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)
返回数组的最小值或沿轴的最小值，忽略任何 NaN。当遇到全为 NaN 的切片时，会引发 RuntimeWarning，并为该切片返回 NaN。
参数：
a 类型为 array_like
包含所需最小值的数字的数组。如果 a 不是数组，则会尝试转换。
axis，可选
计算最小值的轴或轴。默认是计算平铺数组的最小值。
out ndarray，可选
用于放置结果的替代输出数组。默认为 None；如果提供，它必须具有与预期输出相同的形状，但如果需要，类型将被转换。有关更多详情，请参阅 输出类型确定。
版本 1.8.0 中的新功能。
keepdims bool，可选
如果设置为 True，则减少的轴将作为尺寸为一的维度保留在结果中。使用此选项，结果将与原始 a 正确广播。
如果值不是默认值，则 keepdims 将传递给 min 的子类方法。如果子类方法没有实现 keepdims，则会引发任何异常。
版本 1.8.0 中的新功能。
initial 标量，可选
输出元素的最大值。必须存在以允许对空切片进行计算。有关详细信息，请参阅 reduce。
版本 1.22.0 中的新功能。
where bool 类型的数组，可选
用于比较最小值的元素。有关详细信息，请参阅 reduce。
版本 1.22.0 中的新功能。
返回值：
nanmin ndarray
一个与 a 相同形状的数组，移除了指定的轴。如果 a 是 0 维数组，或者轴为 None，则返回一个 ndarray 标量。返回与 a 相同的 dtype。
另请参阅
nanmax
沿给定轴的数组的最大值，忽略任何 NaN。
amin
沿着给定轴的数组的最小值，传播任何 NaN。
fmin
数组的逐元素最小值，忽略任何 NaN。
minimum
数组的逐元素最小值，传播任何 NaN。
isnan
显示哪些元素是非数字（NaN）。
isfinite
显示哪些元素既不是 NaN 也不是无穷大。
amax, fmax, maximum
注意
NumPy 使用 IEEE 标准的二进制浮点运算（IEEE 754）。 这意味着“不是一个数字”与无穷大不等价。 正无穷大被视为一个非常大的数，而负无穷大被视为一个非常小的（即负的）数。
如果输入是整数类型，则该函数等同于 np.min。
示例
>>> a = np.array([[1, 2], [3, np.nan]])
>>> np.nanmin(a)
1.0
>>> np.nanmin(a, axis=0)
array([1., 2.])
>>> np.nanmin(a, axis=1)
array([1., 3.])
当正无穷大和负无穷大同时存在时：
>>> np.nanmin([1, 2, np.nan, np.inf])
1.0
>>> np.nanmin([1, 2, np.nan, np.NINF])
-inf
numpy.convolve
原文：
numpy.org/doc/1.26/reference/generated/numpy.convolve.html
numpy.convolve(a, v, mode='full')
返回两个一维序列的离散线性卷积。
卷积操作符经常出现在信号处理中，用于模拟线性时不变系统对信号的影响 [1]。在概率论中，两个独立随机变量的和分布服从它们各自分布的卷积。
如果 v 比 a 长，则在计算之前交换数组。
参数：
a（N，）array_like
第一个一维输入数组。
v（M，）array_like
第二个一维输入数组。
mode，可选
‘full’：
默认情况下，模式为‘full’。这会返回重叠的每个点的卷积，输出形状为（N+M-1，）。在卷积的端点，信号不完全重叠，可能会出现边界效应。
‘same’：
‘same’ 模式返回长度为 max(M, N) 的输出。边界效应仍然可见。
‘valid’：
‘valid’ 模式返回长度为 max(M, N) - min(M, N) + 1 的输出。仅在信号完全重叠的点上给出卷积乘积。信号边界外的值没有影响。
返回：
out ndarray
a 和 v 的离散线性卷积。
另请参阅
使用快速傅里叶变换卷积两个数组。
用于构造卷积操作符。
polymul
多项式乘法。与 convolve 具有相同的输出，但也接受 poly1d 对象作为输入。
笔记
离散卷积操作定义为
[(a * v)n = \sum^{\infty} a_m v_{n - m}]
可以证明，在时间/空间中的卷积 (x(t) * y(t)) 等价于傅里叶域中的乘法 (X(f) Y(f))，在适当的填充后（填充是必要的，以防止循环卷积）。由于乘法比卷积更有效（更快），函数scipy.signal.fftconvolve 利用 FFT 计算大数据集的卷积。
参考
[1]
维基百科，“卷积”，en.wikipedia.org/wiki/Convolution
例子
注意卷积操作符如何在“滑动”两个数组之前翻转第二个数组：
>>> np.convolve([1, 2, 3], [0, 1, 0.5])
array([0\. , 1\. , 2.5, 4\. , 1.5])
仅返回卷积的中间值。包含边界效应，其中零值被考虑进去：
>>> np.convolve([1,2,3],[0,1,0.5], 'same')
array([1\. , 2.5, 4\. ])
这两个数组长度相同，因此只有一个位置它们完全重叠：
>>> np.convolve([1,2,3],[0,1,0.5], 'valid')
array([2.5])
numpy.clip
numpy.clip(a, a_min, a_max, out=None, **kwargs)
对数组中的值进行截断（限制）。
给定一个区间，超出该区间的值被截断为区间边界。例如，如果指定了一个区间 [0, 1]，则小于 0 的值变为 0，大于 1 的值变为 1。
等效于但比 np.minimum(a_max, np.maximum(a, a_min)) 快。
不检查以确保 a_min < a_max。
参数：
aarray_like
包含要截断的元素的数组。
a_min, a_maxarray_like 或 None
最小和最大值。如果为 None，则不对相应的边界执行截断。a_min 和 a_max 只能有一个为 None。两者都广播到 a。
outndarray，可选
结果将放置在此数组中。它可以是用于就地截断的输入数组。out 必须具有足够的形状来容纳输出。其类型保持不变。
**kwargs
对于其他仅关键字参数，请参阅 ufunc 文档。
新版本 1.17.0 中新增。
返回：
clipped_arrayndarray
一个包含 a 元素的数组，但其中小于 a_min 的值被替换为 a_min，大于 a_max 的值被替换为 a_max。
另请参阅
输出类型确定
注释
当 a_min 大于 a_max 时，clip 返回一个所有值都等于 a_max 的数组，如第二个示例所示。
示例
>>> a = np.arange(10)
>>> a
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> np.clip(a, 1, 8)
array([1, 1, 2, 3, 4, 5, 6, 7, 8, 8])
>>> np.clip(a, 8, 1)
array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1])
>>> np.clip(a, 3, 6, out=a)
array([3, 3, 3, 3, 4, 5, 6, 6, 6, 6])
>>> a
array([3, 3, 3, 3, 4, 5, 6, 6, 6, 6])
>>> a = np.arange(10)
>>> a
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> np.clip(a, [3, 4, 1, 1, 1, 4, 4, 4, 4, 4], 8)
array([3, 4, 2, 3, 4, 5, 6, 7, 8, 8])
numpy.sqrt
numpy.sqrt(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'sqrt'>
返回数组的非负平方根，逐元素。
参数：
xarray_like
需要其平方根的值。
outndarray、None 或 ndarray 和 None 的元组，可选
用于存储结果的位置。如果提供，则必须具有输入广播到的形状。如果未提供或为 None，则返回一个新分配的数组。一个元组（仅作为关键字参数）的长度必须等于输出数量。
wherearray_like，可选
此条件在输入上广播。在条件为 True 的位置，out数组将设置为 ufunc 结果。在其他地方，out数组将保留其原始值。请注意，如果通过默认out=None创建未初始化的out数组，则条件为 False 的位置将保持未初始化状态。
**kwargs
对于其他仅关键字参数，请参阅 ufunc 文档。
返回值：
yndarray
与x相同形状的数组，包含x中每个元素的正平方根。如果x中有任何复数元素，则返回一个复数数组（并计算负实数的平方根）。如果x中的所有元素都是实数，则y也是实数，其中负元素返回nan。如果提供了out，y是对它的引用。如果x是标量，则这是一个标量。
另请参见
emath.sqrt
一个版本，在给定负实数时返回复数。请注意，对于复数输入，0.0 和-0.0 的处理方式不同。
注意
sqrt具有与常见约定一致的分支割线，即实部“区间”[-inf，0)，并在其上方连续。分支割线是复平面上的一条曲线，沿着该曲线给定复函数不连续。
示例
>>> np.sqrt([1,4,9])
array([ 1., 2., 3.])
>>> np.sqrt([4, -1, -3+4J])
array([ 2.+0.j, 0.+1.j, 1.+2.j])
>>> np.sqrt([4, -1, np.inf])
array([ 2., nan, inf])
numpy.cbrt
numpy.cbrt(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'cbrt'>
返回数组的每个元素的立方根。
新版本 1.10.0 中引入。
参数：
xarray_like
需要其立方根的值。
outndarray、None 或 ndarray 和 None 的元组，可选
结果存储的位置。如果提供，它必须具有输入广播到的形状。如果未提供或为 None，则返回一个新分配的数组。仅作为关键字参数的元组（仅当关键字参数）必须具有与输出数量相等的长度。
wherearray_like，可选
此条件会广播到输入。在条件为 True 的位置，out数组将设置为 ufunc 结果。否则，out数组将保留其原始值。注意，如果通过默认值out=None创建一个未初始化的out数组，其中条件为 False 的位置将保持未初始化状态。
**kwargs
对于其他仅关键字参数，请参见 ufunc 文档。
返回：
yndarray
形状与x相同的数组，包含x中每个元素的立方根。如果提供了out，y是对其的引用。如果x是标量，则这是一个标量。
示例
>>> np.cbrt([1,8,27])
array([ 1., 2., 3.])
numpy.square
numpy.square(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'square'>
返回输入的逐元素平方。
参数：
x：array_like
输入数据。
out：ndarray、None 或 ndarray 和 None 的元组，可选
结果存储的位置。如果提供，则必须具有输入广播到的形状。如果未提供或为 None，则返回一个新分配的数组。元组（仅作为关键字参数）的长度必须等于输出数量。
where：array_like，可选
此条件广播到输入。在条件为 True 的位置，out数组将设置为 ufunc 结果。在其他位置，out数组将保持其原始值。请注意，如果通过默认值out=None创建了未初始化的out数组，则其中条件为 False 的位置将保持未初始化。
**kwargs
对于其他仅关键字参数，请参阅 ufunc 文档。
返回值：
out：ndarray 或标量
逐元素xx，形状和 dtype 与x相同。如果x*是标量，则为标量。
另请参阅
numpy.linalg.matrix_power
sqrt
power
示例
>>> np.square([-1j, 1])
array([-1.-0.j, 1.+0.j])
numpy.absolute
原文：
numpy.org/doc/1.26/reference/generated/numpy.absolute.html
numpy.absolute(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'absolute'>
逐元素计算绝对值。
np.abs是这个函数的快捷方式。
参数：
xarray_like
输入数组。
outndarray、None 或 ndarray 和 None 的元组，可选
存储结果的位置。如果提供，它必须具有输入广播到的形状。如果未提供或为 None，则返回一个新分配的数组。元组（仅作为关键字参数）的长度必须等于输出数量。
wherearray_like, optional
此条件会广播到输入中。在条件为 True 的位置，out数组将设置为 ufunc 的结果。在其他位置，out数组将保留其原始值。请注意，如果通过默认值out=None创建未初始化的out数组，则其中条件为 False 的位置将保持未初始化状态。
**kwargs
对于其他关键字参数，请参阅 ufunc 文档。
返回值：
absolutendarray
包含x中每个元素的绝对值的 ndarray。对于复数输入a + ib，绝对值是(\sqrt{ a² + b² })。如果x是标量，则为标量。
示例
>>> x = np.array([-1.2, 1.2])
>>> np.absolute(x)
array([ 1.2, 1.2])
>>> np.absolute(1.2 + 1j)
1.5620499351813308
绘制函数在[-10, 10]上的图像：
>>> import matplotlib.pyplot as plt
>>> x = np.linspace(start=-10, stop=10, num=101)
>>> plt.plot(x, np.absolute(x))
>>> plt.show()
在复平面上绘制函数图像：
>>> xx = x + 1j * x[:, np.newaxis]
>>> plt.imshow(np.abs(xx), extent=[-10, 10, -10, 10], cmap='gray')
>>> plt.show()
函数abs 可以用作np.absolute在 ndarrays 上的简写。
>>> x = np.array([-1.2, 1.2])
>>> abs(x)
array([1.2, 1.2])
numpy.fabs
numpy.fabs(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'fabs'>
逐元素计算绝对值。
该函数返回x中数据的绝对值（正值）。不处理复数值，请使用absolute来找到复数数据的绝对值。
参数：
x：array_like
绝对值所需数字的数组。如果x是标量，则结果y也将是标量。
out：ndarray、None 或 ndarray 和 None 元组，可选
存储结果的位置。如果提供，必须具有输入广播到的形状。如果未提供或为 None，则返回一个新分配的数组。元组（仅作为关键字参数）的长度必须等于输出数量。
where：array_like，可选
此条件在输入上进行广播。在条件为 True 的位置，out数组将设置为 ufunc 结果。否则，out数组将保留其原始值。请注意，如果通过默认的out=None创建未初始化的out数组，则其中条件为 False 的位置将保持未初始化。
**kwargs
其他关键字参数，请参阅 ufunc 文档。
返回：
y：ndarray 或标量
x的绝对值，返回值始终为浮点数。如果x是标量，则为标量。
参见
包括complex类型的绝对值。
示例
>>> np.fabs(-1)
1.0
>>> np.fabs([-1.2, 1.2])
array([ 1.2, 1.2])
numpy.sign
numpy.sign(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'sign'>
返回一个标识数字符号的元素指示。
sign 函数返回-1（如果 x < 0）、0（如果 x==0）、1（如果 x > 0）。对于 nan 输入，返回 nan。
对于复数输入，sign 函数返回 sign(x.real) + 0j（如果 x.real != 0），否则返回 sign(x.imag) + 0j。
对于复数 nan 输入，返回复数（nan, 0）。
参数：
x：array_like
输入值。
out：ndarray、None 或 ndarray 和 None 的元组，可选
存储结果的位置。如果提供，它必须具有输入广播到的形状。如果未提供或为 None，则返回一个新分配的数组。一个元组（仅作为关键字参数）必须具有与输出数量相等的长度。
where：array_like，可选
此条件在输入上进行广播。在条件为 True 的位置，out 数组将设置为 ufunc 结果。在其他地方，out 数组将保留其原始值。请注意，如果通过默认的 out=None 创建了未初始化的 out 数组，则其中条件为 False 的位置将保持未初始化。
**kwargs
关于其他仅限关键字参数，请参阅 ufunc 文档。
返回：
y：ndarray
x的符号。如果 x 是标量，则这是一个标量。
注释
复数的符号有不止一个常见定义。这里使用的定义相当于 (x/\sqrt{x*x})，这与常见的另一个定义 (x/|x|) 不同。
示例
>>> np.sign([-5., 4.5])
array([-1., 1.])
>>> np.sign(0)
0
>>> np.sign(5-2j)
(1+0j)
numpy.heaviside
原文：
numpy.org/doc/1.26/reference/generated/numpy.heaviside.html
numpy.heaviside(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'heaviside'>
计算海维赛德阶跃函数。
海维赛德阶跃函数定义为：
0 if x1 < 0
heaviside(x1, x2) = x2 if x1 == 0
1 if x1 > 0
x2处常常取 0.5，但有时也使用 0 和 1。
参数：
x1array_like
输入值。
x2array_like
当 x1 为 0 时的函数值。如果x1.shape != x2.shape，则它们必须能够广播到一个共同的形状（这将成为输出的形状）。
outndarray、None 或 ndarray 和 None 的元组，可选
存储结果的位置。如果提供，必须具有输入广播到的形状。如果未提供或为 None，则返回新分配的数组。元组（仅作为关键字参数）的长度必须等于输出的数量。
wherearray_like，可选
此条件在输入上进行广播。在条件为 True 的位置，out数组将被设置为 ufunc 结果。否则，out数组将保留其原始值。请注意，如果通过默认的out=None创建了未初始化的out数组，则其中条件为 False 的位置将保持未初始化状态。
**kwargs
对于其他仅关键字参数，请参阅 ufunc 文档。
返回：
outndarray 或标量
输出数组，对x1的逐元素海维赛德阶跃函数。如果x1和x2都是标量，则这是一个标量。
注
在 1.13.0 版本中新增。
参考文献
示例
>>> np.heaviside([-1.5, 0, 2.0], 0.5)
array([ 0\. , 0.5, 1\. ])
>>> np.heaviside([-1.5, 0, 2.0], 1)
array([ 0., 1., 1.])
numpy.nan_to_num
原文：
numpy.org/doc/1.26/reference/generated/numpy.nan_to_num.html
numpy.nan_to_num(x, copy=True, nan=0.0, posinf=None, neginf=None)
用 0 替换 NaN，并用大的有限数（默认行为）或使用 nan、posinf 和/或 neginf 关键字定义的数值来替换无穷大。
如果 x 是不精确的，则 NaN 被 0 或用户在 nan 关键字中定义的值替换，无穷大被x.dtype 可表示的最大有限浮点数或用户在 posinf 关键字中定义的值替换，-无穷大被x.dtype 可表示的最小有限浮点数或用户在 neginf 关键字中定义的值替换。
对于复数数据类型，上述操作分别应用于 x 的实部和虚部。
如果 x 不是不精确的，则不进行替换。
参数：
x标量或数组-like
输入数据。
copybool, optional
是否创建 x 的副本（True）或在原地替换值（False）。仅当转换为数组不需要副本时，原地操作才会发生。默认为 True。
新版 1.13。
nanint, float, optional
用于填充 NaN 值的值。如果未传递值，则 NaN 值将被 0.0 替换。
新版 1.17。
posinfint, float, optional
用于填充正无穷大值的值。如果未传递值，则正无穷大值将被一个非常大的数值替换。
新版 1.17。
neginfint, float, optional
用于填充负无穷大值的值。如果未传递值，则负无穷大值将被一个非常小（或负）的数值替换。
新版 1.17。
返回值：
outndarray
x，非有限值被替换后的结果。如果 copy 为 False，则可能是 x 本身。
另请参见
isinf
显示哪些元素为正无穷大或负无穷大。
isneginf
显示哪些元素为负无穷大。
isposinf
显示哪些元素为正无穷大。
isnan
显示哪些元素为非数字（NaN）。
isfinite
显示哪些元素为有限的（不是 NaN，也不是无穷大）。
注释
NumPy 使用 IEEE 754 二进制浮点算术标准。这意味着非数字与无穷大不等价。
示例
>>> np.nan_to_num(np.inf)
1.7976931348623157e+308
>>> np.nan_to_num(-np.inf)
-1.7976931348623157e+308
>>> np.nan_to_num(np.nan)
0.0
>>> x = np.array([np.inf, -np.inf, np.nan, -128, 128])
>>> np.nan_to_num(x)
array([ 1.79769313e+308, -1.79769313e+308, 0.00000000e+000, # may vary
-1.28000000e+002, 1.28000000e+002])
>>> np.nan_to_num(x, nan=-9999, posinf=33333333, neginf=33333333)
array([ 3.3333333e+07, 3.3333333e+07, -9.9990000e+03,
-1.2800000e+02, 1.2800000e+02])
>>> y = np.array([complex(np.inf, np.nan), np.nan, complex(np.nan, np.inf)])
array([ 1.79769313e+308, -1.79769313e+308, 0.00000000e+000, # may vary
-1.28000000e+002, 1.28000000e+002])
>>> np.nan_to_num(y)
array([ 1.79769313e+308 +0.00000000e+000j, # may vary
0.00000000e+000 +0.00000000e+000j,
0.00000000e+000 +1.79769313e+308j])
>>> np.nan_to_num(y, nan=111111, posinf=222222)
array([222222.+111111.j, 111111\. +0.j, 111111.+222222.j])
numpy.real_if_close
原文：
numpy.org/doc/1.26/reference/generated/numpy.real_if_close.html
numpy.real_if_close(a, tol=100)
如果输入是复数，并且所有虚部接近于零，则返回实部。
“接近零”被定义为tol * a类型的机器 epsilon。
参数：
aarray_like
输入数组。
tolfloat
复数数组中元素的机器 epsilon 公差。如果公差<=1，则使用绝对公差。
返回：
outndarray
如果a是实数，则输出的类型与a的类型相同。如果a有复数元素，则返回类型为 float。
参见
real, imag, angle
注意
机器 epsilon 因机器和数据类型而异，但大多数平台上的 Python 浮点数具有相同的机器 epsilon，等于 2.2204460492503131e-16。您可以使用‘np.finfo(float).eps’打印出浮点数的机器 epsilon。
例子
>>> np.finfo(float).eps
2.2204460492503131e-16 # may vary
>>> np.real_if_close([2.1 + 4e-14j, 5.2 + 3e-15j], tol=1000)
array([2.1, 5.2])
>>> np.real_if_close([2.1 + 4e-13j, 5.2 + 3e-15j], tol=1000)
array([2.1+4.e-13j, 5.2 + 3e-15j])
numpy.interp
numpy.interp(x, xp, fp, left=None, right=None, period=None)
单调递增样本点的一维线性插值。
返回对具有给定离散数据点（xp、fp）的函数的一维分段线性插值，计算结果为x处的值。
参数：
x 类型为数组
要评估插值值的 x 坐标。
xp 1-D 浮点数序列
数据点的 x 坐标，如果未指定 period 参数，则必须递增。 否则，在归一化周期边界后，将对 xp 进行内部排序，并执行 xp = xp % period。
fp 1-D 浮点数或复数序列
数据点的 y 坐标，与xp的长度相同。
left 可选的浮点数或与 fp 对应的复数
x < xp[0] 时返回的值，默认为 fp[0]。
right 可选的浮点数或与 fp 对应的复数
x > xp[-1] 时返回的值，默认为 fp[-1]。
period 为 None 或浮点数，可选
x 坐标的周期。此参数允许正确插值角度坐标。 如果指定了 period 参数，则忽略参数 left 和 right。
新版本 1.10.0 中新增。
返回：
y 类型为浮点数或与 fp 对应的复数或数组
插值值，与 x 的形状相同。
引发：
值错误
如果 xp 和 fp 的长度不同 如果 xp 或 fp 不是 1-D 序列 如果 period == 0
警告
预计 x 坐标序列递增，但没有明确强制执行。 但是，如果序列 xp 非递增，则插值结果毫无意义。
请注意，由于 NaN 不可排序，因此 xp 也不能包含 NaN。
对于 xp 严格递增的简单检查是：
np.all(np.diff(xp) > 0)
另请参阅
示例
>>> xp = [1, 2, 3]
>>> fp = [3, 2, 0]
>>> np.interp(2.5, xp, fp)
1.0
>>> np.interp([0, 1, 1.5, 2.72, 3.14], xp, fp)
array([3\. , 3\. , 2.5 , 0.56, 0\. ])
>>> UNDEF = -99.0
>>> np.interp(3.14, xp, fp, right=UNDEF)
-99.0
绘制正弦函数的插值曲线：
>>> x = np.linspace(0, 2*np.pi, 10)
>>> y = np.sin(x)
>>> xvals = np.linspace(0, 2*np.pi, 50)
>>> yinterp = np.interp(xvals, x, y)
>>> import matplotlib.pyplot as plt
>>> plt.plot(x, y, 'o')
[<matplotlib.lines.Line2D object at 0x...>]
>>> plt.plot(xvals, yinterp, '-x')
[<matplotlib.lines.Line2D object at 0x...>]
>>> plt.show()
具有周期性 x 坐标的插值：
>>> x = [-180, -170, -185, 185, -10, -5, 0, 365]
>>> xp = [190, -190, 350, -350]
>>> fp = [5, 10, 3, 4]
>>> np.interp(x, xp, fp, period=360)
array([7.5 , 5\. , 8.75, 6.25, 3\. , 3.25, 3.5 , 3.75])
复数插值：
>>> x = [1.5, 4.0]
>>> xp = [2,3,5]
>>> fp = [1.0j, 0, 2+3j]
>>> np.interp(x, xp, fp)
array([0.+1.j , 1.+1.5j])
矩阵库（numpy.matlib）
这个模块包含了numpy命名空间中的所有函数，以下是返回矩阵而不是ndarray的替代函数。
也在 numpy 命名空间中返回矩阵的函数
mat(data[, dtype]) |
将输入解释为矩阵。 |
|---|---|
matrix(data[, dtype, copy]) |
注意
不推荐使用这个类，即使用于线性的
|
asmatrix(data[, dtype]) |
将输入解释为矩阵。 |
|---|---|
bmat(obj[, ldict, gdict]) |
从字符串，嵌套序列或数组构建矩阵对象。 |
在matlib中的替代函数
empty(shape[, dtype, order]) |
返回给定形状和类型的新矩阵，不初始化条目。 |
|---|---|
zeros(shape[, dtype, order]) |
返回给定形状和类型的 0 填充的矩阵。 |
ones(shape[, dtype, order]) |
全 1 矩阵。 |
eye(n[, M, k, dtype, order]) |
返回对角线上为 1，其他位置为 0 的矩阵。 |
identity(n[, dtype]) |
返回给定大小的正方形单位矩阵。 |
repmat(a, m, n) |
将 0-D 到 2-D 数组或矩阵重复 MxN 次。 |
rand(*args) |
返回具有给定形状的随机值矩阵。 |
randn(*args) |
返回具有来自“标准正态”分布的数据的随机矩阵。 |
numpy.matlib.empty
原文：
numpy.org/doc/1.26/reference/generated/numpy.matlib.empty.html
matlib.empty(shape, dtype=None, order='C')
返回一个给定形状和类型的新矩阵，不初始化条目。
参数：
shape整数或整数元组
空矩阵的形状。
dtype数据类型，可选
期望输出的数据类型。
order，可选
在内存中存储多维数据是按行主序（C 风格）还是按列主序（Fortran 风格）。
另请参阅
empty_like，zeros
注释
empty与zeros不同，不会将矩阵值设定为零，因此可能稍微更快。另一方面，它需要用户手动设置数组中的所有值，并且应谨慎使用。
示例
>>> import numpy.matlib
>>> np.matlib.empty((2, 2)) # filled with random data
matrix([[ 6.76425276e-320, 9.79033856e-307], # random
[ 7.39337286e-309, 3.22135945e-309]])
>>> np.matlib.empty((2, 2), dtype=int)
matrix([[ 6600475, 0], # random
[ 6586976, 22740995]])
numpy.matlib.zeros
原文：
numpy.org/doc/1.26/reference/generated/numpy.matlib.zeros.html
matlib.zeros(shape, dtype=None, order='C')
返回给定形状和类型的矩阵，填充为零。
参数：
shape整数或整数序列
矩阵的形状
dtype数据类型，可选
矩阵的所需数据类型，默认为浮点型。
order，可选
是否以 C 或 Fortran 连续顺序存储结果，默认为‘C’。
返回：
out矩阵
给定形状、数据类型和顺序的零矩阵。
另请参阅
numpy.zeros
等效的数组函数。
matlib.ones
返回一个全为 1 的矩阵。
笔记
如果shape长度为一即(N,)，或者是一个标量N，out 就成为形状为(1,N)的单行矩阵。
例子
>>> import numpy.matlib
>>> np.matlib.zeros((2, 3))
matrix([[0., 0., 0.],
[0., 0., 0.]])
>>> np.matlib.zeros(2)
matrix([[0., 0.]])
numpy.matlib.ones
原文：
numpy.org/doc/1.26/reference/generated/numpy.matlib.ones.html
matlib.ones(shape, dtype=None, order='C')
全 1 矩阵。
返回具有给定形状和类型的矩阵，其中填充为 1。
参数：
形状
矩阵的形状
dtype数据类型，可选
矩阵的期望数据类型，默认为 np.float64。
顺序，可选
是否以 C 或 Fortran 连续顺序存储矩阵，默认为‘C’。
返回：
out矩阵
给定形状、dtype 和顺序的全 1 矩阵。
另请参阅
ones
一个全 1 数组。
matlib.zeros
零矩阵。
注释
如果shape长度为一，即(N,)，或者是一个标量 N，out 将变成形状为(1,N)的单行矩阵。
示例
>>> np.matlib.ones((2,3))
matrix([[1., 1., 1.],
[1., 1., 1.]])
>>> np.matlib.ones(2)
matrix([[1., 1.]])
numpy.matlib.eye
原文：
numpy.org/doc/1.26/reference/generated/numpy.matlib.eye.html
matlib.eye(n, M=None, k=0, dtype=<class 'float'>, order='C')
返回一个对角线上为一，其他地方为零的矩阵。
参数：
nint
输出中的行数。
Mint，可选
输出中的列数，默认为 n。
kint，可选
对角线的索引：0 表示主对角线，正值表示上对角线，负值表示下对角线。
dtypedtype，可选
返回矩阵的数据类型。
order，可选
是否将输出存储在行优先（C 风格）或列优先（Fortran 风格）的内存顺序中。
版本 1.14.0 中的新功能。
返回：
I矩阵
一个 n x M 的矩阵，其中所有元素都等于零，除了第 k 条对角线，其值等于一。
另请参阅
numpy.eye
等效的数组函数。
identity
方阵单位矩阵。
示例
>>> import numpy.matlib
>>> np.matlib.eye(3, k=1, dtype=float)
matrix([[0., 1., 0.],
[0., 0., 1.],
[0., 0., 0.]])
numpy.matlib.identity
原文：
numpy.org/doc/1.26/reference/generated/numpy.matlib.identity.html
matlib.identity(n, dtype=None)
返回给定尺寸的单位矩阵。
参数：
n整数
返回的单位矩阵的尺寸。
dtype数据类型，可选项
输出的数据类型。默认为float。
返回：
out矩阵
n x n矩阵，其主对角线设置为 1，其他所有元素为零。
另请参阅
numpy.identity
等效的数组函数。
matlib.eye
更一般的矩阵单位函数。
示例
>>> import numpy.matlib
>>> np.matlib.identity(3, dtype=int)
matrix([[1, 0, 0],
[0, 1, 0],
[0, 0, 1]])
numpy.matlib.repmat
原文：
numpy.org/doc/1.26/reference/generated/numpy.matlib.repmat.html
matlib.repmat(a, m, n)
将 0 维到 2 维的数组或矩阵a重复 MxN 次。
参数:
aarray_like
要重复的数组或矩阵。
m, nint
重复a在第一和第二轴上重复的次数。
返回:
outndarray
重复a的结果。
示例
>>> import numpy.matlib
>>> a0 = np.array(1)
>>> np.matlib.repmat(a0, 2, 3)
array([[1, 1, 1],
[1, 1, 1]])
>>> a1 = np.arange(4)
>>> np.matlib.repmat(a1, 2, 2)
array([[0, 1, 2, 3, 0, 1, 2, 3],
[0, 1, 2, 3, 0, 1, 2, 3]])
>>> a2 = np.asmatrix(np.arange(6).reshape(2, 3))
>>> np.matlib.repmat(a2, 2, 3)
matrix([[0, 1, 2, 0, 1, 2, 0, 1, 2],
[3, 4, 5, 3, 4, 5, 3, 4, 5],
[0, 1, 2, 0, 1, 2, 0, 1, 2],
[3, 4, 5, 3, 4, 5, 3, 4, 5]])
numpy.matlib.rand
原文：
numpy.org/doc/1.26/reference/generated/numpy.matlib.rand.html
matlib.rand(*args)
返回一个给定形状的随机值矩阵。
创建给定形状的矩阵，并用来自0, 1)上均匀分布的随机样本进行传播。
参数:
*argsArguments
输出的形状。如果给定 N 个整数，则每个整数指定一个维度的大小。如果给定为一个元组，则该元组给出完整的形状。
返回:
outndarray
形状由args给出的随机值矩阵。
另请参阅
[randn, numpy.random.RandomState.rand
例子
>>> np.random.seed(123)
>>> import numpy.matlib
>>> np.matlib.rand(2, 3)
matrix([[0.69646919, 0.28613933, 0.22685145],
[0.55131477, 0.71946897, 0.42310646]])
>>> np.matlib.rand((2, 3))
matrix([[0.9807642 , 0.68482974, 0.4809319 ],
[0.39211752, 0.34317802, 0.72904971]])
如果第一个参数是一个元组，则忽略其他参数：
>>> np.matlib.rand((2, 3), 4)
matrix([[0.43857224, 0.0596779 , 0.39804426],
[0.73799541, 0.18249173, 0.17545176]])
numpy.matlib.randn
原文：
numpy.org/doc/1.26/reference/generated/numpy.matlib.randn.html
matlib.randn(*args)
返回一个包含来自“标准正态”分布的数据的随机矩阵。
randn 生成一个填充有从单变量“正态”（高斯）分布中抽样得到的随机浮点数的矩阵，均值为 0，方差为 1。
参数：
*args参数
输出的形状。如果给出为 N 个整数，每个整数指定一个维度的大小。如果给出为一个元组，这个元组给出了完整的形状。
返回：
Z浮点数矩阵
一个来自标准正态分布的浮点样本矩阵。
另见
rand,
注意
对于均值为mu，标准差为sigma的正态分布的随机样本，可以使用：
sigma * np.matlib.randn(...) + mu
示例
>>> np.random.seed(123)
>>> import numpy.matlib
>>> np.matlib.randn(1)
matrix([[-1.0856306]])
>>> np.matlib.randn(1, 2, 3)
matrix([[ 0.99734545, 0.2829785 , -1.50629471],
[-0.57860025, 1.65143654, -2.42667924]])
一个二乘四的矩阵，样本来自均值为 3，标准差为 2.5 的正态分布：
>>> 2.5 * np.matlib.randn((2, 4)) + 3
matrix([[1.92771843, 6.16484065, 0.83314899, 1.30278462],
[2.76322758, 6.72847407, 1.40274501, 1.8900451 ]])
杂项例程
性能调整
setbufsize(size) |
设置在 ufunc 中使用的缓冲区的大小。 |
|---|---|
getbufsize() |
返回在 ufunc 中使用的缓冲区的大小。 |
存储范围
shares_memory(a, b, /[, max_work]) |
确定两个数组是否共享内存。 |
|---|---|
may_share_memory(a, b, /[, max_work]) |
确定两个数组是否可能共享内存 |
byte_bounds(a) |
返回数组的端点的指针。 |
数组混合
lib.mixins.NDArrayOperatorsMixin() |
使用 array_ufunc 定义所有操作符特殊方法的 Mixin。 |
|---|
NumPy 版本比较
lib.NumpyVersion(vstring) |
解析和比较 numpy 版本字符串。 |
|---|
实用程序
get_include() |
返回包含 NumPy *.h 头文件的目录。 |
|---|---|
show_config([mode]) |
显示构建和使用 NumPy 的库和系统信息 |
show_runtime() |
打印系统中各种资源的信息，包括可用的内在支持和正在使用的 BLAS/LAPACK 库 |
deprecate(*args, **kwargs) |
发出 DeprecationWarning，将警告添加到 old_name 的文档字符串中，重新绑定 old_name.__name__ 并返回新的函数对象。 |
deprecate_with_doc(msg) |
废弃一个函数并在其文档字符串中包含弃用信息。 |
broadcast_shapes(*args) |
将输入形状广播到单个形状。 |
类似于 Matlab 的函数
who([vardict]) |
打印给定字典中的 NumPy 数组。 |
|---|---|
disp(mesg[, device, linefeed]) |
在设备上显示消息。 |
异常和警告 (numpy.exceptions)
NumPy 中使用的常规异常。请注意，一些异常可能是模块特定的，比如线性代数错误。
NumPy 版本新功能：1.25
异常模块是 NumPy 1.25 版本中的新功能。较旧的异常仍可通过主 NumPy 命名空间进行兼容性访问。
警告
ComplexWarning |
将复数 dtype 转换为实数 dtype 时引发的警告。 |
|---|---|
VisibleDeprecationWarning |
明显弃用警告。 |
异常
AxisError(axis[, ndim, msg_prefix]) |
提供的轴无效。 |
|---|---|
DTypePromotionError |
无法将多个 DTypes 转换为公共类型。 |
TooHardError |
max_work 已超出。 |
DType 类和实用工具(numpy.dtypes)
该模块提供了特定于 dtypes 的功能和它们的类。关于 dtypes 的更一般信息，还请参阅 numpy.dtype 和 数据类型对象（dtype）。
与内置的 types 模块类似，此子模块定义了直接使用较少的类型（类）。
NumPy 版本新功能：1.25
dtypes 模块是 NumPy 1.25 版本中的新功能。之前 DType 类只能间接访问。
DType 类
以下是对应 NumPy dtype 实例和 NumPy 标量类型的类。这些类可用于 isinstance 检查，也可以直接实例化或使用。直接使用这些类并不典型，因为它们的标量对应项（例如 np.float64）或类似 "float64" 的字符串可以用作替代。
| 分组 | DType 类 |
|---|---|
| 布尔 | BoolDType |
| 比特大小整数 | Int8DType, UInt8DType, Int16DType, UInt16DType, Int32DType, UInt32DType, Int64DType, UInt64DType |
| C 命名整数（可以是别名） | ByteDType, UByteDType, ShortDType, UShortDType, IntDType, UIntDType, LongDType, ULongDType, LongLongDType, ULongLongDType |
| 浮点数 | Float16DType, Float32DType, Float64DType, LongDoubleDType |
| 复数 | Complex64DType, Complex128DType, CLongDoubleDType |
| 字符串 | BytesDType, BytesDType |
| 时间 | DateTime64DType, TimeDelta64DType |
| 其他 | ObjectDType, VoidDType |
性能调优
setbufsize(size) |
设置 ufuncs 中使用的缓冲区的大小。 |
|---|---|
getbufsize() |
返回 ufuncs 中使用的缓冲区的大小。 |
内存范围
shares_memory(a, b, /[, max_work]) |
确定两个数组是否共享内存。 |
|---|---|
may_share_memory(a, b, /[,��max_work]) |
确定两个数组是否可能共享内存 |
byte_bounds(a) |
返回数组的端点指针。 |
数组混合类
lib.mixins.NDArrayOperatorsMixin() |
使用 array_ufunc 定义所有操作特殊方法的混合类。 |
|---|
NumPy 版本比较
lib.NumpyVersion(vstring) |
解析和比较 NumPy 版本字符串。 |
|---|
实用工具
get_include() |
返回包含 NumPy *.h 头文件的目录。 |
|---|---|
show_config([mode]) |
显示 NumPy 构建和使用的库和系统信息 |
show_runtime() |
打印系统中各种资源的信息，包括可用的内在支持和正在使用的 BLAS/LAPACK 库 |
deprecate(*args, **kwargs) |
发出 DeprecationWarning，将警告添加到 old_name 的文档字符串，重新绑定 old_name.__name__ 并返回新的函数对象。 |
deprecate_with_doc(msg) |
弃用一个函数并在其文档中包含该弃用信息。 |
broadcast_shapes(*args) |
将输入形状广播为单个形状。 |
类似 Matlab 的函数
who([vardict]) |
打印给定字典中的 NumPy 数组。 |
|---|---|
disp(mesg[, device, linefeed]) |
在设备上显示消息。 |
异常和警告 (numpy.exceptions)
NumPy 使用的常见异常。请注意，有些异常可能是特定于模块的，例如线性代数错误。
NumPy 版本 1.25 新功能
异常模块是 NumPy 1.25 中的新内容。 以前版本的异常仍通过主要的 NumPy 命名空间可用，以确保兼容性。
警告
ComplexWarning |
当将复杂 dtype 转换为实数 dtype 时引发的警告。 |
|---|---|
VisibleDeprecationWarning |
可见性废弃警告。 |
异常
AxisError(axis[, ndim, msg_prefix]) |
提供的轴无效。 |
|---|---|
DTypePromotionError |
无法将多个 DType 转换为共同的一个。 |
TooHardError |
超过了最大工作量。 |
DType 类和实用程序（numpy.dtypes)
此模块包含与特定 dtype 相关的功能和类。 关于 dtype 的更一般信息，请参阅numpy.dtype和数据类型对象（dtype）。
类似于内置的types模块，此子模块定义了不常直接使用的类型（类）。
NumPy 新版本：1.25
dtypes 模块是 NumPy 1.25 中的新内容。 以前，DType 类只能间接访问。
DType 类
以下是相应的 NumPy dtype 实例和 NumPy 标量类型的类。 可以在isinstance检查中使用这些类，也可以直接实例化或使用。 通常不会直接使用这些类，因为可以使用它们的标量对应物（例如np.float64）或像"float64"这样的字符串。
| 分组 | DType 类 |
|---|---|
| 布尔 | BoolDType |
| 位大小整数 | Int8DType, UInt8DType, Int16DType, UInt16DType, Int32DType, UInt32DType, Int64DType, UInt64DType |
| 以 C 命名的整数（可能是别名） | ByteDType, UByteDType, ShortDType, UShortDType, IntDType, UIntDType, LongDType, ULongDType, LongLongDType, ULongLongDType |
| 浮点数 | Float16DType, Float32DType, Float64DType, LongDoubleDType |
| 复数 | Complex64DType, Complex128DType, CLongDoubleDType |
| 字符串 | BytesDType, BytesDType |
| Times | DateTime64DType, TimeDelta64DType |
| 其他 | ObjectDType, VoidDType |
异常与警告（numpy.exceptions)
NumPy 使用的常规异常。 请注意，一些异常可能是特定于模块的，例如线性代数错误。
NumPy 新版本：1.25
异常模块是 NumPy 1.25 中的新内容。较旧的异常保留在主 NumPy 命名空间中以确保兼容性。
警告
ComplexWarning |
将复数数据类型转换为实数数据类型时引发警告。 |
|---|---|
VisibleDeprecationWarning |
可见的已弃用警告。 |
异常
AxisError(axis[, ndim, msg_prefix]) |
供应的轴无效。 |
|---|---|
DTypePromotionError |
无法将多个数据类型转换为公共数据类型。 |
TooHardError |
超出最大工作量。 |
警告
ComplexWarning |
将复数数据类型转换为实数数据类型时引发警告。 |
|---|---|
VisibleDeprecationWarning |
可见的已弃用警告。 |
异常
AxisError(axis[, ndim, msg_prefix]) |
供应的轴无效。 |
|---|---|
DTypePromotionError |
无法将多个数据类型转换为公共数据类型。 |
TooHardError |
超出最大工作量。 |
数据类型类和实用程序(numpy.dtypes)
该模块包含特定的数据类型相关功能及其类。有关数据类型的更一般信息，还请参阅numpy.dtype和数据类型对象（dtype）。
与内置的types模块类似，这个子模块定义了不常直接使用的类型（类）。
NumPy 版本更新内容：1.25
数据类型模块是 NumPy 1.25 中的新内容。以前的数据类型类只能间接访问。
数据类型类
以下是相应的 NumPy dtype 实例和 NumPy 标量类型的类。可以在isinstance检查中使用这些类，也可以直接实例化或使用。直接使用这些类并不典型，因为可以使用它们的标量对应物（例如np.float64）或类似"float64"的字符串。
| 类别 | DType 类 |
|---|---|
| --- | --- |
| 布尔类型 | BoolDType |
| 位大小的整数 | Int8DType, UInt8DType, Int16DType, UInt16DType, Int32DType, UInt32DType, Int64DType, UInt64DType |
| C 命名整数（可能是别名） | ByteDType, UByteDType, ShortDType, UShortDType, IntDType, UIntDType, LongDType, ULongDType, LongLongDType, ULongLongDType |
| 浮点数 | Float16DType, Float32DType, Float64DType, LongDoubleDType |
| 复数 | Complex64DType, Complex128DType, CLongDoubleDType |
| 字符串 | BytesDType, BytesDType |
| 时间 | DateTime64DType, TimeDelta64DType |
| 其他 | ObjectDType, VoidDType |
DType 类
以下是相应的 NumPy dtype 实例和 NumPy 标量类型的类。可以在isinstance检查中使用这些类，也可以直接实例化或使用。直接使用这些类并不典型，因为可以使用它们的标量对应物（例如np.float64）或类似"float64"的字符串。
| 类别 | DType 类 |
|---|---|
| --- | --- |
| 布尔类型 | BoolDType |
| 位大小的整数 | Int8DType, UInt8DType, Int16DType, UInt16DType, Int32DType, UInt32DType, Int64DType, UInt64DType |
| C 命名整数（可能是别名） | ByteDType, UByteDType, ShortDType, UShortDType, IntDType, UIntDType, LongDType, ULongDType, LongLongDType, ULongLongDType |
| 浮点数 | Float16DType, Float32DType, Float64DType, LongDoubleDType |
| 复数 | Complex64DType, Complex128DType, CLongDoubleDType |
| 字符串 | BytesDType, BytesDType |
| 时间 | DateTime64DType, TimeDelta64DType |
| 其他 | ObjectDType, VoidDType |
numpy.setbufsize
原文：
numpy.org/doc/1.26/reference/generated/numpy.setbufsize.html
numpy.setbufsize(size)
设置在 ufuncs 中使用的缓冲区大小。
参数：
size整数
缓冲区大小。
numpy.getbufsize
原文：
numpy.org/doc/1.26/reference/generated/numpy.getbufsize.html
numpy.getbufsize()
返回 ufunc 使用的缓冲区大小。
返回：
getbufsizeint
ufunc 缓冲区大小，以字节为单位。
numpy.shares_memory
原文：
numpy.org/doc/1.26/reference/generated/numpy.shares_memory.html
numpy.shares_memory(a, b, /, max_work=None)
确定两个数组是否共享内存。
警告
除非将max_work设置为有限数或MAY_SHARE_BOUNDS，否则该函数对某些输入可能会以指数级慢。如果有疑问，请使用numpy.may_share_memory。
参数：
a, bndarray
输入数组
max_workint, 可选
用于解决重叠问题的工作量（要考虑的候选解的最大数量）。 下面识别了一些特殊值：
max_work=MAY_SHARE_EXACT（默认）
问题已被精确解决。在这种情况下，仅当数组之间存在共享元素时，函数才返回 True。在某些情况下，寻找确切解可能需要很长时间。
max_work=MAY_SHARE_BOUNDS
仅检查 a 和 b 的内存边界。
返回：
outbool
抛出：
numpy.exceptions.TooHardError
超过 max_work。
另见
may_share_memory
示例
>>> x = np.array([1, 2, 3, 4])
>>> np.shares_memory(x, np.array([5, 6, 7]))
False
>>> np.shares_memory(x[::2], x)
True
>>> np.shares_memory(x[::2], x[1::2])
False
检查两个数组是否共享内存是 NP 完全的，并且运行时间可能会随维数的增加呈指数级增长。因此，max_work通常应设置为有限数，因为可能构造需要运行极长时间的示例：
>>> from numpy.lib.stride_tricks import as_strided
>>> x = np.zeros([192163377], dtype=np.int8)
>>> x1 = as_strided(x, strides=(36674, 61119, 85569), shape=(1049, 1049, 1049))
>>> x2 = as_strided(x[64023025:], strides=(12223, 12224, 1), shape=(1049, 1049, 1))
>>> np.shares_memory(x1, x2, max_work=1000)
Traceback (most recent call last):
...
numpy.exceptions.TooHardError: Exceeded max_work
在没有设置max_work的情况下运行np.shares_memory(x1, x2)大约需要 1 分钟。可能还会找到需要更长时间解决的问题。
numpy.may_share_memory
原文：
numpy.org/doc/1.26/reference/generated/numpy.may_share_memory.html
numpy.may_share_memory(a, b, /, max_work=None)
确定两个数组是否可能共享内存
返回 True 并不一定意味着这两个数组共享任何元素。这只是表示它们可能共享。
默认情况下，只检查 a 和 b 的内存边界。
参数：
a, bndarray
输入数组
max_workint，可选
解决重叠问题所需的工作。详细信息请参阅shares_memory。默认情况下，may_share_memory会执行边界检查。
返回：
outbool
另请参阅
shares_memory
示例
>>> np.may_share_memory(np.array([1,2]), np.array([5,8,9]))
False
>>> x = np.zeros([3, 4])
>>> np.may_share_memory(x[:,0], x[:,1])
True
numpy.byte_bounds
原文：
numpy.org/doc/1.26/reference/generated/numpy.byte_bounds.html
numpy.byte_bounds(a)
返回指向数组端点的指针。
参数：
andarray
输入数组。它必须符合数组接口的 Python 端。
返回：
(low, high)包含 2 个整数的元组
第一个整数是数组的第一个字节，第二个整数是数组的最后一个字节的下一个位置。如果a不是连续的，则不会使用(low, high)值之间的每个字节。
示例
>>> I = np.eye(2, dtype='f'); I.dtype
dtype('float32')
>>> low, high = np.byte_bounds(I)
>>> high - low == I.size*I.itemsize
True
>>> I = np.eye(2); I.dtype
dtype('float64')
>>> low, high = np.byte_bounds(I)
>>> high - low == I.size*I.itemsize
True
numpy.lib.mixins.NDArrayOperatorsMixin
原文：
numpy.org/doc/1.26/reference/generated/numpy.lib.mixins.NDArrayOperatorsMixin.html
class numpy.lib.mixins.NDArrayOperatorsMixin
使用 array_ufunc 定义所有操作符特殊方法的混合类。
该类实现了 Python 几乎所有内置操作符的特殊方法，在operator模块中定义，包括比较（==，>等）和算术（+，*，-等），通过推迟到__array_ufunc__方法，这些子类必须实现。
它对于编写不继承自numpy.ndarray的类非常有用，但应支持算术和 numpy 通用函数，就像在A Mechanism for Overriding Ufuncs中描述的那样。
作为一个简单的例子，考虑这个ArrayLike类的实现，它只是简单地包装了一个 NumPy 数组，并确保任何算术操作的结果也是一个ArrayLike对象：
class ArrayLike(np.lib.mixins.NDArrayOperatorsMixin):
def __init__(self, value):
self.value = np.asarray(value)
# One might also consider adding the built-in list type to this
# list, to support operations like np.add(array_like, list)
_HANDLED_TYPES = (np.ndarray, numbers.Number)
def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
out = kwargs.get('out', ())
for x in inputs + out:
# Only support operations with instances of _HANDLED_TYPES.
# Use ArrayLike instead of type(self) for isinstance to
# allow subclasses that don't override __array_ufunc__ to
# handle ArrayLike objects.
if not isinstance(x, self._HANDLED_TYPES + (ArrayLike,)):
return NotImplemented
# Defer to the implementation of the ufunc on unwrapped values.
inputs = tuple(x.value if isinstance(x, ArrayLike) else x
for x in inputs)
if out:
kwargs['out'] = tuple(
x.value if isinstance(x, ArrayLike) else x
for x in out)
result = getattr(ufunc, method)(*inputs, **kwargs)
if type(result) is tuple:
# multiple return values
return tuple(type(self)(x) for x in result)
elif method == 'at':
# no return value
return None
else:
# one return value
return type(self)(result)
def __repr__(self):
return '%s(%r)' % (type(self).__name__, self.value)
在ArrayLike对象和数字或 numpy 数组之间的交互中，结果总是另一个ArrayLike：
>>> x = ArrayLike([1, 2, 3])
>>> x - 1
ArrayLike(array([0, 1, 2]))
>>> 1 - x
ArrayLike(array([ 0, -1, -2]))
>>> np.arange(3) - x
ArrayLike(array([-1, -1, -1]))
>>> x - np.arange(3)
ArrayLike(array([1, 1, 1]))
请注意，与numpy.ndarray不同，ArrayLike不允许使用任意未识别类型进行操作。这确保了与 ArrayLike 的交互保持良好定义的类型转换层次结构。
在 1.13 版中新推出。
numpy.lib.NumpyVersion
原文：
numpy.org/doc/1.26/reference/generated/numpy.lib.NumpyVersion.html
class numpy.lib.NumpyVersion(vstring)
解析和比较 numpy 版本字符串。
NumPy 采用以下版本控制方案（给出的数字是示例；原则上它们可以大于 9）：
-
发布版本：‘1.8.0’，‘1.8.1’，等等。
-
Alpha：‘1.8.0a1’，‘1.8.0a2’，等等。
-
Beta：‘1.8.0b1’，‘1.8.0b2’，等等。
-
发布候选版本：‘1.8.0rc1’，‘1.8.0rc2’，等等。
-
开发版本：‘1.8.0.dev-f1234afa’（添加了 git 提交哈希）
-
a1 后的开发版本：‘1.8.0a1.dev-f1234afa’，
‘1.8.0b2.dev-f1234afa’，‘1.8.1rc1.dev-f1234afa’，等等。
-
开发版本（没有 git 哈希可用）：‘1.8.0.dev-Unknown’
需要与有效的版本字符串或其他NumpyVersion 实例进行比较。注意，同一（预）发布的所有开发版本都相等。
新版本 1.9.0。
参数：
vstringstr
NumPy 版本字符串（np.__version__）。
示例
>>> from numpy.lib import NumpyVersion
>>> if NumpyVersion(np.__version__) < '1.7.0':
... print('skip')
>>> # skip
>>> NumpyVersion('1.7') # raises ValueError, add ".0"
Traceback (most recent call last):
...
ValueError: Not a valid numpy version string
numpy.get_include
原文：
numpy.org/doc/1.26/reference/generated/numpy.get_include.html
numpy.get_include()
返回包含 NumPy *.h 头文件的目录。
需要对 NumPy 进行编译的扩展模块应使用此函数来定位适当的包含目录。
注意
当使用distutils时，例如在setup.py中：
import numpy as np
...
Extension('extension_name', ...
include_dirs=[np.get_include()])
...
numpy.show_config
原文：
numpy.org/doc/1.26/reference/generated/numpy.show_config.html
numpy.show_config(mode='stdout')
显示构建和使用 NumPy 的库和系统信息
参数：
mode{‘stdout’, ‘dicts’}, optional.
指示如何显示配置信息。‘stdout’ 打印到控制台，‘dicts’ 返回配置的字典。
返回：
out{dict, None}
如果模式是‘dicts’，则返回一个字典，否则返回 None
另请参阅
get_include
返回包含 NumPy C 头文件的目录。
说明
- 如果安装了
pyyaml，‘stdout’ 模式将提供更易读的输出
numpy.show_runtime
原文：
numpy.org/doc/1.26/reference/generated/numpy.show_runtime.html
numpy.show_runtime()
打印系统中各种资源的信息，包括可用的内在支持和使用的 BLAS/LAPACK 库
自 1.24.0 版本开始新增。
另请参阅
show_config
显示系统中构建 NumPy 的库。
注释
-
如果可用，信息是通过 threadpoolctl 库获取的。
-
SIMD 相关信息源自
__cpu_features__、__cpu_baseline__和__cpu_dispatch__
numpy.deprecate
numpy.deprecate(*args, **kwargs)
会发出 DeprecationWarning 警告，将警告添加到old_name的文档字符串中，重新绑定old_name.__name__并返回新的函数对象。
此函数也可以用作装饰器。
参数：
func函数
要弃用的函数。
old_name字符串，可选
要弃用的函数的名称。默认值为 None，此时使用func的名称。
new_name字符串，可选
函数的新名称。默认值为 None，此时弃用信息为old_name已被弃用。如果给定，弃用信息为old_name已被弃用，应该使用new_name代替。
message字符串，可选
关于弃用的额外说明。在警告后在文档字符串中显示。
返回：
old_func函数
要弃用的函数。
示例
请注意，olduint打印 Deprecation Warning 后返回一个值：
>>> olduint = np.deprecate(np.uint)
DeprecationWarning: `uint64` is deprecated! # may vary
>>> olduint(6)
6
numpy.deprecate_with_doc
原文：
numpy.org/doc/1.26/reference/generated/numpy.deprecate_with_doc.html
numpy.deprecate_with_doc(msg)
废弃一个函数并在其文档字符串中包含该废弃信息。
此函数用作装饰器。它返回一个对象，可用于通过将要装饰的函数作为参数来发出 DeprecationWarning，这会将警告添加到要装饰的函数的文档字符串中，并返回新的函数对象。
参数：
msgstr
对于废弃的额外解释。在警告之后在文档字符串中显示。
返回值：
obj对象
另请参阅
deprecate
装饰一个函数，使其发出DeprecationWarning。
numpy.broadcast_shapes
原文：
numpy.org/doc/1.26/reference/generated/numpy.broadcast_shapes.html
numpy.broadcast_shapes(*args)
将输入形状广播到单一形状。
在这里了解更多有关广播的信息。
版本 1.20.0 中的新增内容。
参数：
*args整数的元组，或整数
要进行广播的形状。
返回：
元组
广播后的形状。
异常：
ValueError
如果形状不兼容，且不能按照 NumPy 的广播规则进行广播。
请参阅
广播
broadcast_arrays
broadcast_to
示例
>>> np.broadcast_shapes((1, 2), (3, 1), (3, 2))
(3, 2)
>>> np.broadcast_shapes((6, 7), (5, 6, 1), (7,), (5, 1, 7))
(5, 6, 7)
numpy.who
numpy.who(vardict=None)
打印给定字典中的 NumPy 数组。
如果没有传入字典或vardict为 None，则返回命名空间中的所有 NumPy 数组（全局字典中的所有 NumPy 数组）。
参数：
vardict字典，可选
一个可能含有 ndarrays 的字典。默认为 globals()。
返回：
outNone
返回'None'。
注意
打印出vardict中所有 ndarrays 的名称、形状、字节数和类型。
示例
>>> a = np.arange(10)
>>> b = np.ones(20)
>>> np.who()
Name Shape Bytes Type
===========================================================
a 10 80 int64
b 20 160 float64
Upper bound on total bytes = 240
>>> d = {'x': np.arange(2.0), 'y': np.arange(3.0), 'txt': 'Some str',
... 'idx':5}
>>> np.who(d)
Name Shape Bytes Type
===========================================================
x 2 16 float64
y 3 24 float64
Upper bound on total bytes = 40
numpy.disp
numpy.disp(mesg, device=None, linefeed=True)
在设备上显示消息。
参数：
mesgstr
要显示的消息。
deviceobject
用于写入消息的设备。如果为 None，默认为sys.stdout，非常类似于print。device需要具有write()和flush()方法。
linefeedbool，可选
是否打印换行符的选项。默认为 True。
引发：
AttributeError
如果device没有write()或flush()方法。
示例
除了sys.stdout，文件样对象也可以使用，因为它具有所需的两个方法：
>>> from io import StringIO
>>> buf = StringIO()
>>> np.disp(u'"Display" in a file', device=buf)
>>> buf.getvalue()
'"Display" in a file\n'
numpy.exceptions.ComplexWarning
numpy.org/doc/1.26/reference/generated/numpy.exceptions.ComplexWarning.html
exception exceptions.ComplexWarning
当将复数数据类型转换为实数数据类型时引发的警告。
在实现中，将复数转换为实数会丢弃其虚部，但这种行为可能并非用户真正想要的。
numpy.exceptions.VisibleDeprecationWarning
原文：
numpy.org/doc/1.26/reference/generated/numpy.exceptions.VisibleDeprecationWarning.html
exception exceptions.VisibleDeprecationWarning
明显的弃用警告。
默认情况下，Python 不会显示弃用警告，因此当非常显眼的警告是有帮助的时候，可以使用这个类，例如，因为使用方式很可能是用户错误。
numpy.exceptions.AxisError
原文：
numpy.org/doc/1.26/reference/generated/numpy.exceptions.AxisError.html
exception exceptions.AxisError(axis, ndim=None, msg_prefix=None)
提供的轴无效。
当指定了大于数组维度数量的 axis 参数时，会引发此异常。为了与针对较旧的 numpy 版本编写的代码兼容，该版本对此情况使用了 ValueError 和 IndexError 的混合方式进行引发异常，此异常子类化了这两种异常，以确保 except ValueError 和 except IndexError 语句仍然可以捕获到 AxisError。
版本 1.13 中新增。
参数：
axisint 或 str
超出范围的轴或自定义异常消息。如果提供了一个轴，则也应该指定ndim。
ndimint，可选
数组维度的数量。
msg_prefixstr，可选
异常消息的前缀。
示例
>>> array_1d = np.arange(10)
>>> np.cumsum(array_1d, axis=1)
Traceback (most recent call last):
...
numpy.exceptions.AxisError: axis 1 is out of bounds for array of dimension 1
负轴被保留：
>>> np.cumsum(array_1d, axis=-2)
Traceback (most recent call last):
...
numpy.exceptions.AxisError: axis -2 is out of bounds for array of dimension 1
类构造函数通常以轴和数组维数为参数：
>>> print(np.AxisError(2, 1, msg_prefix='error'))
error: axis 2 is out of bounds for array of dimension 1
或者可以传递自定义异常消息：
>>> print(np.AxisError('Custom error message'))
Custom error message
属性：
axisint，可选
超出范围的轴或如果提供了自定义异常消息则为 None。这应该是用户传递的轴，在解析负索引之前的任何规范化。
版本 1.22 中新增。
ndimint，可选
数组维度的数量或如果提供了自定义异常消息则为 None。
版本 1.22 中新增。
numpy.exceptions.DTypePromotionError
原文：
numpy.org/doc/1.26/reference/generated/numpy.exceptions.DTypePromotionError.html
exception exceptions.DTypePromotionError
多个数据类型无法转换为公共类型。
此异常源自TypeError，当数据类型无法转换为单一公共类型时引发。这可能是因为它们属于不同的类别/类型或是相同类型的不兼容实例（请参阅示例）。
注释
许多函数将使用提升来找到正确的结果和实现。对于这些函数，错误通常会与更具体的错误链接在一起，指示找不到输入数据类型的任何实现。
通常情况下，当arr1 == arr2安全地返回所有False时，应该将提升视为两个数组的数据类型之间的“无效”，因为数据类型在根本上是不同的。
示例
日期时间和复数是不兼容的类，不能进行提升：
>>> np.result_type(np.dtype("M8[s]"), np.complex128)
DTypePromotionError: The DType <class 'numpy.dtype[datetime64]'> could not
be promoted by <class 'numpy.dtype[complex128]'>. This means that no common
DType exists for the given inputs. For example they cannot be stored in a
single array unless the dtype is `object`. The full list of DTypes is:
(<class 'numpy.dtype[datetime64]'>, <class 'numpy.dtype[complex128]'>)
例如，对于结构化数据类型，结构可能不匹配，当给定具有字段数量不匹配的两个结构化数据类型时，会出现相同的DTypePromotionError：
>>> dtype1 = np.dtype([("field1", np.float64), ("field2", np.int64)])
>>> dtype2 = np.dtype([("field1", np.float64)])
>>> np.promote_types(dtype1, dtype2)
DTypePromotionError: field names `('field1', 'field2')` and `('field1',)`
mismatch.
numpy.exceptions.TooHardError
原文：
numpy.org/doc/1.26/reference/generated/numpy.exceptions.TooHardError.html
exception exceptions.TooHardError
超过了 max_work 上限。
当超过由max_work参数指定的需考虑的最大候选解数时，将引发此异常。 将有限数值分配给 max_work 可能会导致操作失败。
填充数组
pad(array, pad_width[, mode]) |
填充数组。 |
|---|
numpy.pad
numpy.pad(array, pad_width, mode='constant', **kwargs)
填充一个数组。
参数：
array秩为 N 的 array_like
要填充的数组。
pad_width
每个轴的边缘填充的值的数量。 ((before_1, after_1), ... (before_N, after_N))各轴的独特填充宽度。 (before, after)或((before, after),)为每个轴提供相同的前值和后值的填充量。 (pad,)或int是所有轴的前后填充宽度的快捷方式。
mode字符串或函数，可选
以下字符串值之一或用户提供的函数之一。
‘常数’（默认）
用常数值填充。
‘边界’
用 array 的边缘值填充。
‘线性斜坡’
用线性斜坡填充 end_value 和数组边缘值之间的值。
‘最大’
以每个轴上向量的所有或部分的最大值填充。
‘平均’
以每个轴上向量的所有或部分的均值填充。
‘中位数’
以向量的所有或部分的中位数值沿各轴填充。
‘最小值’
以每个轴的所有或部分的最小值填充。
‘反射’
以每个轴上向量的第一个和最后一个值的镜像填充。
‘对称’
以数组边缘为轴，对称地填充与数组边缘镜像的向量。
‘环绕’
用沿轴的向量的环绕填充。 第一个值用于填充结尾，最后一个值用于填充开头。
‘空’
用未定义的值填充。
新功能，版本 1.17 中引入。
<函数>
填充函数，请参阅注释。
stat_length序列或整数，可选
用于‘maximum’, ‘mean’, ‘median’和 ‘minimum’。 用于计算统计值的每个轴边缘处的值的数量。
((before_1, after_1), ... (before_N, after_N))各轴的独特统计长度。
(before, after)或((before, after),)为每个轴提供相同的前值和后值的统计长度。
(stat_length,)或int是before = after = statistic各轴的统计长度的快捷方式。
默认为None，使用整个轴。
constant_values序列或标量，可选
用于‘constant’。 用于为每个轴设置填充值的值。
((before_1, after_1), ... (before_N, after_N))各轴的独特填充常量。
(before, after)或((before, after),)为每个轴提供相同的前值和后值常量。
(constant,)或constant是所有轴的before = after = constant的快捷方式。
默认为 0。
end_values序列或标量，可选
用于‘linear_ramp’。 用于线性斜坡的结束值和将形成填充数组边缘的值。
((before_1, after_1), ... (before_N, after_N))各轴的独特结束值。
(before, after)或((before, after),)为每个轴提供相同的前值和后值。
(constant,)或constant是所有轴的before = after = constant的快捷方式。
默认为 0。
reflect_type，可选
用于 'reflect' 和 'symmetric'。'even' 风格是默认的，围绕边界值不变的反射。对于 'odd' 风格，数组的扩展部分是通过从反射值中减去两倍的边界值而创建的。
返回：
padndarray
通过 pad_width 增加形状的array的填充数组。
注意
新版本 1.7.0 中的新功能。
对于秩大于 1 的数组，一些后续轴的填充是从前面轴的填充计算而来。这在一个秩为 2 的数组中最容易理解，其中填充数组的角落是通过使用第一个轴的填充值来计算得到的。
如果使用填充函数，则应该原位修改一个一维数组。它具有以下签名：
padding_func(vector, iaxis_pad_width, iaxis, kwargs)
其中
vectorndarray
一维数组已经用零值填充。填充值为 vector[:iaxis_pad_width[0]] 和 vector[-iaxis_pad_width[1]:]。
iaxis_pad_widthtuple
一个由两个整数组成的元组，iaxis_pad_width[0] 表示在 vector 开头填充的值的数量，iaxis_pad_width[1] 表示在 vector 结尾填充的值的数量。
iaxisint
当前正在计算的轴。
kwargsdict
函数需要的任何关键字参数。
示例
>>> a = [1, 2, 3, 4, 5]
>>> np.pad(a, (2, 3), 'constant', constant_values=(4, 6))
array([4, 4, 1, ..., 6, 6, 6])
>>> np.pad(a, (2, 3), 'edge')
array([1, 1, 1, ..., 5, 5, 5])
>>> np.pad(a, (2, 3), 'linear_ramp', end_values=(5, -4))
array([ 5, 3, 1, 2, 3, 4, 5, 2, -1, -4])
>>> np.pad(a, (2,), 'maximum')
array([5, 5, 1, 2, 3, 4, 5, 5, 5])
>>> np.pad(a, (2,), 'mean')
array([3, 3, 1, 2, 3, 4, 5, 3, 3])
>>> np.pad(a, (2,), 'median')
array([3, 3, 1, 2, 3, 4, 5, 3, 3])
>>> a = [[1, 2], [3, 4]]
>>> np.pad(a, ((3, 2), (2, 3)), 'minimum')
array([[1, 1, 1, 2, 1, 1, 1],
[1, 1, 1, 2, 1, 1, 1],
[1, 1, 1, 2, 1, 1, 1],
[1, 1, 1, 2, 1, 1, 1],
[3, 3, 3, 4, 3, 3, 3],
[1, 1, 1, 2, 1, 1, 1],
[1, 1, 1, 2, 1, 1, 1]])
>>> a = [1, 2, 3, 4, 5]
>>> np.pad(a, (2, 3), 'reflect')
array([3, 2, 1, 2, 3, 4, 5, 4, 3, 2])
>>> np.pad(a, (2, 3), 'reflect', reflect_type='odd')
array([-1, 0, 1, 2, 3, 4, 5, 6, 7, 8])
>>> np.pad(a, (2, 3), 'symmetric')
array([2, 1, 1, 2, 3, 4, 5, 5, 4, 3])
>>> np.pad(a, (2, 3), 'symmetric', reflect_type='odd')
array([0, 1, 1, 2, 3, 4, 5, 5, 6, 7])
>>> np.pad(a, (2, 3), 'wrap')
array([4, 5, 1, 2, 3, 4, 5, 1, 2, 3])
>>> def pad_with(vector, pad_width, iaxis, kwargs):
... pad_value = kwargs.get('padder', 10)
... vector[:pad_width[0]] = pad_value
... vector[-pad_width[1]:] = pad_value
>>> a = np.arange(6)
>>> a = a.reshape((2, 3))
>>> np.pad(a, 2, pad_with)
array([[10, 10, 10, 10, 10, 10, 10],
[10, 10, 10, 10, 10, 10, 10],
[10, 10, 0, 1, 2, 10, 10],
[10, 10, 3, 4, 5, 10, 10],
[10, 10, 10, 10, 10, 10, 10],
[10, 10, 10, 10, 10, 10, 10]])
>>> np.pad(a, 2, pad_with, padder=100)
array([[100, 100, 100, 100, 100, 100, 100],
[100, 100, 100, 100, 100, 100, 100],
[100, 100, 0, 1, 2, 100, 100],
[100, 100, 3, 4, 5, 100, 100],
[100, 100, 100, 100, 100, 100, 100],
[100, 100, 100, 100, 100, 100, 100]])
多项式
在 NumPy 中，可以使用numpy.polynomial包的便利类创建、操作甚至拟合多项式，这是在 NumPy 1.4 中引入的。
在 NumPy 1.4 之前，numpy.poly1d是首选类，为了保持向后兼容性仍然可用。但是，较新的polynomial package更加完整，其便利类提供了处理多项式表达式的更一致、更良好的接口。因此，建议在新的编码中使用numpy.polynomial。
注意
术语
多项式模块一词指的是定义在numpy.lib.polynomial中的旧 API，其中包括numpy.poly1d类和以 poly 为前缀的多项式函数，可从numpy命名空间中访问（如numpy.polyadd、numpy.polyval、numpy.polyfit等）。
多项式包一词指的是在numpy.polynomial中定义的新 API，其中包括不同类型多项式的便利类（numpy.polynomial.Polynomial、numpy.polynomial.Chebyshev等）。
从numpy.poly1d过渡到numpy.polynomial
如上所述，numpy.lib.polynomial中定义的poly1d 类及其相关函数，如numpy.polyfit和numpy.poly等被视为传统遗留代码，不应在新代码中使用。自 NumPy 1.4 版本起，优先使用numpy.polynomial包处理多项式。
快速参考
以下表格列出了传统多项式模块和多项式包在常见任务中的一些主要差异。为简洁起见，导入了Polynomial类：
from numpy.polynomial import Polynomial
| 如何…… | 旧版（numpy.poly1d) |
numpy.polynomial |
|---|---|---|
| 从系数创建多项式对象 [1] | p = np.poly1d([1, 2, 3]) |
p = Polynomial([3, 2, 1]) |
| 从根创建多项式对象 | r = np.poly([-1, 1]) p = np.poly1d(r) |
p = Polynomial.fromroots([-1, 1]) |
对数据进行 deg 次多项式拟合 |
np.polyfit(x, y, deg) |
Polynomial.fit(x, y, deg) |
过渡指南
numpy.lib.polynomial 与 numpy.polynomial 之间存在显著差异。最显著的差异是多项式表达式中系数的排列顺序。numpy.polynomial 中的各种例程都处理系数从零次开始的级数，这与 poly1d 约定的相反顺序。要记住这一点很简单，因为指数对应于次数，即 coef[i] 是 i 次项的系数。
虽然约定上的差异可能令人困惑，但从旧版多项式 API 转换到新版 API 却是直截了当的。例如，以下演示了如何将代表表达式 (x^{2} + 2x + 3) 的 numpy.poly1d 实例转换为代表相同表达式的 Polynomial 实例：
>>> p1d = np.poly1d([1, 2, 3])
>>> p = np.polynomial.Polynomial(p1d.coef[::-1])
除了 coef 属性之外，多项式包中的多项式还具有 domain 和 window 属性。当拟合数据时，这些属性是最相关的，尽管应该注意，带有不同 domain 和 window 属性的多项式不被视为相等，并且不能在算术运算中混合使用：
>>> p1 = np.polynomial.Polynomial([1, 2, 3])
>>> p1
Polynomial([1., 2., 3.], domain=[-1, 1], window=[-1, 1], symbol='x')
>>> p2 = np.polynomial.Polynomial([1, 2, 3], domain=[-2, 2])
>>> p1 == p2
False
>>> p1 + p2
Traceback (most recent call last):
...
TypeError: Domains differ
有关 domain 和 window 属性的更多详细信息，请参阅方便的类文档。
旧版多项式模块与多项式包之间的另一个主要差异是多项式拟合。在旧模块中，拟合是通过 polyfit 函数进行的。在多项式包中，首选 fit 类方法。例如，考虑对以下数据进行简单线性拟合：
In [1]: rng = np.random.default_rng()
In [2]: x = np.arange(10)
In [3]: y = np.arange(10) + rng.standard_normal(10)
使用旧版多项式模块，可以使用 polyfit 对这些数据进行线性拟合（即一次多项式）：
In [4]: np.polyfit(x, y, deg=1)
Out[4]: array([0.89217112, 0.20829838])
有了新的多项式 API，优先使用 fit 类方法：
In [5]: p_fitted = np.polynomial.Polynomial.fit(x, y, deg=1)
In [6]: p_fitted
Out[6]: Polynomial([4.22306843, 4.01477004], domain=[0., 9.], window=[-1., 1.], symbol='x')
请注意，系数是以缩放域给出的，在window和domain之间的线性映射定义的域内。可以使用 convert 来获取未缩放数据域中的系数。
In [7]: p_fitted.convert()
Out[7]: Polynomial([0.20829838, 0.89217112], domain=[-1., 1.], window=[-1., 1.], symbol='x')
polynomial 包的文档
除了标准的幂级数多项式外，多项式包还提供了包括切比雪夫、厄米特（两个子类型）、拉盖尔和勒让德多项式在内的几种额外类型的多项式。每种多项式都有一个关联的便捷类，可以从numpy.polynomial命名空间中获取，提供了一个统一的接口来处理多项式，无论它们的类型是什么。
- 使用便捷类
有关单独为每种多项式定义的特定函数的文档可以在相应的模块文档中找到：
-
幂级数 (
numpy.polynomial.polynomial) -
切比雪夫系列 (
numpy.polynomial.chebyshev) -
厄米特系列，“物理学家” (
numpy.polynomial.hermite) -
厄米特 E 系列，“概率论家” (
numpy.polynomial.hermite_e) -
拉盖尔系列 (
numpy.polynomial.laguerre) -
勒让德系列 (
numpy.polynomial.legendre) -
Polyutils
旧版多项式的文档
-
Poly1d
-
基础知识
-
拟合
-
微积分
-
算术
-
警告
-
从 numpy.poly1d 过渡到 numpy.polynomial
如上所述，poly1d 类和numpy.lib.polynomial中定义的相关函数，如numpy.polyfit和numpy.poly等被视为遗留，并且不应在新代码中使用。自 NumPy 版本 1.4 起，首选使用numpy.polynomial包来处理多项式。
快速参考
以下表格突出显示了遗留多项式模块和多项式包在常见任务中的一些主要区别。为简洁起见导入了Polynomial类：
from numpy.polynomial import Polynomial
| 如何… | 遗留 (numpy.poly1d) |
numpy.polynomial |
|---|---|---|
| 从系数创建多项式对象 [1] | p = np.poly1d([1, 2, 3]) |
p = Polynomial([3, 2, 1]) |
| 从根创建多项式对象 | r = np.poly([-1, 1]) p = np.poly1d(r) |
p = Polynomial.fromroots([-1, 1]) |
对数据进行deg次多项式拟合 |
np.polyfit(x, y, deg) |
Polynomial.fit(x, y, deg) |
迁移指南
numpy.lib.polynomial和numpy.polynomial之间存在显著差异。最显著的区别是多项式表达式中系数的顺序。numpy.polynomial中的各种例程都处理系数从零次开始向上的级数，这与 poly1d 约定的相反顺序。简单记忆方法是索引对应于次数，即coef[i]是第 i 项的系数。
虽然约定上的差异可能会令人困惑，但从遗留多项式 API 转换到新 API 是直截了当的。例如，下面演示了如何将表示表达式(x^{2} + 2x + 3)的numpy.poly1d实例转换为表示相同表达式的Polynomial实例：
>>> p1d = np.poly1d([1, 2, 3])
>>> p = np.polynomial.Polynomial(p1d.coef[::-1])
除了coef属性外，多项式包中的多项式还具有domain和window属性。当将多项式拟合到数据时，这些属性最相关，尽管需要注意的是具有不同domain和window属性的多项式不被视为相等，且不能在算术运算中混合使用：
>>> p1 = np.polynomial.Polynomial([1, 2, 3])
>>> p1
Polynomial([1., 2., 3.], domain=[-1, 1], window=[-1, 1], symbol='x')
>>> p2 = np.polynomial.Polynomial([1, 2, 3], domain=[-2, 2])
>>> p1 == p2
False
>>> p1 + p2
Traceback (most recent call last):
...
TypeError: Domains differ
请参阅方便的类的文档, 以获取有关domain和window属性的进一步详细信息。
传统的多项式模块和多项式包之间的另一个主要区别是多项式拟合。在旧模块中，拟合是通过polyfit函数完成的。在多项式包中，更倾向于使用fit类方法。例如，考虑对以下数据进行简单的线性拟合：
In [1]: rng = np.random.default_rng()
In [2]: x = np.arange(10)
In [3]: y = np.arange(10) + rng.standard_normal(10)
在传统的多项式模块中，可以使用polyfit对这些数据进行线性拟合（即一次多项式）：
In [4]: np.polyfit(x, y, deg=1)
Out[4]: array([0.89217112, 0.20829838])
使用新的多项式 API，更倾向于使用fit类方法：
In [5]: p_fitted = np.polynomial.Polynomial.fit(x, y, deg=1)
In [6]: p_fitted
Out[6]: Polynomial([4.22306843, 4.01477004], domain=[0., 9.], window=[-1., 1.], symbol='x')
请注意，系数是以比例领域给出的，由线性映射定义了window和domain之间的关系。convert可用于在未缩放数据领域中获取系数。
In [7]: p_fitted.convert()
Out[7]: Polynomial([0.20829838, 0.89217112], domain=[-1., 1.], window=[-1., 1.], symbol='x')
快速参考
以下表格突出显示了传统多项式模块和多项式包在常见任务中的一些主要区别。为简洁起见, 导入了Polynomial类：
from numpy.polynomial import Polynomial
| 如何… | 传统（numpy.poly1d) |
numpy.polynomial |
|---|---|---|
| 根据系数创建多项式对象 [1] | p = np.poly1d([1, 2, 3]) |
p = Polynomial([3, 2, 1]) |
| 根据根创建多项式对象 | r = np.poly([-1, 1]) p = np.poly1d(r) |
p = Polynomial.fromroots([-1, 1]) |
对数据进行deg次多项式拟合 |
np.polyfit(x, y, deg) |
Polynomial.fit(x, y, deg) |
迁移指南
numpy.lib.polynomial和numpy.polynomial之间存在显著的差异。最显著的差异是多项式表达式的系数顺序。numpy.polynomial中的各种例程都涉及系数从零次往上的级数，这与poly1d约定的相反顺序相符。记住这一点的简单方法是索引对应于次数, 即，coef[i]是第 i 次项的系数。
尽管约定的差异可能令人困惑，但从传统多项式 API 转换到新 API 是直接的。例如，以下演示了如何将代表表达式(x^{2} + 2x + 3)的numpy.poly1d实例转换为代表相同表达式的Polynomial实例：
>>> p1d = np.poly1d([1, 2, 3])
>>> p = np.polynomial.Polynomial(p1d.coef[::-1])
除了coef属性外，多项式包中的多项式还具有domain和window属性。这些属性在拟合多项式到数据时最相关，虽然应注意到具有不同domain和window属性的多项式不被视为相等，不能混合进行算术运算：
>>> p1 = np.polynomial.Polynomial([1, 2, 3])
>>> p1
Polynomial([1., 2., 3.], domain=[-1, 1], window=[-1, 1], symbol='x')
>>> p2 = np.polynomial.Polynomial([1, 2, 3], domain=[-2, 2])
>>> p1 == p2
False
>>> p1 + p2
Traceback (most recent call last):
...
TypeError: Domains differ
有关domain和window属性的更多详细信息，请参阅便利类的文档。
传统多项式模块和多项式包之间的另一个主要区别是多项式拟合。在旧模块中，拟合是通过polyfit函数完成的。在多项式包中，更偏爱使用fit类方法。例如，考虑对以下数据进行简单线性拟合：
In [1]: rng = np.random.default_rng()
In [2]: x = np.arange(10)
In [3]: y = np.arange(10) + rng.standard_normal(10)
在传统多项式模块中，线性拟合（即一次多项式）可以用polyfit应用于这些数据：
In [4]: np.polyfit(x, y, deg=1)
Out[4]: array([0.89217112, 0.20829838])
使用新的多项式 API，更偏爱使用fit类方法：
In [5]: p_fitted = np.polynomial.Polynomial.fit(x, y, deg=1)
In [6]: p_fitted
Out[6]: Polynomial([4.22306843, 4.01477004], domain=[0., 9.], window=[-1., 1.], symbol='x')
请注意，系数是以 已缩放域给出的，在window和domain之间的线性映射所定义的。可使用convert来获得未缩放数据域中的系数。
In [7]: p_fitted.convert()
Out[7]: Polynomial([0.20829838, 0.89217112], domain=[-1., 1.], window=[-1., 1.], symbol='x')
多项式包的文档
除了标准的幂级数多项式外，多项式包还提供了几种额外的多项式，包括切比雪夫、埃尔米特（两种子类型）、拉盖尔和勒让德多项式。每种多项式都有一个相关的便利类，可从numpy.polynomial名称空间中获得，提供了一致的接口，可用于处理不同类型的多项式。
- 使用便利类
与每种多项式定义的特定函数相关的文档可以在相应的模块文档中找到：
-
幂级数 (
numpy.polynomial.polynomial) -
Chebyshev 级数 (
numpy.polynomial.chebyshev) -
Hermite 级数，"物理学家" (
numpy.polynomial.hermite) -
HermiteE 级数，"概率论者" (
numpy.polynomial.hermite_e) -
Laguerre 级数 (
numpy.polynomial.laguerre) -
Legendre 级数 (
numpy.polynomial.legendre) -
Polyutils
旧版多项式文档
-
Poly1d
-
基础知识
-
拟合
-
微积分
-
算术运算
-
警告
-
使用便利类
原文：
numpy.org/doc/1.26/reference/routines.polynomials.classes.html
多项式包提供的便利类包括：
名称 提供 多项式 幂级数 切比雪夫 切比雪夫级数 勒让德 勒让德级数 拉盖尔 拉盖尔级数 厄米特 厄米特级数 厄米特 E 厄米特 E 级数
在这种情况下，系列是相应的多项式基函数的有限求和，乘以系数。例如，幂级数看起来像
[p(x) = 1 + 2x + 3x²]
并具有系数([1, 2, 3])。具有相同系数的切比雪夫级数看起来像
[p(x) = 1 T_0(x) + 2 T_1(x) + 3 T_2(x)]
更一般地
[p(x) = \sum_{i=0}^n c_i T_i(x)]
在这种情况下，(T_n)表示度为(n)的切比雪夫函数，但也可以轻松地成为任何其他类的基函数。所有类的约定是系数(c[i])与度为 i 的基函数相对应。
所有类都是不可变的，并且具有相同的方法，特别是它们实现了 Python 的数字运算符 +、-、*、//、%、divmod、**、==和!=。最后两个可能因为浮点精度误差而有些问题。我们现在通过 NumPy 版本 1.7.0 快速演示各种操作。
基础
首先，我们需要一个多项式类和一个多项式实例来玩耍。这些类可以直接从多项式包或相关类型的模块中导入。这里我们从包中导入并使用传统的 Polynomial 类，因为它很熟悉：
>>> from numpy.polynomial import Polynomial as P
>>> p = P([1,2,3])
>>> p
Polynomial([1., 2., 3.], domain=[-1, 1], window=[-1, 1], symbol='x')
请注意，打印输出的长版本有三个部分。第一个是系数，第二个是域，第三个是窗口：
>>> p.coef
array([1., 2., 3.])
>>> p.domain
array([-1, 1])
>>> p.window
array([-1, 1])
打印多项式会输出一个更熟悉格式的多项式表达式：
>>> print(p)
1.0 + 2.0·x + 3.0·x²
请注意，多项式的字符串表示默认使用 Unicode 字符（在 Windows 上除外）来表示幂和下标。还提供了基于 ASCII 的表示形式（在 Windows 上为默认）。可以使用set_default_printstyle函数在包级别切换多项式字符串格式：
>>> np.polynomial.set_default_printstyle('ascii')
>>> print(p)
1.0 + 2.0 x + 3.0 x**2
或使用字符串格式对单个多项式实例进行控制：
>>> print(f"{p:unicode}")
1.0 + 2.0·x + 3.0·x²
当我们进行拟合时，会涉及到域和窗口，目前我们忽略它们，并进行基本的代数和算术操作。
加法和减法：
>>> p + p
Polynomial([2., 4., 6.], domain=[-1., 1.], window=[-1., 1.], symbol='x')
>>> p - p
Polynomial([0.], domain=[-1., 1.], window=[-1., 1.], symbol='x')
乘法：
>>> p * p
Polynomial([ 1., 4., 10., 12., 9.], domain=[-1., 1.], window=[-1., 1.], symbol='x')
幂：
>>> p**2
Polynomial([ 1., 4., 10., 12., 9.], domain=[-1., 1.], window=[-1., 1.], symbol='x')
除法：
地板除法，‘//’, 是多项式类的除法运算符，在这方面多项式被视为整数。对于 Python 版本 < 3.x，‘/’ 运算符映射为 ‘//’，正如对 Python 的会发生的那样，对于较新版本，‘/’ 只能用于标量的除法。某个时候将被弃用：
>>> p // P([-1, 1])
Polynomial([5., 3.], domain=[-1., 1.], window=[-1., 1.], symbol='x')
余数：
>>> p % P([-1, 1])
Polynomial([6.], domain=[-1., 1.], window=[-1., 1.], symbol='x')
Divmod（取商和余数）：
>>> quo, rem = divmod(p, P([-1, 1]))
>>> quo
Polynomial([5., 3.], domain=[-1., 1.], window=[-1., 1.], symbol='x')
>>> rem
Polynomial([6.], domain=[-1., 1.], window=[-1., 1.], symbol='x')
评估：
>>> x = np.arange(5)
>>> p(x)
array([ 1., 6., 17., 34., 57.])
>>> x = np.arange(6).reshape(3,2)
>>> p(x)
array([[ 1., 6.],
[17., 34.],
[57., 86.]])
替换：
用多项式替代 x，并展开结果。在这里，我们用 p 替代自身，展开后得到一个次数为 4 的新多项式。如果把多项式看作函数，这就是函数的复合：
>>> p(p)
Polynomial([ 6., 16., 36., 36., 27.], domain=[-1., 1.], window=[-1., 1.], symbol='x')
根：
>>> p.roots()
array([-0.33333333-0.47140452j, -0.33333333+0.47140452j])
并不总是方便明确使用多项式实例，因此元组、列表、数组和标量会在算术运算中被自动转换：
>>> p + [1, 2, 3]
Polynomial([2., 4., 6.], domain=[-1., 1.], window=[-1., 1.], symbol='x')
>>> [1, 2, 3] * p
Polynomial([ 1., 4., 10., 12., 9.], domain=[-1., 1.], window=[-1., 1.], symbol='x')
>>> p / 2
Polynomial([0.5, 1\. , 1.5], domain=[-1., 1.], window=[-1., 1.], symbol='x')
在域、窗口或类不同的多项式之间不能在算术中混合使用：
>>> from numpy.polynomial import Chebyshev as T
>>> p + P([1], domain=[0,1])
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<string>", line 213, in __add__
TypeError: Domains differ
>>> p + P([1], window=[0,1])
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<string>", line 215, in __add__
TypeError: Windows differ
>>> p + T([1])
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<string>", line 211, in __add__
TypeError: Polynomial types differ
但可以使用不同类型进行替换。实际上，这就是多项式类之间进行类型、域和窗口转换的方式：
>>> p(T([0, 1]))
Chebyshev([2.5, 2\. , 1.5], domain=[-1., 1.], window=[-1., 1.], symbol='x')
这将把多项式 p 转换为切比雪夫形式。这是因为 (T_1(x) = x)，将 (x) 替换为 (x) 不会改变原多项式。然而，所有的乘法和除法都将使用切比雪夫级数进行，因此结果的类型会有所变化。
所有多项式实例都应为不可变对象，因此增强操作（+=, -= 等）和任何会违反多项式实例不变性的功能都被有意地未实现。
微积分
多项式实例可以进行积分和微分。
>>> from numpy.polynomial import Polynomial as P
>>> p = P([2, 6])
>>> p.integ()
Polynomial([0., 2., 3.], domain=[-1., 1.], window=[-1., 1.], symbol='x')
>>> p.integ(2)
Polynomial([0., 0., 1., 1.], domain=[-1., 1.], window=[-1., 1.], symbol='x')
第一个例子对 p 进行一次积分，第二个例子对其进行两次积分。默认情况下，积分的下限和积分常数都为 0，但两者都可以指定：
>>> p.integ(lbnd=-1)
Polynomial([-1., 2., 3.], domain=[-1., 1.], window=[-1., 1.], symbol='x')
>>> p.integ(lbnd=-1, k=1)
Polynomial([0., 2., 3.], domain=[-1., 1.], window=[-1., 1.], symbol='x')
在第一种情况下，积分的下限设为 -1，并且积分常数为 0。在第二种情况下，积分常数也设为 1。微分更简单，因为唯一的选项就是对多项式微分的次数：
>>> p = P([1, 2, 3])
>>> p.deriv(1)
Polynomial([2., 6.], domain=[-1., 1.], window=[-1., 1.], symbol='x')
>>> p.deriv(2)
Polynomial([6.], domain=[-1., 1.], window=[-1., 1.], symbol='x')
其他多项式构造函数
指定系数来构造多项式只是获取多项式实例的一种方式，它们也可以通过指定它们的根、从其他多项式类型进行转换以及通过最小二乘拟合来创建。拟合在自己的部分中讨论，其他方法如下所示：
>>> from numpy.polynomial import Polynomial as P
>>> from numpy.polynomial import Chebyshev as T
>>> p = P.fromroots([1, 2, 3])
>>> p
Polynomial([-6., 11., -6., 1.], domain=[-1., 1.], window=[-1., 1.], symbol='x')
>>> p.convert(kind=T)
Chebyshev([-9\. , 11.75, -3\. , 0.25], domain=[-1., 1.], window=[-1., 1.], symbol='x')
convert 方法也可以转换域和窗口：
>>> p.convert(kind=T, domain=[0, 1])
Chebyshev([-2.4375 , 2.96875, -0.5625 , 0.03125], domain=[0., 1.], window=[-1., 1.], symbol='x')
>>> p.convert(kind=P, domain=[0, 1])
Polynomial([-1.875, 2.875, -1.125, 0.125], domain=[0., 1.], window=[-1., 1.], symbol='x')
在 numpy 版本 >= 1.7.0 中，basis 和 cast 类方法也可用。cast 方法类似于 convert 方法，而 basis 方法返回给定次数的基函数多项式：
>>> P.basis(3)
Polynomial([0., 0., 0., 1.], domain=[-1., 1.], window=[-1., 1.], symbol='x')
>>> T.cast(p)
Chebyshev([-9\. , 11.75, -3\. , 0.25], domain=[-1., 1.], window=[-1., 1.], symbol='x')
类型之间的转换可能很有用，但不建议常规使用。从一个次数为 50 的切比雪夫级数转换为相同次数的多项式级数可能导致数字精度损失，使数值评估的结果基本随机。
拟合
拟合是为了便利起见，域和窗口属性是其一部分。为了说明问题，下面绘制了 5 次 Chebyshev 多项式的值。
>>> import matplotlib.pyplot as plt
>>> from numpy.polynomial import Chebyshev as T
>>> x = np.linspace(-1, 1, 100)
>>> for i in range(6):
... ax = plt.plot(x, T.basis(i)(x), lw=2, label=f"$T_{i}$")
...
>>> plt.legend(loc="upper left")
>>> plt.show()
在-1 <= x <= 1 的范围内，它们是漂亮的，等波纹函数，位于+/- 1 之间。在-2 <= x <= 2 的范围内，相同的图形看起来截然不同：
>>> import matplotlib.pyplot as plt
>>> from numpy.polynomial import Chebyshev as T
>>> x = np.linspace(-2, 2, 100)
>>> for i in range(6):
... ax = plt.plot(x, T.basis(i)(x), lw=2, label=f"$T_{i}$")
...
>>> plt.legend(loc="lower right")
>>> plt.show()
可以看到，“好的”部分已经变得微不足道。在使用 Chebyshev 多项式进行拟合时，我们希望使用x介于-1 和 1 之间的区间，这就是窗口的作用。然而，要拟合的数据很少能够在该区间内，因此我们使用域来指定数据点所在的区间。拟合完成后，通过线性变换将域映射到窗口，并使用映射后的数据点进行通常的最小二乘拟合。拟合的窗口和域是返回系列的一部分，在计算值、导数等时会自动使用它们。如果在调用中没有指定它们，拟合例程将使用默认窗口和包含所有数据点的最小域。下面是对噪声正弦曲线拟合的示例。
>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> from numpy.polynomial import Chebyshev as T
>>> np.random.seed(11)
>>> x = np.linspace(0, 2*np.pi, 20)
>>> y = np.sin(x) + np.random.normal(scale=.1, size=x.shape)
>>> p = T.fit(x, y, 5)
>>> plt.plot(x, y, 'o')
>>> xx, yy = p.linspace()
>>> plt.plot(xx, yy, lw=2)
>>> p.domain
array([0\. , 6.28318531])
>>> p.window
array([-1., 1.])
>>> plt.show()
基础知识
首先，我们需要一个多项式类和一个多项式实例来玩耍。这些类可以直接从多项式包或相关类型的模块中导入。在这里，我们从包中导入并使用传统的多项式类，因为它更为熟悉：
>>> from numpy.polynomial import Polynomial as P
>>> p = P([1,2,3])
>>> p
Polynomial([1., 2., 3.], domain=[-1, 1], window=[-1, 1], symbol='x')
请注意，打印长版本输出有三部分。第一部分是系数，第二部分是域，第三部分是窗口：
>>> p.coef
array([1., 2., 3.])
>>> p.domain
array([-1, 1])
>>> p.window
array([-1, 1])
打印多项式会以更熟悉的格式显示多项式表达式：
>>> print(p)
1.0 + 2.0·x + 3.0·x²
请注意，默认情况下多项式的字符串表示使用 Unicode 字符（在 Windows 上除外）来表示幂和下标。也可以使用基于 ASCII 的表示（在 Windows 上为默认）。可以使用set_default_printstyle函数在包级别切换多项式字符串格式：
>>> np.polynomial.set_default_printstyle('ascii')
>>> print(p)
1.0 + 2.0 x + 3.0 x**2
或控制单个多项式实例的字符串格式：
>>> print(f"{p:unicode}")
1.0 + 2.0·x + 3.0·x²
我们将在拟合时处理域和窗口，目前我们忽略它们并进行基本的代数和算术运算。
加法和减法：
>>> p + p
Polynomial([2., 4., 6.], domain=[-1., 1.], window=[-1., 1.], symbol='x')
>>> p - p
Polynomial([0.], domain=[-1., 1.], window=[-1., 1.], symbol='x')
乘法：
>>> p * p
Polynomial([ 1., 4., 10., 12., 9.], domain=[-1., 1.], window=[-1., 1.], symbol='x')
幂：
>>> p**2
Polynomial([ 1., 4., 10., 12., 9.], domain=[-1., 1.], window=[-1., 1.], symbol='x')
除法：
"地板除法"，‘//’，是多项式类的除法运算符，多项式在这个方面被处理得像整数一样。对于 Python 版本 < 3.x，‘/’运算符映射到‘//’，就像 Python 一样；对于以后的版本，‘/’只对标量进行除法运算有效。在某个时候它将被弃用：
>>> p // P([-1, 1])
Polynomial([5., 3.], domain=[-1., 1.], window=[-1., 1.], symbol='x')
余数:
>>> p % P([-1, 1])
Polynomial([6.], domain=[-1., 1.], window=[-1., 1.], symbol='x')
除取余:
>>> quo, rem = divmod(p, P([-1, 1]))
>>> quo
Polynomial([5., 3.], domain=[-1., 1.], window=[-1., 1.], symbol='x')
>>> rem
Polynomial([6.], domain=[-1., 1.], window=[-1., 1.], symbol='x')
评估:
>>> x = np.arange(5)
>>> p(x)
array([ 1., 6., 17., 34., 57.])
>>> x = np.arange(6).reshape(3,2)
>>> p(x)
array([[ 1., 6.],
[17., 34.],
[57., 86.]])
替换:
用一个多项式替换 x 并展开结果。在这里，我们将 p 代入自身，展开后得到一个新的 4 次多项式。如果把多项式看作函数，这就是函数的组合：
>>> p(p)
Polynomial([ 6., 16., 36., 36., 27.], domain=[-1., 1.], window=[-1., 1.], symbol='x')
根:
>>> p.roots()
array([-0.33333333-0.47140452j, -0.33333333+0.47140452j])
并不总是方便明确使用多项式实例，所以元组、列表、数组和标量在算术运算中自动进行类型转换：
>>> p + [1, 2, 3]
Polynomial([2., 4., 6.], domain=[-1., 1.], window=[-1., 1.], symbol='x')
>>> [1, 2, 3] * p
Polynomial([ 1., 4., 10., 12., 9.], domain=[-1., 1.], window=[-1., 1.], symbol='x')
>>> p / 2
Polynomial([0.5, 1\. , 1.5], domain=[-1., 1.], window=[-1., 1.], symbol='x')
在域、窗口或类别上有所不同的多项式不能混合在算术中使用:
>>> from numpy.polynomial import Chebyshev as T
>>> p + P([1], domain=[0,1])
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<string>", line 213, in __add__
TypeError: Domains differ
>>> p + P([1], window=[0,1])
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<string>", line 215, in __add__
TypeError: Windows differ
>>> p + T([1])
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<string>", line 211, in __add__
TypeError: Polynomial types differ
但是可以使用不同类型来进行替换。实际上，这就是如何在类型、域和窗口转换之间进行多项式类的相互转换的：
>>> p(T([0, 1]))
Chebyshev([2.5, 2\. , 1.5], domain=[-1., 1.], window=[-1., 1.], symbol='x')
这给出了切比雪夫形式的多项式p。这是因为(T_1(x) = x)，并且用(x)代替(x)不会改变原多项式。然而，所有乘法和除法都将使用切比雪夫级数进行计算，所以结果的类型也是如此。
所有多项式实例都是不可变的，因此,augmented 操作(+=, -=,等)和任何其他会违反多项式实例的不可变性的功能都是有意未实现的。
微积分
多项式实例可以进行积分和微分。
>>> from numpy.polynomial import Polynomial as P
>>> p = P([2, 6])
>>> p.integ()
Polynomial([0., 2., 3.], domain=[-1., 1.], window=[-1., 1.], symbol='x')
>>> p.integ(2)
Polynomial([0., 0., 1., 1.], domain=[-1., 1.], window=[-1., 1.], symbol='x')
第一个示例对p进行了一次积分，第二个示例对其进行了两次积分。默认情况下，积分的下限和积分常数都是 0，但都可以指定。
>>> p.integ(lbnd=-1)
Polynomial([-1., 2., 3.], domain=[-1., 1.], window=[-1., 1.], symbol='x')
>>> p.integ(lbnd=-1, k=1)
Polynomial([0., 2., 3.], domain=[-1., 1.], window=[-1., 1.], symbol='x')
在第一种情况下，积分的下限设置为-1，积分常数为 0。在第二种情况下，积分常数也设置为 1。微分更简单，因为唯一的选择是多项式被微分的次数：
>>> p = P([1, 2, 3])
>>> p.deriv(1)
Polynomial([2., 6.], domain=[-1., 1.], window=[-1., 1.], symbol='x')
>>> p.deriv(2)
Polynomial([6.], domain=[-1., 1.], window=[-1., 1.], symbol='x')
其他多项式构造函数
通过指定系数构造多项式只是获得多项式实例的一种方式，它们还可以通过指定它们的根、通过从其他多项式类型转换获得，以及通过最小二乘拟合来创建。拟合在它自己的部分中进行讨论，其他方法如下所示:
>>> from numpy.polynomial import Polynomial as P
>>> from numpy.polynomial import Chebyshev as T
>>> p = P.fromroots([1, 2, 3])
>>> p
Polynomial([-6., 11., -6., 1.], domain=[-1., 1.], window=[-1., 1.], symbol='x')
>>> p.convert(kind=T)
Chebyshev([-9\. , 11.75, -3\. , 0.25], domain=[-1., 1.], window=[-1., 1.], symbol='x')
convert 方法还可以转换域和窗口：
>>> p.convert(kind=T, domain=[0, 1])
Chebyshev([-2.4375 , 2.96875, -0.5625 , 0.03125], domain=[0., 1.], window=[-1., 1.], symbol='x')
>>> p.convert(kind=P, domain=[0, 1])
Polynomial([-1.875, 2.875, -1.125, 0.125], domain=[0., 1.], window=[-1., 1.], symbol='x')
在 numpy 版本 >= 1.7.0 中，basis和cast类方法也是可用的。cast 方法类似于 convert 方法，而 basis 方法返回给定次数的基础多项式：
>>> P.basis(3)
Polynomial([0., 0., 0., 1.], domain=[-1., 1.], window=[-1., 1.], symbol='x')
>>> T.cast(p)
Chebyshev([-9\. , 11.75, -3\. , 0.25], domain=[-1., 1.], window=[-1., 1.], symbol='x')
类型之间的转换可能会有用，但不建议经常使用。在从 50 次切比雪夫级数转换成相同次数的多项式级数时，数值精度的丢失会使数值计算的结果基本上是随机的。
拟合
拟合是方便类的domain和window属性的原因。 为了说明问题，下面绘制了最高为 5 次的切比雪夫多项式的值。
>>> import matplotlib.pyplot as plt
>>> from numpy.polynomial import Chebyshev as T
>>> x = np.linspace(-1, 1, 100)
>>> for i in range(6):
... ax = plt.plot(x, T.basis(i)(x), lw=2, label=f"$T_{i}$")
...
>>> plt.legend(loc="upper left")
>>> plt.show()
在范围-1 <= x <= 1 内，它们是漂亮的函数，在+/- 1 之间。 相同的区间在-2 <= x <= 2 看起来大不相同：
>>> import matplotlib.pyplot as plt
>>> from numpy.polynomial import Chebyshev as T
>>> x = np.linspace(-2, 2, 100)
>>> for i in range(6):
... ax = plt.plot(x, T.basis(i)(x), lw=2, label=f"$T_{i}$")
...
>>> plt.legend(loc="lower right")
>>> plt.show()
如图所示，“好”的部分已经缩小到无关紧要的程度。 在使用切比雪夫多项式进行拟合时，我们想使用x在-1 和 1 之间的区域，这正是window指定的。 但是，要拟合的数据可能不会所有数据点都在该区间内，因此我们使用domain来指定数据点所在的区间。进行拟合时，首先通过线性变换将domain映射到window，然后使用映射后的数据点进行普通最小二乘拟合。 拟合的窗口和域是返回系列的一部分，在计算值、导数等时会自动使用。 如果在调用中未指定它们，拟合例程将使用默认窗口和包含所有数据点的最小域。 下面这幅图是对噪声正弦曲线的拟合示例。
>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> from numpy.polynomial import Chebyshev as T
>>> np.random.seed(11)
>>> x = np.linspace(0, 2*np.pi, 20)
>>> y = np.sin(x) + np.random.normal(scale=.1, size=x.shape)
>>> p = T.fit(x, y, 5)
>>> plt.plot(x, y, 'o')
>>> xx, yy = p.linspace()
>>> plt.plot(xx, yy, lw=2)
>>> p.domain
array([0\. , 6.28318531])
>>> p.window
array([-1., 1.])
>>> plt.show()
幂级数（numpy.polynomial.polynomial）
原文：
numpy.org/doc/1.26/reference/routines.polynomials.polynomial.html
这个模块提供了一些对象（主要是函数），用于处理多项式，包括一个Polynomial类，封装了通常的算术操作。（关于这个模块如何表示和处理多项式对象的一般信息在它的“父级”子包的文档字符串中，numpy.polynomial）。
类
Polynomial(coef[, domain, window, symbol]) |
一种幂级数类。 |
|---|
常数
polydomain |
一个数组对象，表示一个多维、同构的固定大小项目数组。 |
|---|---|
polyzero |
一个数组对象，表示一个多维、同构的固定大小项目数组。 |
polyone |
一个数组对象，表示一个多维、同构的固定大小项目数组。 |
polyx |
一个数组对象，表示一个多维、同构的固定大小项目数组。 |
算术
polyadd(c1, c2) |
将一个多项式加到另一个多项式上。 |
|---|---|
polysub(c1, c2) |
从一个多项式中减去另一个多项式。 |
polymulx(c) |
将一个多项式乘以 x。 |
polymul(c1, c2) |
将一个多项式乘以另一个多项式。 |
polydiv(c1, c2) |
一个多项式��以另一个多项式。 |
polypow(c, pow[, maxpower]) |
将多项式提升到指定次幂。 |
polyval(x, c[, tensor]) |
在点 x 处评估一个多项式。 |
polyval2d(x, y, c) |
在点(x, y)处评估一个二维多项式。 |
polyval3d(x, y, z, c) |
在点(x, y, z)处评估一个三维多项式。 |
polygrid2d(x, y, c) |
在 x 和 y 的笛卡尔乘积上评估一个二维多项式。 |
polygrid3d(x, y, z, c) |
在 x、y、z 的笛卡尔乘积上评估一个三维多项式。 |
微积分
polyder(c[, m, scl, axis]) |
对多项式进行微分。 |
|---|---|
polyint(c[, m, k, lbnd, scl, axis]) |
对多项式进行积分。 |
杂项函数
polyfromroots(roots) |
生成具有给定根的首一多项式。 |
|---|---|
polyroots(c) |
计算多项式的根。 |
polyvalfromroots(x, r[, tensor]) |
在点 x 处计算由其根指定的多项式。 |
polyvander(x, deg) |
给定次数的范德蒙德矩阵。 |
polyvander2d(x, y, deg) |
给定次数的伪范德蒙德矩阵。 |
polyvander3d(x, y, z, deg) |
给定次数的伪范德蒙德矩阵。 |
polycompanion(c) |
返回 c 的伴随矩阵。 |
polyfit(x, y, deg[, rcond, full, w]) |
对数据进行多项式的最小二乘拟合。 |
polytrim(c[, tol]) |
从多项式中移除“小” “尾部” 系数。 |
polyline(off, scl) |
返回表示线性多项式的数组。 |
参见
numpy.polynomial
类
Polynomial(coef[, domain, window, symbol]) |
一个幂级数类。 |
|---|
常量
polydomain |
一个表示多维、同种类型、固定大小项的数组对象。 |
|---|---|
polyzero |
一个表示多维、同种类型、固定大小项的数组对象。 |
polyone |
一个表示多维、同种类型、固定大小项的数组对象。 |
polyx |
一个表示多维、同种类型、固定大小项的数组对象。 |
算术
polyadd(c1, c2) |
将一个多项式加到另一个多项式上。 |
|---|---|
polysub(c1, c2) |
一个多项式减去另一个多项式。 |
polymulx(c) |
将多项式乘以 x。 |
polymul(c1, c2) |
将一个多项式乘以另一个。 |
polydiv(c1, c2) |
将一个多项式除以另一个。 |
polypow(c, pow[, maxpower]) |
将多项式提升到某个幂。 |
polyval(x, c[, tensor]) |
在点 x 处评估多项式。 |
polyval2d(x, y, c) |
在点(x, y)处评估二维多项式。 |
polyval3d(x, y, z, c) |
在点(x, y, z)处评估三维多项式。 |
polygrid2d(x, y, c) |
在 x 和 y 的直积上评估二维多项式。 |
polygrid3d(x, y, z, c) |
在 x、y 和 z 的直积上评估三维多项式。 |
微积分
polyder(c[, m, scl, axis]) |
对多项式进行微分。 |
|---|---|
polyint(c[, m, k, lbnd, scl, axis]) |
对多项式积分。 |
其他函数
polyfromroots(roots) |
以给定根生成一个首一多项式。 |
|---|---|
polyroots(c) |
计算多项式的根。 |
polyvalfromroots(x, r[, tensor]) |
在点 x 处评估由其根指定的多项式。 |
polyvander(x, deg) |
给定次数的范德蒙矩阵。 |
polyvander2d(x, y, deg) |
给定次数的伪范德蒙矩阵。 |
polyvander3d(x, y, z, deg) |
给定阶数的伪范德蒙矩阵。 |
polycompanion(c) |
返回 c 的伴随矩阵。 |
polyfit(x, y, deg[, rcond, full, w]) |
对数据进行多项式的最小二乘拟合。 |
polytrim(c[, tol]) |
从多项式中删除 "小" "尾部" 系数。 |
polyline(off, scl) |
返回表示线性多项式的数组。 |
参见
numpy.polynomial
切比雪夫级数（numpy.polynomial.chebyshev）
原文：
numpy.org/doc/1.26/reference/routines.polynomials.chebyshev.html
该模块提供了一些对象（主要是函数），用于处理切比雪夫级数，包括一个Chebyshev 类，该类封装了通常的算术运算。（关于该模块如何表示和处理这种多项式的一般信息在其“父”子包的文档字符串中，numpy.polynomial）。
类
Chebyshev(coef[, domain, window, symbol]) |
一个切比雪夫级数类。 |
|---|
常数
chebdomain |
一个数组对象，表示一个多维、同类数组，包含固定大小的元素。 |
|---|---|
chebzero |
一个数组对象，表示一个多维、同类数组，包含固定大小的元素。 |
chebone |
一个数组对象，表示一个多维、同类数组，包含固定大小的元素。 |
chebx |
一个数组对象，表示一个多维、同类数组，包含固定大小的元素。 |
算术
chebadd(c1, c2) |
将一个切比雪夫级数加到另一个上。 |
|---|---|
chebsub(c1, c2) |
从一个切比雪夫级数中减去另一个。 |
chebmulx(c) |
将一个切比雪夫级数乘以 x。 |
chebmul(c1, c2) |
将一个切比雪夫级数乘以另一个。 |
chebdiv(c1, c2) |
将一个切比雪夫级数除以另一个。 |
chebpow(c, pow[, maxpower]) |
将切比雪夫级数提升到指定幂次。 |
chebval(x, c[, tensor]) |
在点 x 处评估切比雪夫级数。 |
chebval2d(x, y, c) |
在点(x, y)处评估二维切比雪夫级数。 |
chebval3d(x, y, z, c) |
在点(x, y, z)处评估三维切比雪夫级数。 |
chebgrid2d(x, y, c) |
在 x 和 y 的笛卡尔乘积上评估二维切比雪夫级数。 |
chebgrid3d(x, y, z, c) |
在 x、y 和 z 的笛卡尔乘积上评估三维切比雪夫级数。 |
微积分
chebder(c[, m, scl, axis]) |
对切比雪夫级数进行微分。 |
|---|---|
chebint(c[, m, k, lbnd, scl, axis]) |
对切比雪夫级数进行积分。 |
杂项函数
chebfromroots(roots) |
生成具有给定根的切比雪夫级数。 |
|---|---|
chebroots(c) |
计算切比雪夫级数的根。 |
chebvander(x, deg) |
给定次数的伪范德蒙矩阵。 |
chebvander2d(x, y, deg) |
给定次数的伪范德蒙矩阵。 |
chebvander3d(x, y, z, deg) |
给定次数的伪范德蒙矩阵。 |
chebgauss(deg) |
高斯-切比雪夫积分。 |
chebweight(x) |
切比雪夫多项式的权函数。 |
chebcompanion(c) |
返回 c 的缩放伴随矩阵。 |
chebfit(x, y, deg[, rcond, full, w]) |
对数据进行切比雪夫级数的最小二乘拟合。 |
chebpts1(npts) |
第一类 Chebyshev 点。 |
chebpts2(npts) |
第二类 Chebyshev 点。 |
chebtrim(c[, tol]) |
从多项式中删除“小”“尾部”系数。 |
chebline(off, scl) |
其图形为直线的切比雪夫级数。 |
cheb2poly(c) |
将切比雪夫级数转换为多项式。 |
poly2cheb(pol) |
将多项式转换为切比雪夫级数。 |
chebinterpolate(func, deg[, args]) |
在第一类 Chebyshev 点上对函数进行插值。 |
另请参阅
numpy.polynomial
注释
乘法、除法、积分和微分的实现使用代数恒等式 [1]:
[\begin{split}T_n(x) = \frac{z^n + z^{-n}}{2} \ z\frac{dx}{dz} = \frac{z - z^{-1}}{2}.\end{split}]
其中
[x = \frac{z + z^{-1}}{2}.]
这些恒等式允许将切比雪夫级数表示为一个有限的对称 Laurent 级数。在这个模块中，这种类型的 Laurent 级数称为“z-series”。
参考
[1]
A. T. Benjamin, et al., “Combinatorial Trigonometry with Chebyshev Polynomials,” Journal of Statistical Planning and Inference 14, 2008 (web.archive.org/web/20080221202153/https://www.math.hmc.edu/~benjamin/papers/CombTrig.pdf, pg. 4)
类
Chebyshev(coef[, domain, window, symbol]) |
切比雪夫级数类。 |
|---|
常数
chebdomain |
一个数组对象，表示固定大小项的多维、同质数组。 |
|---|---|
chebzero |
一个数组对象，表示固定大小项的多维、同质数组。 |
chebone |
一个数组对象，表示固定大小项的多维、同质数组。 |
chebx |
一个数组对象，表示固定大小项的多维、同质数组。 |
算术
chebadd(c1, c2) |
将一个切比雪夫级数加到另一个上。 |
|---|---|
chebsub(c1, c2) |
从一个切比雪夫级数中减去另一个。 |
chebmulx(c) |
将切比雪夫级数乘以 x。 |
chebmul(c1, c2) |
将一个切比雪夫级数乘以另一个。 |
chebdiv(c1, c2) |
将一个切比雪夫级数除以另一个。 |
chebpow(c, pow[, maxpower]) |
将切比雪夫级数提升到幂。 |
chebval(x, c[, tensor]) |
在点 x 处评估切比雪夫级数。 |
chebval2d(x, y, c) |
在点 (x, y) 上计算 2-D 切比雪夫级数。 |
chebval3d(x, y, z, c) |
在点 (x, y, z) 上计算 3-D 切比雪夫级数。 |
chebgrid2d(x, y, c) |
在 x 和 y 的笛卡尔积上计算 2-D 切比雪夫级数。 |
chebgrid3d(x, y, z, c) |
在 x、y 和 z 的笛卡尔积上计算 3-D 切比雪夫级数。 |
微积分
chebder(c[, m, scl, axis]) |
对切比雪夫级数求导。 |
|---|---|
chebint(c[, m, k, lbnd, scl, axis]) |
积分切比雪夫级数。 |
其他函数
chebfromroots(roots) |
以给定根生成切比雪夫级数。 |
|---|---|
chebroots(c) |
计算切比雪夫级数的根。 |
chebvander(x, deg) |
给定次数的伪范德蒙矩阵。 |
chebvander2d(x, y, deg) |
给定次数的伪范德蒙矩阵。 |
chebvander3d(x, y, z, deg) |
给定次数的伪范德蒙矩阵。 |
chebgauss(deg) |
高斯切比雪夫积分。 |
chebweight(x) |
切比雪夫多项式的权重函数。 |
chebcompanion(c) |
返回 c 的标度伴随矩阵。 |
chebfit(x, y, deg[, rcond, full, w]) |
Chebyshev 系列拟合数据的最小二乘法。 |
chebpts1(npts) |
第一类 Chebyshev 点。 |
chebpts2(npts) |
第二类 Chebyshev 点。 |
chebtrim(c[, tol]) |
从多项式中去除“小”的“尾部”系数。 |
chebline(off, scl) |
其图形为直线的 Chebyshev 系列。 |
cheb2poly(c) |
将 Chebyshev 系列转换为多项式。 |
poly2cheb(pol) |
将多项式转换为 Chebyshev 系列。 |
chebinterpolate(func, deg[, args]) |
在第一类 Chebyshev 点插值函数。 |
另请参阅
numpy.polynomial
注意事项
乘法、除法、积分和微分的实现使用代数恒等式[1]：
[\begin{split}T_n(x) = \frac{z^n + z^{-n}}{2} \ z\frac{dx}{dz} = \frac{z - z^{-1}}{2}.\end{split}]
其中
[x = \frac{z + z^{-1}}{2}.]
这些恒等式允许将 Chebyshev 系列表示为一个有限的对称 Laurent 级数。在这个模块中，这种 Laurent 级数被称为“z-series”。
参考资料
[1]
A. T. Benjamin, et al., “Combinatorial Trigonometry with Chebyshev Polynomials,” Journal of Statistical Planning and Inference 14, 2008 (web.archive.org/web/20080221202153/https://www.math.hmc.edu/~benjamin/papers/CombTrig.pdf, pg. 4)
埃米特级数，“物理学家”（numpy.polynomial.hermite）
原文：
numpy.org/doc/1.26/reference/routines.polynomials.hermite.html
本模块提供了许多与 Hermite 系列有关的对象（主要是函数），包括一个Hermite类，该类封装了通常的算术操作。（关于该模块如何表示和处理这种多项式的一般信息在其“父级”子包的文档字符串中，numpy.polynomial）。
类
Hermite(coef[, domain, window, symbol]) |
Hermite 级数类。 |
|---|
常数
hermdomain |
一个数组对象代表一个多维、同构的、大小固定的数组。 |
|---|---|
hermzero |
一个数组对象代表一个多维、同构的、大小固定的数组。 |
hermone |
一个数组对象代表一个多维、同构的、大小固定的数组。 |
hermx |
一个数组对象代表一个多维、同构的、大小固定的数组。 |
算术
hermadd(c1, c2) |
将一个 Hermite 级数加到另一个 Hermite 级数。 |
|---|---|
hermsub(c1, c2) |
从另一个 Hermite 级数中减去一个 Hermite 级数。 |
hermmulx(c) |
将 Hermite 级数乘以 x。 |
hermmul(c1, c2) |
将一个 Hermite 级数乘以另一个 Hermite 级数。 |
hermdiv(c1, c2) |
将一个 Hermite 级数除以另一个 Hermite 级数。 |
hermpow(c, pow[, maxpower]) |
将一个 Hermite 级数求幂。 |
hermval(x, c[, tensor]) |
在点 x 处求解 Hermite 级数。 |
hermval2d(x, y, c) |
在点(x, y)处求解 2D Hermite 级数。 |
hermval3d(x, y, z, c) |
在点(x, y, z)处求解 3D Hermite 级数。 |
hermgrid2d(x, y, c) |
在 x 和 y 的笛卡尔积上求解 2D Hermite 级数。 |
hermgrid3d(x, y, z, c) |
在 x、y 和 z 的笛卡尔积上求解 3D Hermite 级数。 |
微积分
hermder(c[, m, scl, axis]) |
求解 Hermite 级数的导数。 |
|---|---|
hermint(c[, m, k, lbnd, scl, axis]) |
计算 Hermite 级数的积分。 |
杂项函数
hermfromroots(roots) |
生成具有给定根的 Hermite 级数。 |
|---|---|
hermroots(c) |
计算 Hermite 级数的根。 |
hermvander(x, deg) |
给定次数的 Hermite 伪范德蒙矩阵。 |
hermvander2d(x, y, deg) |
给定次数的 Hermite 伪范德蒙矩阵。 |
hermvander3d(x, y, z, deg) |
给定次数的 Hermite 伪范德蒙矩阵。 |
hermgauss(deg) |
Gauss-Hermite 积分。 |
hermweight(x) |
Hermite 多项式的权重函数。 |
hermcompanion(c) |
返回 c 的缩放伴随矩阵。 |
hermfit(x, y, deg[, rcond, full, w]) |
Hermite 级数对数据的最小二乘拟合。 |
hermtrim(c[, tol]) |
从多项式中删除“小”“尾部”系数。 |
hermline(off, scl) |
其图形为直线的 Hermite 级数。 |
herm2poly(c) |
将 Hermite 级数转换为多项式。 |
poly2herm(pol) |
将多项式转换为 Hermite 级数。 |
另请参阅
numpy.polynomial
类
Hermite(coef[, domain, window, symbol]) |
Hermite 级数类。 |
|---|
常量
hermdomain |
一个数组对象表示多维、同质数组，其中包含固定大小的项目。 |
|---|---|
hermzero |
一个数组对象表示多维、同质数组，其中包含固定大小的项目。 |
hermone |
一个数组对象表示多维、同质数组，其中包含固定大小的项目。 |
hermx |
一个数组对象表示多维、同质数组，其中包含固定大小的项目。 |
算术
hermadd(c1, c2) |
将一个 Hermite 级数加上另一个 Hermite 级数。 |
|---|---|
hermsub(c1, c2) |
从另一个 Hermite 级数中减去一个 Hermite 级数。 |
hermmulx(c) |
将一个 Hermite 级数乘以 x。 |
hermmul(c1, c2) |
将一个厄米特级数乘以另一个。 |
hermdiv(c1, c2) |
将一个厄米特级数除以另一个。 |
hermpow(c, pow[, maxpower]) |
将厄米特级数提升至幂。 |
hermval(x, c[, tensor]) |
在点 x 处评估厄米特级数。 |
hermval2d(x, y, c) |
在点（x，y）处评估二维厄米特级数。 |
hermval3d(x, y, z, c) |
在点（x，y，z）处评估三维厄米特级数。 |
hermgrid2d(x, y, c) |
在 x 和 y 的笛卡尔积上评估二维厄米特级数。 |
hermgrid3d(x, y, z, c) |
在 x，y 和 z 的笛卡尔积上评估三维厄米特级数。 |
微积分
hermder(c[, m, scl, axis]) |
对厄米特级数进行微分。 |
|---|---|
hermint(c[, m, k, lbnd, scl, axis]) |
对厄米特级数进行积分。 |
杂项功能
hermfromroots(roots) |
生成具有给定根的厄米特级数。 |
|---|---|
hermroots(c) |
计算厄米特级数的根。 |
hermvander(x, deg) |
给定程度的伪范德蒙矩阵。 |
hermvander2d(x, y, deg) |
给定次数的伪范德蒙矩阵。 |
hermvander3d(x, y, z, deg) |
给定次数的伪范德蒙矩阵。 |
hermgauss(deg) |
高斯-埃尔米特积分。 |
hermweight(x) |
埃尔米特多项式的权函数。 |
hermcompanion(c) |
返回缩放的伴随矩阵。 |
hermfit(x, y, deg[, rcond, full, w]) |
最小二乘拟合埃尔米特级数至数据。 |
hermtrim(c[, tol]) |
从多项式中删除“小”“尾部”系数。 |
hermline(off, scl) |
图像为直线的埃尔米特级数。 |
herm2poly(c) |
将埃尔米特级数转换为多项式。 |
poly2herm(pol) |
将多项式转换为埃尔米特级数。 |
另外参见
numpy.polynomial
埃米特 E 级数，“概率学家”（numpy.polynomial.hermite_e）
原文：
numpy.org/doc/1.26/reference/routines.polynomials.hermite_e.html
该模块提供了许多对象（主要是函数），用于处理 Hermite_e 系列，包括一个HermiteE类，封装了通常的算术操作。（有关此模块如何表示和处理这些多项式的一般信息在其“父”子包的文档字符串中，numpy.polynomial）。
类
HermiteE(coef[, domain, window, symbol]) |
HermiteE 系列类。 |
|---|
常量
hermedomain |
一个数组对象表示一个多维、同质的固定大小项数组。 |
|---|---|
hermezero |
一个数组对象表示一个多维、同质的固定大小项数组。 |
hermeone |
一个数组对象表示一个多维、同质的固定大小项数组。 |
hermex |
一个数组对象表示一个多维、同质的固定大小项数组。 |
算术
hermeadd(c1, c2) |
将一个 Hermite 系列加到另一个。 |
|---|---|
hermesub(c1, c2) |
从一个 Hermite 系列中减去另一个。 |
hermemulx(c) |
将一个 Hermite 系列乘以 x。 |
hermemul(c1, c2) |
将一个 Hermite 系列乘以另一个。 |
hermediv(c1, c2) |
将一个 Hermite 系列除以另一个。 |
hermepow(c, pow[, maxpower]) |
将 Hermite 级数提升到幂。 |
hermeval(x, c[, tensor]) |
在点 x 处评估 HermiteE 级数。 |
hermeval2d(x, y, c) |
在点 (x, y) 处评估 2-D HermiteE 级数。 |
hermeval3d(x, y, z, c) |
在点 (x, y, z) 处评估 3-D Hermite_e 级数。 |
hermegrid2d(x, y, c) |
在 x 和 y 的笛卡尔积上评估 2-D HermiteE 级数。 |
hermegrid3d(x, y, z, c) |
在 x、y 和 z 的笛卡尔积上评估 3-D HermiteE 级数。 |
微积分
hermeder(c[, m, scl, axis]) |
对 Hermite_e 级数进行微分。 |
|---|---|
hermeint(c[, m, k, lbnd, scl, axis]) |
对 Hermite_e 级数进行积分。 |
杂项函数
hermefromroots(roots) |
生成具有给定根的 HermiteE 级数。 |
|---|---|
hermeroots(c) |
计算 HermiteE 级数的根。 |
hermevander(x, deg) |
给定次数的伪范德蒙矩阵。 |
hermevander2d(x, y, deg) |
给定次数的伪范德蒙矩阵。 |
hermevander3d(x, y, z, deg) |
给定次数的伪范德蒙矩阵。 |
hermegauss(deg) |
Gauss-HermiteE 积分。 |
hermeweight(x) |
Hermite_e 多项式的权重函数。 |
hermecompanion(c) |
返回 c 的缩放伴随矩阵。 |
hermefit(x, y, deg[, rcond, full, w]) |
对数据进行 Hermite 系列的最小二乘拟合。 |
hermetrim(c[, tol]) |
从多项式中删除"小"的"尾部"系数。 |
hermeline(off, scl) |
其图是直线的 Hermite 系列。 |
herme2poly(c) |
将 Hermite 系列转换为多项式。 |
poly2herme(pol) |
将多项式转换为 Hermite 系列。 |
亦参见
numpy.polynomial
类
HermiteE(coef[, domain, window, symbol]) |
HermiteE 系列类。 |
|---|
常数
hermedomain |
数组对象表示固定大小的项的多维、同构数组。 |
|---|---|
hermezero |
数组对象表示固定大小的项的多维、同构数组。 |
hermeone |
数组对象表示固定大小的项的多维、同构数组。 |
hermex |
数组对象表示固定大小的项的多维、同构数组。 |
算术
hermeadd(c1, c2) |
将一个 Hermite 系列加到另一个 Hermite 系列上。 |
|---|---|
hermesub(c1, c2) |
从一个 Hermite 级数中减去另一个。 |
hermemulx(c) |
通过 x 将 Hermite 级数相乘。 |
hermemul(c1, c2) |
将一个 Hermite 级数乘以另一个。 |
hermediv(c1, c2) |
将一个 Hermite 级数除以另一个。 |
hermepow(c, pow[, maxpower]) |
将 Hermite 级数提升到某个幂。 |
hermeval(x, c[, tensor]) |
在 x 点评估 HermiteE 级数。 |
hermeval2d(x, y, c) |
在点 (x, y) 处评估 2-D HermiteE 级数。 |
hermeval3d(x, y, z, c) |
在点 (x, y, z) 处评估 3-D Hermite_e 级数。 |
hermegrid2d(x, y, c) |
在 x 和 y 的笛卡尔乘积上评估 2-D HermiteE 级数。 |
hermegrid3d(x, y, z, c) |
在 x, y, z 的笛卡尔乘积上评估 3-D HermiteE 级数。 |
微积分
hermeder(c[, m, scl, axis]) |
求 Hermite_e 级数的导数。 |
|---|---|
hermeint(c[, m, k, lbnd, scl, axis]) |
对 Hermite_e 级数进行积分。 |
Misc 函数
hermefromroots(roots) |
使用给定的根生成一个 HermiteE 级数。 |
|---|---|
hermeroots(c) |
计算 HermiteE 级数的根。 |
hermevander(x, deg) |
给定阶数的拟范德蒙德矩阵。 |
hermevander2d(x, y, deg) |
给定阶数的拟范德蒙德矩阵。 |
hermevander3d(x, y, z, deg) |
给定阶数的拟范德蒙德矩阵。 |
hermegauss(deg) |
高斯-埃尔米特 E 积分。 |
hermeweight(x) |
埃尔米特 _ｅ多项式的权函数。 |
hermecompanion(c) |
返回缩放后的系数矩阵。 |
hermefit(x, y, deg[, rcond, full, w]) |
对数据进行埃尔米特级数的最小二乘拟合。 |
hermetrim(c[, tol]) |
从多项式中删除"小"的"尾随"系数。 |
hermeline(off, scl) |
其图形为直线的埃尔米特级数。 |
herme2poly(c) |
将埃尔米特级数转换为多项式。 |
poly2herme(pol) |
将多项式转换为埃尔米特级数。 |
另见
numpy.polynomial
拉盖尔级数（numpy.polynomial.laguerre）
原文：
numpy.org/doc/1.26/reference/routines.polynomials.laguerre.html
该模块提供了一些对象（主要是函数），用于处理拉盖尔级数，包括一个 Laguerre 类，封装了通常的算术运算。（有关此模块如何表示和处理此类多项式的一般信息在其“父”子包的文档字符串中，numpy.polynomial）。
类
Laguerre(coef[, domain, window, symbol]) |
一个拉盖尔级数类。 |
|---|
常数
lagdomain |
一个数组对象，表示固定大小项目的多维、同质数组。 |
|---|---|
lagzero |
一个数组对象，表示固定大小项目的多维、同质数组。 |
lagone |
一个数组对象，表示固定大小项目的多维、同质数组。 |
lagx |
一个数组对象，表示固定大小项目的多维、同质数组。 |
算术
lagadd(c1, c2) |
将一个拉盖尔级数加到另一个上。 |
|---|---|
lagsub(c1, c2) |
从一个拉盖尔级数中减去另一个。 |
lagmulx(c) |
将拉盖尔级数乘以 x。 |
lagmul(c1, c2) |
将一个拉盖尔级数乘以另一个。 |
lagdiv(c1, c2) |
将一个拉盖尔级数除以另一个。 |
lagpow(c, pow[, maxpower]) |
将拉盖尔级数提升至某个幂。 |
lagval(x, c[, tensor]) |
在点 x 处评估拉盖尔级数。 |
lagval2d(x, y, c) |
在点 (x, y) 处评估 2-D 拉盖尔级数。 |
lagval3d(x, y, z, c) |
在点 (x, y, z) 处评估 3-D 拉盖尔级数。 |
laggrid2d(x, y, c) |
在笛卡尔积 x 和 y 上评估 2-D 拉盖尔级数。 |
laggrid3d(x, y, z, c) |
在笛卡尔积 x、y 和 z 上评估 3-D 拉盖尔级数。 |
微积分
lagder(c[, m, scl, axis]) |
对拉盖尔级数进行微分。 |
|---|---|
lagint(c[, m, k, lbnd, scl, axis]) |
对拉盖尔级数进行积分。 |
杂项函数
lagfromroots(roots) |
生成具有给定根的拉盖尔级数。 |
|---|---|
lagroots(c) |
计算拉盖尔级数的根。 |
lagvander(x, deg) |
给定度数的伪范德蒙矩阵。 |
lagvander2d(x, y, deg) |
给定度数的伪范德蒙矩阵。 |
lagvander3d(x, y, z, deg) |
给定度数的伪范德蒙矩阵。 |
laggauss(deg) |
高斯-拉盖尔积分。 |
lagweight(x) |
拉盖尔多项式的权函数。 |
lagcompanion(c) |
返回 c 的伴随矩阵。 |
lagfit(x, y, deg[, rcond, full, w]) |
拉盖尔级数拟合数据的最小二乘法。 |
lagtrim(c[, tol]) |
从多项式中移除“小”的“尾部”系数。 |
lagline(off, scl) |
其图形为直线的拉盖尔级数。 |
lag2poly(c) |
将拉盖尔级数转换为多项式。 |
poly2lag(pol) |
将多项式转换为拉盖尔级数。 |
另请参阅
numpy.polynomial
类
Laguerre(coef[, domain, window, symbol]) |
拉盖尔级数类。 |
|---|
常数
lagdomain |
代表多维、同构、固定大小项的数组对象。 |
|---|---|
lagzero |
代表多维、同构、固定大小项的数组对象。 |
lagone |
代表多维、同构、固定大小项的数组对象。 |
lagx |
代表多维、同构、固定大小项的数组对象。 |
算术
lagadd(c1, c2) |
将一个拉盖尔级数加到另一个拉盖尔级数。 |
|---|---|
lagsub(c1, c2) |
从另一个拉盖尔级数中减去一个拉盖尔级数。 |
lagmulx(c) |
将拉盖尔级数乘以 x。 |
lagmul(c1, c2) |
将一个 Laguerre 级数乘以另一个。 |
lagdiv(c1, c2) |
将一个 Laguerre 级数除以另一个。 |
lagpow(c, pow[, maxpower]) |
将 Laguerre 级数提高到幂。 |
lagval(x, c[, tensor]) |
在点 x 处评估 Laguerre 级数。 |
lagval2d(x, y, c) |
在点（x，y）处评估 2-D Laguerre 级数。 |
lagval3d(x, y, z, c) |
在点（x，y，z）处评估 3-D Laguerre 级数。 |
laggrid2d(x, y, c) |
在 x 和 y 的笛卡尔积上评估 2-D Laguerre 级数。 |
laggrid3d(x, y, z, c) |
在 x、y 和 z 的笛卡尔乘积上评估 3-D Laguerre 级数。 |
微积分
lagder(c[, m, scl, axis]) |
对 Laguerre 级数进行微分。 |
|---|---|
lagint(c[, m, k, lbnd, scl, axis]) |
对 Laguerre 级数进行积分。 |
杂项功能
lagfromroots(roots) |
生成具有给定根的 Laguerre 级数。 |
|---|---|
lagroots(c) |
计算 Laguerre 级数的根。 |
lagvander(x, deg) |
给定度数的伪 Vandermonde 矩阵。 |
lagvander2d(x, y, deg) |
给定度数的伪 Vandermonde 矩阵。 |
lagvander3d(x, y, z, deg) |
给定次数的伪范德蒙德矩阵。 |
laggauss(deg) |
高斯-拉盖尔求积。 |
lagweight(x) |
拉盖尔多项式的权重函数。 |
lagcompanion(c) |
返回 c 的伴随矩阵。 |
lagfit(x, y, deg[, rcond, full, w]) |
拉盖尔级数对数据的最小二乘拟合。 |
lagtrim(c[, tol]) |
从多项式中删除“小”“尾部”系数。 |
lagline(off, scl) |
其图形为直线的拉盖尔级数。 |
lag2poly(c) |
将拉盖尔级数转换为多项式。 |
poly2lag(pol) |
将多项式转换为拉盖尔级数。 |
另请参阅
numpy.polynomial
勒让德级数 (numpy.polynomial.legendre)
原文：
numpy.org/doc/1.26/reference/routines.polynomials.legendre.html
该模块提供了一些与勒让德级数处理相关的对象（主要是函数），包括一个封装了通常算术运算的Legendre类。（关于此模块如何表示和处理此类多项式的一般信息可以在其“父”子包numpy.polynomial的文档字符串中找到）。
类
Legendre(coef[, domain, window, symbol]) |
一个勒让德级数的类。 |
|---|
常量
legdomain |
一个数组对象，表示一个多维、同质且固定大小的数组。 |
|---|---|
legzero |
一个数组对象，表示一个多维、同质且固定大小的数组。 |
legone |
一个数组对象，表示一个多维、同质且固定大小的数组。 |
legx |
一个数组对象，表示一个多维、同质且固定大小的数组。 |
算术
legadd(c1, c2) |
将一个勒让德级数与另一个相加。 |
|---|---|
legsub(c1, c2) |
将一个勒让德级数从另一个中减去。 |
legmulx(c) |
用 x 乘以一个勒让德级数。 |
legmul(c1, c2) |
将一个勒让德级数与另一个相乘。 |
legdiv(c1, c2) |
将一个勒让德级数除以另一个。 |
legpow(c, pow[, maxpower]) |
将一个勒让德级数提升到某个幂。 |
legval(x, c[, tensor]) |
在点 x 处评估勒让德级数。 |
legval2d(x, y, c) |
在点（x，y）处评估 2-D 勒让德级数。 |
legval3d(x, y, z, c) |
在点（x, y, z）处评估 3-D 勒让德级数。 |
leggrid2d(x, y, c) |
在 x 和 y 的笛卡尔乘积上评估 2-D 勒让德级数。 |
leggrid3d(x, y, z, c) |
在 x、y 和 z 的笛卡尔乘积上评估 3-D 勒让德级数。 |
微积分
legder(c[, m, scl, axis]) |
差分一个勒让德级数。 |
|---|---|
legint(c[, m, k, lbnd, scl, axis]) |
积分一个勒让德级数。 |
杂项函数
legfromroots(roots) |
生成具有给定根的勒让德级数。 |
|---|---|
legroots(c) |
计算勒让德级数的根。 |
legvander(x, deg) |
给定次数的伪范德蒙矩阵。 |
legvander2d(x, y, deg) |
给定次数的伪范德蒙矩阵。 |
legvander3d(x, y, z, deg) |
给定次数的伪范德蒙矩阵。 |
leggauss(deg) |
高斯-勒让德积分。 |
legweight(x) |
勒让德多项式的权重函数。 |
legcompanion(c) |
返回 c 的缩放伴随矩阵。 |
legfit(x, y, deg[, rcond, full, w]) |
对 Legendre 序列进行最小二乘拟合。 |
legtrim(c[, tol]) |
从多项式中去除“小”的“尾部”系数。 |
legline(off, scl) |
其图形是一条直线的 Legendre 序列。 |
leg2poly(c) |
将一个 Legendre 序列转换为多项式。 |
poly2leg(pol) |
将多项式转换为 Legendre 序列。 |
请参阅
numpy.polynomial
类
Legendre(coef[, domain, window, symbol]) |
一个 Legendre 序列类。 |
|---|
常数
legdomain |
一个数组对象，代表一个多维的、同质的、固定大小项的数组。 | |
|---|---|---|
legzero |
一个数组对象，代表一个多维的、同质的、固定大小项的数组。 | |
legone |
一个数组对象，代表一个多维的、同质的、固定大小项的数组。 | |
legx |
一个数组对象，代表一个多维的、同质的、固定大小项的数组。 |
算术
legadd(c1, c2) |
将一个 Legendre 序列加到另一个 Legendre 序列。 | |
|---|---|---|
legsub(c1, c2) |
从另一个中减去一个 Legendre 序列。 | |
legmulx(c) |
将一个 Legendre 序列乘以 x。 | |
legmul(c1, c2) |
将一个勒让德级数乘以另一个。 | |
legdiv(c1, c2) |
将一个勒让德级数除以另一个。 | |
legpow(c, pow[, maxpower]) |
将一个勒让德级数提升到一次幂。 | |
legval(x, c[, tensor]) |
在点 x 处评估勒让德级数。 | |
legval2d(x, y, c) |
在点(x, y)处评估二维勒让德级数。 | |
legval3d(x, y, z, c) |
在点(x, y, z)处评估三维勒让德级数。 | |
leggrid2d(x, y, c) |
在笛卡尔积 x 和 y 上评估二维勒让德级数。 | |
leggrid3d(x, y, z, c) |
在笛卡尔积 x、y 和 z 上评估三维勒让德级数。 |
微积分
legder(c[, m, scl, axis]) |
求勒让德级数的导数。 |
|---|---|
legint(c[, m, k, lbnd, scl, axis]) |
对勒让德级数进行积分。 |
杂项函数
legfromroots(roots) |
生成具有给定根的勒让德级数。 |
|---|---|
legroots(c) |
计算勒让德级数的根。 |
legvander(x, deg) |
给定阶数的伪范德蒙德矩阵。 |
legvander2d(x, y, deg) |
给定阶数的伪范德蒙德矩阵。 |
legvander3d(x, y, z, deg) |
给定次数的伪范德蒙矩阵。 |
leggauss(deg) |
高斯-勒让德积分。 |
legweight(x) |
勒让德多项式的权函数。 |
legcompanion(c) |
返回一阶矩阵 c 的缩放伴随矩阵。 |
legfit(x, y, deg[, rcond, full, w]) |
最小二乘将勒让德级数拟合至数据。 |
legtrim(c[, tol]) |
从多项式中删除“小”、“尾随”系数。 |
legline(off, scl) |
图形为直线的勒让德级数。 |
leg2poly(c) |
将勒让德级数转换为多项式。 |
poly2leg(pol) |
将多项式转换为勒让德级数。 |
另请参阅
numpy.polynomial
polyutils
原文：
numpy.org/doc/1.26/reference/routines.polynomials.polyutils.html
多项式模块的实用类和函数。
该模块提供：错误和警告对象；一个多项式基类；以及在polynomial和chebyshev模块中使用的一些常规例程。
警告对象
RankWarning |
当设计矩阵秩不足时，由 chebfit 发出。 |
|---|
函数
as_series(alist[, trim]) |
将参数返回为一组 1 维数组。 |
|---|---|
trimseq(seq) |
移除小的 Poly 系列系数。 |
trimcoef(c[, tol]) |
从多项式中移除"小的"和"尾部的"系数。 |
getdomain(x) |
返回适用于给定横纵坐标的定义域。 |
mapdomain(x, old, new) |
对输入点应用线性映射。 |
mapparms(old, new) |
在域之间进行线性映射参数。 |
警告对象
RankWarning |
当设计矩阵秩不足时，由 chebfit 发出。 |
|---|
函数
as_series(alist[, trim]) |
将参数返回为一组 1 维数组。 |
|---|---|
trimseq(seq) |
移除小的 Poly 系列系数。 |
trimcoef(c[, tol]) |
从多项式中移除"小的"和"尾部的"系��。 |
getdomain(x) |
返回适用于给定横纵坐标的定义域。 |
mapdomain(x, old, new) |
将线性映射应用于输入点。 |
mapparms(old, new) |
在领域之间线性映射参数。 |
poly1d
原文：
numpy.org/doc/1.26/reference/routines.polynomials.poly1d.html
基础知识
poly1d(c_or_r[, r, variable]) |
一维多项式类。 |
|---|---|
polyval(p, x) |
在特定值处评估多项式。 |
poly(seq_of_zeros) |
找到具有给定根序列的多项式的系数。 |
roots(p) |
返回具有给定系数的多项式的根。 |
拟合
polyfit(x, y, deg[, rcond, full, w, cov]) |
最小二乘多项式拟合。 |
|---|
微积分
polyder(p[, m]) |
返回多项式指定阶数的导数。 |
|---|---|
polyint(p[, m, k]) |
返回多项式的不定积分（原函数）。 |
算术
polyadd(a1, a2) |
两个多项式的和。 |
|---|---|
polydiv(u, v) |
返回多项式除法的商和余数。 |
polymul(a1, a2) |
找到两个多项式的乘积。 |
polysub(a1, a2) |
两个多项式的差（减法）。 |
警告
RankWarning |
当范德蒙矩阵秩不足时，由polyfit发出。 |
|---|
基础知识
poly1d(c_or_r[, r, variable]) |
一维多项式类。 |
|---|---|
polyval(p, x) |
在特定值处评估多项式。 |
poly(seq_of_zeros) |
找到具有给定根序列的多项式的系数。 |
roots(p) |
返回具有给定系数的多项式的根。 |
拟合
polyfit(x, y, deg[, rcond, full, w, cov]) |
最小二乘多项式拟合。 |
|---|
微积分
polyder(p[, m]) |
返回多项式指定阶数的导数。 |
|---|---|
polyint(p[, m, k]) |
返回多项式的不定积分（原函数）。 |
算术
polyadd(a1, a2) |
找到两个多项式的和。 |
|---|---|
polydiv(u, v) |
返回多项式除法的商和余数。 |
polymul(a1, a2) |
找到两个多项式的乘积。 |
polysub(a1, a2) |
两个多项式的差（减法）。 |
警告
RankWarning |
当范德蒙矩阵秩不足时，由polyfit发出警告。 |
|---|
