NumPy-1-26-中文文档-十五-

NumPy 1.26 中文文档（十五）

原文：numpy.org/doc/

`numpy.unwrap`

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

numpy.unwrap(p, discont=None, axis=-1, *, period=6.283185307179586)

通过求取大于周期的差值的补集来进行展开。

通过将与前一个元素的绝对差大于max(discont, period/2)的元素改为它们的period-补充值，可对信号p进行展开。

对于默认情况下period为(2\pi)且discont为(\pi)的情况，这将展开弧度相位p，其中相邻差值永远不会大于(\pi)，通过添加(2k\pi)，其中(k)是整数。

参数：

parray_like

输入数组。

discontfloat，可选

值之间的最大不连续性，默认为period/2。小于period/2的值被视为period/2。如果discont大于period/2，则与默认情况不同，discont应该更大。

axisint，可选

进行展开操作的轴，默认为最后一个轴。

periodfloat，可选

输入的范围大小，其范围内进行包装。默认情况下，它是2 pi。

在 1.21.0 版本中新增。

outndarray

输出数组。

另请参阅

rad2deg、deg2rad

注意事项

如果p中的不连续性小于period/2，但大于discont，则不进行展开，因为取补集只会使不连续性变大。

示例

>>> phase = np.linspace(0, np.pi, num=5)
>>> phase[3:] += np.pi
>>> phase
array([ 0\.        ,  0.78539816,  1.57079633,  5.49778714,  6.28318531]) # may vary
>>> np.unwrap(phase)
array([ 0\.        ,  0.78539816,  1.57079633, -0.78539816,  0\.        ]) # may vary
>>> np.unwrap([0, 1, 2, -1, 0], period=4)
array([0, 1, 2, 3, 4])
>>> np.unwrap([ 1, 2, 3, 4, 5, 6, 1, 2, 3], period=6)
array([1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> np.unwrap([2, 3, 4, 5, 2, 3, 4, 5], period=4)
array([2, 3, 4, 5, 6, 7, 8, 9])
>>> phase_deg = np.mod(np.linspace(0 ,720, 19), 360) - 180
>>> np.unwrap(phase_deg, period=360)
array([-180., -140., -100.,  -60.,  -20.,   20.,   60.,  100.,  140.,
 180.,  220.,  260.,  300.,  340.,  380.,  420.,  460.,  500.,
 540.])

`numpy.deg2rad`

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

numpy.deg2rad(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'deg2rad'>

将角度从度数转换为弧度。

参数：

xarray_like

角度（度数）。

outndarray、None 或 ndarray 和 None 的元组，可选

存储结果的位置。如果提供，必须具有输入广播到的形状。如果未提供或为 None，将返回一个新分配的数组。一个元组（仅作为关键字参数时可能）的长度必须等于输出数量。

wherearray_like，可选

此条件在输入上进行广播。在条件为真的位置，out数组将被设置为 ufunc 结果。否则，out数组将保留其原始值。注意，如果通过默认值out=None创建了一个未初始化的out数组，在其中条件为假的位置将保持未初始化。

**kwargs

关于其他仅关键字参数，请参阅 ufunc 文档。

yndarray

相应的弧度角。如果x是标量，则这是一个标量。

另请参阅

rad2deg

将角度从弧度转换为度数。

unwrap

通过包装来消除角度的大幅度跳跃。

注意

1.3.0 版本中的新功能。

deg2rad(x)等于x * pi / 180。

示例

>>> np.deg2rad(180)
3.1415926535897931

`numpy.rad2deg`

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

numpy.rad2deg(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'rad2deg'>

将角度从弧度转换为度。

参数：

xarray_like

弧度角。

outndarray、None 或 ndarray 和 None 的元组，可选

存储结果的位置。如果提供了，它必须具有输入广播到的形状。如果未提供或为 None，则返回一个新分配的数组。一个元组（仅作为关键字参数）的长度必须等于输出的数量。

wherearray_like，可选

此条件在输入上进行广播。在条件为 True 的位置，out数组将设置为 ufunc 结果。否则，out数组将保留其原始值。请注意，如果通过默认参数out=None创建了未初始化的out数组，则其中条件为 False 的位置将保持未初始化状态。

**kwargs

对于其他仅关键字参数，请参阅 ufunc 文档。

yndarray

相应的角度（如果x是标量，则为标量）。

另请参见

deg2rad

将角度从度转换为弧度。

unwrap

通过包裹来消除角度中的大幅跳变。

注意

自 1.3.0 版本新推出。

rad2deg(x)是180 * x / pi。

示例

>>> np.rad2deg(np.pi/2)
90.0

`numpy.sinh`

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

numpy.sinh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'sinh'>

双曲正弦，逐元素。

相当于1/2 * (np.exp(x) - np.exp(-x))或-1j * np.sin(1j*x)。

参数：

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是标量，则这是一个标量。

注意事项

如果提供了out，函数将结果写入其中，并返回对out的引用。（见示例）

引用

M. Abramowitz 和 I. A. Stegun，《数学函数手册》。纽约，纽约州：多佛，1972 年，第 83 页。

示例

>>> np.sinh(0)
0.0
>>> np.sinh(np.pi*1j/2)
1j
>>> np.sinh(np.pi*1j) # (exact value is 0)
1.2246063538223773e-016j
>>> # Discrepancy due to vagaries of floating point arithmetic.

>>> # Example of providing the optional output parameter
>>> out1 = np.array([0], dtype='d')
>>> out2 = np.sinh([0.1], out1)
>>> out2 is out1
True

>>> # Example of ValueError due to provision of shape mis-matched `out`
>>> np.sinh(np.zeros((3,3)),np.zeros((2,2)))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: operands could not be broadcast together with shapes (3,3) (2,2)

`numpy.cosh`

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

numpy.cosh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'cosh'>

双曲余弦，对每个元素进行运算。

等同于1/2 * (np.exp(x) + np.exp(-x))和np.cos(1j*x)。

参数：

x类似数组

输入数组。

outndarray，None，或 ndarray 和 None 的元组，可选

存储结果的位置。如果提供，必须具有输入广播到的形状。如果未提供或为 None，则返回一个新分配的数组。一个元组（仅作为关键字参数）的长度必须等于输出的数量。

where类似数组，可选

此条件广播到输入。在条件为 True 的位置，out数组将设置为 ufunc 结果。否则，out数组将保留其原始值。请注意，如果通过默认的out=None创建了一个未初始化的out数组，在其中条件为 False 的位置将保持未初始化。

**kwargs

对于其他仅限关键字参数，请参阅 ufunc 文档。

outndarray 或标量

与x具有相同形状的输出数组。如果x是标量，则这是一个标量。

示例

>>> np.cosh(0)
1.0

双曲余弦描述了悬垂电缆的形状：

>>> import matplotlib.pyplot as plt
>>> x = np.linspace(-4, 4, 1000)
>>> plt.plot(x, np.cosh(x))
>>> plt.show()

../../_images/numpy-cosh-1.png

`numpy.tanh`

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

numpy.tanh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'tanh'>

计算双曲正切的逐元素值。

等价于np.sinh(x)/np.cosh(x)或-1j * np.tan(1j*x)。

参数：

x数组样本

输入数组。

outndarray、None 或 ndarray 和 None 的元组，可选

结果存储的位置。如果提供，必须具有输入广播到的形状。如果未提供或为 None，则返回一个新分配的数组。元组（仅作为关键字参数）的长度必须等于输出数。

where数组样本，可选

此条件会广播到输入。在条件为真的位置，out 数组将设置为 ufunc 结果。在其他位置，out 数组将保持原始值。请注意，如果通过默认的out=None创建了一个未初始化的out数组，那么其中条件为假的位置将保持未初始化状态。

**kwargs

对于其他仅限关键字的参数，请参阅 ufunc 文档。

yndarray

相应的双曲正切值。如果x是标量，则为标量。

注意事项

如果提供了out，函数会将结果写入其中，并返回对out的引用。（参见示例）

参考

[1]

M. Abramowitz 和 I. A. Stegun，“数学函数手册”。纽约，多佛尔，1972 年，第 83 页。personal.math.ubc.ca/~cbm/aands/page_83.htm

[2]

维基百科，“双曲函数”，en.wikipedia.org/wiki/Hyperbolic_function

示例

>>> np.tanh((0, np.pi*1j, np.pi*1j/2))
array([ 0\. +0.00000000e+00j,  0\. -1.22460635e-16j,  0\. +1.63317787e+16j])

>>> # Example of providing the optional output parameter illustrating
>>> # that what is returned is a reference to said parameter
>>> out1 = np.array([0], dtype='d')
>>> out2 = np.tanh([0.1], out1)
>>> out2 is out1
True

>>> # Example of ValueError due to provision of shape mis-matched `out`
>>> np.tanh(np.zeros((3,3)),np.zeros((2,2)))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: operands could not be broadcast together with shapes (3,3) (2,2)

`numpy.arcsinh`

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

numpy.arcsinh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'arcsinh'>

逐元素反双曲正弦。

参数：

xarray_like

输入数组。

outndarray, None 或 ndarray 和 None 的元组，可选

存储结果的位置。如果提供，必须具有输入广播到的形状。如果未提供或为 None，则返回一个新分配的数组。只有作为关键字参数的元组必须具有与输出数量相等的长度。

wherearray_like，可选

此条件在输入上进行广播。在条件为 True 的位置，out数组将设置为 ufunc 结果。否则，out数组将保留其原始值。请注意，如果通过默认情况out=None创建了未初始化的out数组，其中条件为 False 的位置将保持未初始化状态。

**kwargs

对于其他仅关键字的参数，请参阅 ufunc 文档。

outndarray 或标量

与x相同形状的数组。如果x是标量，则这是一个标量。

注释

arcsinh 是一个多值函数：对于每个x，存在无穷多个数字z，使得sinh(z) = x。约定是返回其虚部位于[-pi/2, pi/2]的z。

对于实数输入数据类型，arcsinh 总是返回实数输出。对于每个无法表示为实数或无穷大的值，它返回nan并设置invalid浮点错误标志。

对于复数输入，arccos 是一个具有分支切线[1j, infj]和[-1j, -infj]的复解析函数，对前者从右侧连续，对后者从左侧连续。

反双曲正弦也被称为asinh或sinh^-1。

参考

[1]

M. Abramowitz 和 I.A. Stegun，“数学函数手册”，第 10 版，1964 年第 10 次印刷，第 86 页。personal.math.ubc.ca/~cbm/aands/page_86.htm

[2]

维基百科，“反双曲函数”，en.wikipedia.org/wiki/Arcsinh

示例

>>> np.arcsinh(np.array([np.e, 10.0]))
array([ 1.72538256,  2.99822295])

`numpy.arccosh`

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

numpy.arccosh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'arccosh'>

逐元素的反双曲余弦。

参数：

xarray_like

输入数组。

outndarray，None，或元组 ndarray 和 None，可选

结果存储的位置。如果提供，它必须具有输入广播到的形状。如果未提供或为 None，则返回一个新分配的数组。元组（仅作为关键字参数）的长度必须等于输出数。

wherearray_like, 可选

此条件传播到输入。在条件为 True 的位置，out数组将设置为 ufunc 的结果。否则，out数组将保留其原始值。请注意，如果通过默认的out=None创建未初始化的out数组，则其中条件为 False 的位置将保持未初始化。

**kwargs

对于其他仅关键字参数，请参阅 ufunc 文档。

arccoshndarray

与x形状相同的数组。如果x是标量，则这是一个标量。

另请参见

cosh, arcsinh, sinh, arctanh, tanh

注

arccosh 是一个多值函数：对于每个x，都存在无限多个z，使得 cosh(z) = x。约定是返回其虚部在[-pi, pi]区间内，实部在[0, inf]区间内的z。

对于实值输入数据类型，arccosh 总是返回实际输出。对于每个无法表示为实数或无限大的值，它会产生 nan 并设置无效的浮点错误标志。

对于复数值输入，arccosh 是一个具有分支切 [-inf, 1] 并在其上连续的复解析函数。

参考

[1]

M. Abramowitz 和 I.A. Stegun，“数学函数手册”，第 10 版印刷，1964 年，第 86 页。personal.math.ubc.ca/~cbm/aands/page_86.htm

[2]

维基百科，“反双曲函数”，en.wikipedia.org/wiki/Arccosh

示例

>>> np.arccosh([np.e, 10.0])
array([ 1.65745445,  2.99322285])
>>> np.arccosh(1)
0.0

`numpy.arctanh`

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

numpy.arctanh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'arctanh'>

逐元素的反双曲正切。

参数：

xarray_like

输入数组。

outndarray、None 或 ndarray 和 None 的元组，可选

存储结果的位置。如果提供，则必须具有输入广播到的形状。如果未提供或为 None，则返回一个新分配的数组。元组（仅作为关键字参数）的长度必须等于输出数量。

wherearray_like, optional

此条件广播到输入。在条件为 True 的位置，out数组将设置为 ufunc 结果。在其他地方，out数组将保留其原始值。请注意，如果通过默认out=None创建了一个未初始化的out数组，在其中条件为 False 的位置将保持未初始化状态。

**kwargs

对于其他仅限关键字参数，请参阅 ufunc 文档。

outndarray 或标量

与x相同形状的数组。如果x是标量，则为标量。

另请参见

emath.arctanh

说明

arctanh是一个多值函数：对于每个x，存在无限多个数z满足tanh(z) = x。约定是返回其虚部在[-pi/2, pi/2]范围内的z。

对于实值输入数据类型，arctanh总是返回实数输出。对于每个不能表示为实数或无穷大的值，它产生nan并设置invalid浮点错误标志。

对于复数输入，arctanh是一个具有分支截面[-1, -inf]和[1, inf]的复数解析函数，并且在前者上是连续的，在后者下是连续的。

反双曲正切也被称为atanh或tanh^-1。

参考资料

[1]

M. Abramowitz 和 I.A. Stegun，“数学函数手册”，1964 年第 10 版，第 86 页。personal.math.ubc.ca/~cbm/aands/page_86.htm

[2]

维基百科，“反双曲函数”，en.wikipedia.org/wiki/Arctanh

示例

>>> np.arctanh([0, -0.5])
array([ 0\.        , -0.54930614])

`numpy.round`

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

numpy.round(a, decimals=0, out=None)

均匀地四舍五入到指定的小数位数。

参数：

aarray_like

输入数据。

decimalsint, 可选

要四舍五入的小数位数（默认值：0）。如果 decimals 为负数，则指定小数点左侧的位置数。

outndarray, 可选

替代输出数组，用于放置结果。它必须具有与期望输出相同的形状，但必要时将强制转换输出值的类型。更多详细信息，请参见输出类型确定。

rounded_arrayndarray

一个与a相同类型的数组，包含四舍五入的值。除非指定了out，否则将创建一个新数组。将返回结果的引用。

复数的实部和虚部分别四舍五入。将浮点数四舍五入的结果是一个浮点数。

另请参阅

ndarray.round

等效的方法

around

此函数的别名

ceil, fix, floor, rint, trunc

注释

对于恰好处于四舍五入的十进制值之间的值，NumPy 会向最近的偶数值进行四舍五入。因此 1.5 和 2.5 会四舍五入为 2.0，-0.5 和 0.5 会四舍五入为 0.0，等等。

np.round使用一个快速但有时不精确的算法来四舍五入浮点数据类型。对于正的decimals，它等效于np.true_divide(np.rint(a * 10**decimals), 10**decimals)，由于 IEEE 浮点标准中小数分数的不精确表示导致误差 [1]，并且通过乘以十的幂引入的误差。例如，请注意以下数字中额外的“1”：

>>> np.round(56294995342131.5, 3)
56294995342131.51

如果你的目标是以固定的小数位打印这些值，最好使用 numpy 的浮点打印例程来限制打印的小数位数：

>>> np.format_float_positional(56294995342131.5, precision=3)
'56294995342131.5'

浮点数打印例程使用一种准确但计算量要求更高的算法来计算小数点后的位数。

或者，Python 的内置round函数使用一个更准确但速度较慢的算法来处理 64 位浮点值：

>>> round(56294995342131.5, 3)
56294995342131.5
>>> np.round(16.055, 2), round(16.055, 2)  # equals 16.0549999999999997
(16.06, 16.05)

参考

[1]

“IEEE 754 标准状况讲义”，威廉·卡恩，people.eecs.berkeley.edu/~wkahan/ieee754status/IEEE754.PDF

示例

>>> np.round([0.37, 1.64])
array([0., 2.])
>>> np.round([0.37, 1.64], decimals=1)
array([0.4, 1.6])
>>> np.round([.5, 1.5, 2.5, 3.5, 4.5]) # rounds to nearest even value
array([0., 2., 2., 4., 4.])
>>> np.round([1,2,3,11], decimals=1) # ndarray of ints is returned
array([ 1,  2,  3, 11])
>>> np.round([1,2,3,11], decimals=-1)
array([ 0,  0,  0, 10])

`numpy.around`

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

numpy.around(a, decimals=0, out=None)

将数组四舍五入到指定的小数位数。

around 是 round 的别名。

另请参阅

ndarray.round

等效方法

round

此函数的别名

ceil, fix, floor, rint, trunc

`numpy.rint`

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

numpy.rint(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'rint'>

将数组元素四舍五入到最接近的整数。

参数：

xarray_like

输入数组。

outndarray、None 或 ndarray 和 None 的元组，可选

存储结果的位置。如果提供，则它必须具有输入广播到的形状。如果未提供或为 None，则返回一个新分配的数组。元组（仅作为关键字参数）的长度必须等于输出的数量。

wherearray_like，可选

此条件广播到输入上。在条件为 True 的位置，out 数组将设置为 ufunc 结果。在其他位置，out 数组将保留其原始值。请注意，如果通过默认out=None创建了一个未初始化的out数组，则其中条件为 False 的位置将保持未初始化。

**kwargs

对于其他仅关键字参数，请参阅 ufunc 文档。

outndarray 或标量

输出数组与x具有相同的形状和类型。如果x为标量，则为标量。

另请参见

fix、ceil、floor、trunc

注意

对于正好位于四舍五入十进制值之间的值，NumPy 会四舍五入到最接近的偶数值。因此，1.5 和 2.5 四舍五入为 2.0，-0.5 和 0.5 四舍五入为 0.0，依此类推。

示例

>>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0])
>>> np.rint(a)
array([-2., -2., -0.,  0.,  2.,  2.,  2.])

`numpy.fix`

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

numpy.fix(x, out=None)

向零舍入到最接近的整数。

将浮点数数组逐元素四舍五入到最接近的整数向零。四舍五入后的值以浮点数返回。

参数：

x类似数组

要四舍五入的浮点数数组

outndarray，可选

存储结果的位置。如果提供了，则必须具有输入广播到的形状。如果未提供或为 None，则返回一个新分配的数组。

out浮点数组

一个与输入相同维度的浮点数组。如果没有提供第二个参数，则返回一个具有四舍五入值的浮点数组。

如果提供了第二个参数，则将结果存储在那里。返回值 out 然后是对该数组的引用。

另请参阅

rint, trunc, floor, ceil

around

四舍五入到给定的小数位数

示例

>>> np.fix(3.14)
3.0
>>> np.fix(3)
3.0
>>> np.fix([2.1, 2.9, -2.1, -2.9])
array([ 2.,  2., -2., -2.])

`numpy.floor`

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

numpy.floor(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'floor'>

返回输入的向下取整，逐元素。

标量x的底部是最大的整数i，使得i <= x。通常表示为(\lfloor x \rfloor)。

参数：

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是标量，则这是一个标量。

另请参见

ceil，trunc，rint，fix

注意

一些电子表格程序计算“朝零方向取整”，其中floor(-2.5) == -2。NumPy 相反使用floor的定义，其中floor(-2.5) == -3。“朝零方向取整”函数在 NumPy 中称为fix。

示例

>>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0])
>>> np.floor(a)
array([-2., -2., -1.,  0.,  1.,  1.,  2.])

`numpy.ceil`

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

numpy.ceil(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'ceil'>

返回输入的元素的上限，逐个元素进行。

标量 x 的天花板是最小的整数 i，满足 i >= x。它通常表示为 (\lceil x \rceil)。

参数：

x array_like

输入数据。

outndarray、None 或 ndarray 和 None 的元组，可选

存储结果的位置。如果提供，它必须具有输入广播到的形状。如果未提供或为 None，则返回一个新分配的数组。一个元组（仅作为关键字参数）必须具有与输出数量相等的长度。

wherearray_like，可选

此条件在输入上进行广播。在条件为 True 的位置上，out 数组将设置为 ufunc 的结果。在其他位置，out 数组将保留其原始值。请注意，如果通过默认的 out=None 创建了一个未初始化的 out 数组，则其中条件为 False 的位置将保持未初始化。

**kwargs

对于其他关键字参数，请参阅 ufunc 文档。

y ndarray 或标量

x 中每个元素的上限，dtype 为 float。如果 x 是标量，则为标量。

另请参见

floor, trunc, rint, fix

示例

>>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0])
>>> np.ceil(a)
array([-1., -1., -0.,  1.,  2.,  2.,  2.])

`numpy.trunc`

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

numpy.trunc(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'trunc'>

返回输入的截断值，逐元素操作。

标量 x 的截断值是最接近零的整数 i，比 x 更靠近零。简而言之，有符号数字 x 的小数部分被丢弃。

参数：

xarray_like

输入数据。

outndarray、无或者 ndarray 及无的元组，可选

结果存储的位置。如果提供，它必须具有输入数据广播到的形状。如果未提供或为 None，则返回一个新分配的数组。一个元组（仅限关键字参数）必须具有与输出数量相等的长度。

wherearray_like，可选

此条件将广播到输入数据上。在条件为 True 的位置，out 数组将设置为 ufunc 结果。在其他位置，out 数组将保留其原始值。请注意，如果通过默认值 out=None 创建了未初始化的 out 数组，在其中条件为 False 的位置将保持未初始化状态。

**kwargs

对于其他仅限关键字参数，请参阅 ufunc 文档。

yndarray 或者标量

x 中每个元素的截断值。如果 x 是标量，则为标量。

另请参见

ceil, floor, rint, fix

注意

新版本 1.3.0 中推出。

示例

>>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0])
>>> np.trunc(a)
array([-1., -1., -0.,  0.,  1.,  1.,  2.])

`numpy.prod`

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

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

返回给定轴上数组元素的乘积。

参数：

a类似数组

输入数据。

axisNone 或 int 或 int 元组，可选

执行乘积的轴或轴。默认值 axis=None 将计算输入数组中所有元素的乘积。如果 axis 为负，则从最后一个到第一个轴计数。

1.7.0 版本中的新功能。

如果 axis 是一个 int 元组，将在元组中指定的所有轴上执行乘积，而不是像以前那样在单个轴或所有轴上执行。

dtypedtype，可选

返回数组的类型，以及元素相乘的累加器的类型。默认情况下使用a的 dtype，除非a的整数 dtype 比默认平台整数低精度。在这种情况下，如果a是有符号的，则使用平台整数，而如果a是无符号的，则使用与平台整数相同精度的无符号整数。

outndarray，可选

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

keepdims布尔值，可选

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

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

initial标量，可选

此乘积的初始值。有关详情，请参见reduce。

1.15.0 版本中的新功能。

where布尔数组，可选

要包括在乘积中的元素。有关详情，请参见reduce。

1.17.0 版本中的新功能。

product_along_axisndarray，参见上述dtype参数。

一个形状与a相同但去除指定轴的数组。如果指定，则返回对out的引用。

参见

ndarray.prod

等效的方法

输出类型确定

注意事项

在使用整数类型时算术是模块化的，溢出时不会引发错误。这意味着，在 32 位平台上：

>>> x = np.array([536870910, 536870910, 536870910, 536870910])
>>> np.prod(x)
16 # may vary

空数组的乘积是中性元素 1：

>>> np.prod([])
1.0

示例

默认情况下，计算所有元素的乘积：

>>> np.prod([1.,2.])
2.0

即使输入数组是二维的：

>>> a = np.array([[1., 2.], [3., 4.]])
>>> np.prod(a)
24.0

但我们也可以指定要进行乘法的轴：

>>> np.prod(a, axis=1)
array([  2.,  12.])
>>> np.prod(a, axis=0)
array([3., 8.])

或选择特定要包括的元素：

>>> np.prod([1., np.nan, 3.], where=[True, False, True])
3.0

如果x的类型是无符号的，则输出类型为无符号平台整数：

>>> x = np.array([1, 2, 3], dtype=np.uint8)
>>> np.prod(x).dtype == np.uint
True

如果x是有符号整数类型，则输出类型为默认平台整数：

>>> x = np.array([1, 2, 3], dtype=np.int8)
>>> np.prod(x).dtype == int
True

你还可以从一个值开始计算积，而不是从一开始：

>>> np.prod([1, 2], initial=5)
10

`numpy.sum`

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

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

给定轴上数组元素的总和。

参数:

aarray_like

要求和的元素。

axisNone 或 int 或 int 的元组，可选

执行求和的轴或轴。默认 axis=None 将对输入数组的所有元素求和。如果 axis 为负，则从最后一个轴到第一个轴计数。

1.7.0 版中新增。

如果 axis 是 int 的元组，则对元组中指定的所有轴执行求和，而不是以前的单个轴或所有轴。

dtypedtype，可选

返回的数组类型以及对元素求和的累加器的类型。除非a具有比默认平台整数更低精度的整数 dtype，否则默认情况下使用a的 dtype。在这种情况下，如果a为有符号数，则使用平台整数，而如果a为无符号数，则使用与平台整数相同精度的无符号整数。

outndarray，可选

可替代的输出数组，用于放置结果。它必须具有与期望输出相同的形状，但必要时将转换输出值的类型。

keepdimsbool，可选

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

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

initialscalar，可选

求和的起始值。详情请参见reduce。

1.15.0 版中新增。

wherebool 数组，可选

包含在总和中的元素。详情请参见reduce。

1.17.0 版中新增。

sum_along_axisndarray

一个与a形状相同的数组，指定轴已移除。如果a是 0 维数组，或者 axis 为 None，则返回一个标量。如果指定了输出数组，则返回out的引用。

另请参见

ndarray.sum

等效方法。

add.reduce

与add相同的功能。

cumsum

数组元素的累积和。

trapz

使用复合梯形规则对数组值进行积分。

mean, average

注释

使用整数类型时，算术是模数的，并且在溢出时不会引发错误。

空数组的总和是中性元素0：

>>> np.sum([])
0.0

对于浮点数，sum（和np.add.reduce）的数值精度通常受到直接将每个数字逐个加到结果中的限制，从而在每一步都引起舍入误差。然而，numpy 通常会使用一个数值更好的方法（部分成对求和），从而在许多用例中提供了改进的精度。当没有给出axis时，总是提供这种改进的精度。当给出axis时，它将取决于哪个轴被求和。从技术上讲，为了提供可能的最佳速度，只有在内存中的快速轴上进行求和时，才使用改进的精度。注意，确切的精度可能会因其他参数而异。与 NumPy 相反，Python 的math.fsum函数使用了一种更慢但更精确的求和方法。特别是在求和大量低精度浮点数，如float32时，数值误差可能会变得显著。在这种情况下，建议使用dtype="float64"以使用更高的输出精度。

示例

>>> np.sum([0.5, 1.5])
2.0
>>> np.sum([0.5, 0.7, 0.2, 1.5], dtype=np.int32)
1
>>> np.sum([[0, 1], [0, 5]])
6
>>> np.sum([[0, 1], [0, 5]], axis=0)
array([0, 6])
>>> np.sum([[0, 1], [0, 5]], axis=1)
array([1, 5])
>>> np.sum([[0, 1], [np.nan, 5]], where=[False, True], axis=1)
array([1., 5.])

如果累加器太小，就会发生溢出：

>>> np.ones(128, dtype=np.int8).sum(dtype=np.int8)
-128

你也可以用一个不为零的值开始求和：

>>> np.sum([10], initial=5)
15

`numpy.nanprod`

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

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

返回沿给定轴上的数组元素的乘积，将不是数字（NaN）视为 1。

对于所有是 NaN 或空的切片，返回值为 1。

新版本为 1.10.0。

参数：

a 类似数组

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

axis，可选参数

计算乘积的轴或轴。默认情况下，计算平坦数组的乘积。

dtype 数据类型，可选参数

返回数组的类型，以及计算元素总和的累加器的类型。默认情况下，使用 a 的数据类型。但当 a 具有低于平台精度的整数类型（u）intp 时，情况就有所不同。在这种情况下，默认将是（u）int32 或（u）int64，具体取决于平台是 32 位还是 64 位。对于不精确的输入，数据类型必须是不精确的。

out 类似数组，可选参数

包含结果的备用输出数组。默认为 None。如果提供，则必须具有与预期输出相同的形状，但根据需要将转换类型。更多详情请参见输出类型确定。将 NaN 转换为整数可能会产生意外的结果。

keepdims 布尔值，可选参数

如果为 True，则被减少的轴将作为大小为一的维度保留在结果中。使用此选项，结果将正确传播至原始数组 arr。

initial 数量，可选参数

此乘积的起始值。具体内容请参见 reduce。

新版本为 1.22.0。

where 布尔类型数组，可选参数

包含在乘积中的元素。具体内容请参见 reduce。

新版本为 1.22.0。

返回值：

nanprod 类似数组

返回一个新的数组，除非指定了 out，否则将返回结果。

请参阅

numpy.prod

在数组中跨越 NaN 进行计算。

isnan

显示哪些元素是 NaN。

示例

>>> np.nanprod(1)
1
>>> np.nanprod([1])
1
>>> np.nanprod([1, np.nan])
1.0
>>> a = np.array([[1, 2], [3, np.nan]])
>>> np.nanprod(a)
6.0
>>> np.nanprod(a, axis=0)
array([3., 2.])

`numpy.nansum`

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

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

返回在给定轴上对数组元素求和的结果，将 Not a Number（NaN）视为零。

在 NumPy 版本 <= 1.9.0 中，针对全部是 NaN 或者空数组的切片会返回 Nan。在后续版本中，将返回零。

参数：

a 类似数组

包含��需求和结果的数字数组。如果 a 不是数组，则尝试进行转换。

axis {int, int 元组, None}，可选参数

沿着其进行求和的轴或轴。默认是对压平的数组求和。

dtype 数据类型，可选参数

返回的数组和元素求和的累加器的数据类型。默认情况下，使用 a 的数据类型。特例是当 a 的整数类型比平台的精度低时（u）intp。在这种情况下，默认值将分别为（u）int32 或（u）int64，具体取决于平台是 32 位还是 64 位。对于不精确的输入，数据类型必须是不精确的。

新版本 1.8.0 中。

out ndarray，可选参数

用于存放结果的备用输出数组。默认值为 None。如果提供，则必须具有与预期输出相同的形状，但必要时会进行类型转换。有关更多详情，请参阅输出类型确定。将 NaN 转换为整数可能会产生意外结果。

新版本 1.8.0 中。

keepdims 布尔型，可选参数

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

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

新版本 1.8.0 中。

initial 标量，可选参数

求和的起始值。详见reduce。

新版本 1.22.0 中。

where 布尔型数组，可选参数

要包含在求和中的元素。详见reduce。

新版本 1.22.0 中。

nansum ndarray。

返回一个新的数组来保存结果，除非指定了 out 参数，否则将返回该数组。如果 axis 不为 None 或者 a 是一个一维数组，则结果的大小和 a 的形状相同。

另请参阅

numpy.sum

对数组中的 NaN 进行求和。

isnan

显示哪些元素是 NaN。

isfinite

显示哪些元素不是 NaN 或 +/-inf。

注意事项

如果同时存在正无穷大和负无穷大，它们的和将为非数字（NaN）。

示例

>>> np.nansum(1)
1
>>> np.nansum([1])
1
>>> np.nansum([1, np.nan])
1.0
>>> a = np.array([[1, 1], [1, np.nan]])
>>> np.nansum(a)
3.0
>>> np.nansum(a, axis=0)
array([2.,  1.])
>>> np.nansum([1, np.nan, np.inf])
inf
>>> np.nansum([1, np.nan, np.NINF])
-inf
>>> from numpy.testing import suppress_warnings
>>> with suppress_warnings() as sup:
...     sup.filter(RuntimeWarning)
...     np.nansum([1, np.nan, np.inf, -np.inf]) # both +/- infinity present
nan

`numpy.cumprod`

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

numpy.cumprod(a, axis=None, dtype=None, out=None)

返回沿着给定轴的元素的累积乘积。

参数：

aarray_like

输入数组。

axisint, optional

计算累积乘积的轴。默认情况下，输入被展平。

dtypedtype, optional

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

outndarray, optional

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

cumprodndarray

除非指定out，否则将返回一个包含结果的新数组；如果指定了out，则返回对out的引用。

另见

输出类型确定

注意

当使用整数类型时，运算是模块化的，并且在溢出时不会引发错误。

示例

>>> a = np.array([1,2,3])
>>> np.cumprod(a) # intermediate results 1, 1*2
...               # total product 1*2*3 = 6
array([1, 2, 6])
>>> a = np.array([[1, 2, 3], [4, 5, 6]])
>>> np.cumprod(a, dtype=float) # specify type of output
array([   1.,    2.,    6.,   24.,  120.,  720.])

每列（即在行上）a的累积乘积：

>>> np.cumprod(a, axis=0)
array([[ 1,  2,  3],
 [ 4, 10, 18]])

每行（即在列上）a的累积乘积：

>>> np.cumprod(a,axis=1)
array([[  1,   2,   6],
 [  4,  20, 120]])

`numpy.cumsum`

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

numpy.cumsum(a, axis=None, dtype=None, out=None)

返回沿给定轴的元素的累积和。

参数：

a array_like

输入数组。

axis int，可选

在其上计算累积和的轴。默认值（None）是在展开的数组上计算累积和。

dtype dtype，可选

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

out ndarray，可选

可选的替代输出数组，用于放置结果。它必须具有与预期输出相同的形状和缓冲区长度，但如果需要，类型将被转换。有关更多详细信息，请参见输出类型确定。

cumsum_along_axis ndarray。

返回一个保存结果的新数组，除非指定了out，否则返回对out的引用。如果axis不是 None 或a是 1 维数组，则结果与a具有相同的大小和形状。

另请参阅

sum

对数组元素求和。

trapz

使用复合梯形规则对数组值进行积分。

diff

计算沿指定轴的第 n 个离散差分。

注意

使用整数类型时，算术操作是模数的，如果溢出不会引发错误。

cumsum(a)[-1] 的结果可能与 sum(a) 不相等，因为sum可能使用成对求和例程，减小舍入误差。更多信息请参见sum。

示例

>>> a = np.array([[1,2,3], [4,5,6]])
>>> a
array([[1, 2, 3],
 [4, 5, 6]])
>>> np.cumsum(a)
array([ 1,  3,  6, 10, 15, 21])
>>> np.cumsum(a, dtype=float)     # specifies type of output value(s)
array([  1.,   3.,   6.,  10.,  15.,  21.])

>>> np.cumsum(a,axis=0)      # sum over rows for each of the 3 columns
array([[1, 2, 3],
 [5, 7, 9]])
>>> np.cumsum(a,axis=1)      # sum over columns for each of the 2 rows
array([[ 1,  3,  6],
 [ 4,  9, 15]])

cumsum(b)[-1] 的结果可能与 sum(b) 不相等

>>> b = np.array([1, 2e-9, 3e-9] * 1000000)
>>> b.cumsum()[-1]
1000000.0050045159
>>> b.sum()
1000000.0050000029

`numpy.nancumprod`

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

numpy.nancumprod(a, axis=None, dtype=None, out=None)

在给定轴上返回数组元素的累积乘积，将 Not a Numbers（NaN）视为一个。当遇到 NaN 时，累积乘积不会改变，前导 NaN 将被替换为 1。

对于全是 NaN 或空的切片，将返回 1。

1.12.0 版中新增。

参数：

aarray_like

输入数组。

轴int，可选

计算累积乘积的轴。默认情况下，输入将被展平。

dtypedtype，可选

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

输出ndarray，可选

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

nancumprodndarray

除非指定了out，否则将返回一个持有结果的新数组。

另请参阅

numpy.cumprod

穿越数组的累积乘积，传播 NaN。

isnan

显示哪些元素是 NaN。

例子

>>> np.nancumprod(1)
array([1])
>>> np.nancumprod([1])
array([1])
>>> np.nancumprod([1, np.nan])
array([1.,  1.])
>>> a = np.array([[1, 2], [3, np.nan]])
>>> np.nancumprod(a)
array([1.,  2.,  6.,  6.])
>>> np.nancumprod(a, axis=0)
array([[1.,  2.],
 [3.,  2.]])
>>> np.nancumprod(a, axis=1)
array([[1.,  2.],
 [3.,  3.]])

`numpy.nancumsum`

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

numpy.nancumsum(a, axis=None, dtype=None, out=None)

返回给定轴上数组元素的累积和，将非数字（NaN）视为零。当遇到 NaN 时，累积总和不会改变，并且前导 NaN 将被零替换。

对于所有-NaN 或空的切片，返回零。

自版本 1.12.0 开始。

参数：

aarray_like

输入数组。

轴int，可选

计算累积总和的轴。默认值（None）是在扁平化数组上计算累积总和。

dtypedtype，可选

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

outndarray，可选

替代输出数组中放置结果。它必须具有与预期输出相同的形状和缓冲区长度，但如果需要则将类型转换。有关更多详细信息，请参见输出类型确定。

nancumsumndarray。

除非指定了out，否则将返回保存结果的新数组。如果axis不为空，或者a是一个 1-d 数组，则结果的大小与a相同，形状与a相同。

另请参阅

numpy.cumsum

数组累积总和，传播 NaN。

isnan

显示哪些元素是 NaN。

示例

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

`numpy.diff`

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

numpy.diff(a, n=1, axis=-1, prepend=<no value>, append=<no value>)

计算沿给定轴的第 n 个离散差分。

第一次差分由 out[i] = a[i+1] - a[i] 沿着给定轴计算得出，更高的差分通过递归使用 diff 计算。

参数：

aarray_like

输入数组

nint, 可选

值的差异次数。如果为零，则原始输入将保持不变。

axisint, 可选

进行差分的轴，默认是最后一个轴。

prepend, appendarray_like, 可选

在执行差分之前沿着轴添加的值。标量值在轴的方向上扩展为具有长度 1 的数组，并且在所有其他轴向上扩展为输入数组的形状。否则，维度和形状必须与 a 相匹配，除了轴向。

从版本 1.16.0 开始。

diffndarray

第 n 个差分。输出的形状与 a 相同，除了沿着 axis 的维度小了 n。输出类型与 a 中任意两个元素的差异类型相同。在大多数情况下，这与 a 的类型相同。一个值得注意的例外是datetime64，它的输出结果是timedelta64数组。

另请参见

梯度，ediff1d，cumsum

笔记

对于布尔数组，类型是保留的，因此结果将包含False，当连续元素相同时，结果为True，当它们不同时。

对于无符号整数数组，结果也将是无符号的。这并不奇怪，因为结果与直接计算差异是一致的：

>>> u8_arr = np.array([1, 0], dtype=np.uint8)
>>> np.diff(u8_arr)
array([255], dtype=uint8)
>>> u8_arr[1,...] - u8_arr[0,...]
255

如果这不是期望的结果，那么数组应首先转换为较大的整数类型：

>>> i16_arr = u8_arr.astype(np.int16)
>>> np.diff(i16_arr)
array([-1], dtype=int16)

示例

>>> x = np.array([1, 2, 4, 7, 0])
>>> np.diff(x)
array([ 1,  2,  3, -7])
>>> np.diff(x, n=2)
array([  1,   1, -10])

>>> x = np.array([[1, 3, 6, 10], [0, 5, 6, 8]])
>>> np.diff(x)
array([[2, 3, 4],
 [5, 1, 2]])
>>> np.diff(x, axis=0)
array([[-1,  2,  0, -2]])

>>> x = np.arange('1066-10-13', '1066-10-16', dtype=np.datetime64)
>>> np.diff(x)
array([1, 1], dtype='timedelta64[D]')

`numpy.ediff1d`

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

numpy.ediff1d(ary, to_end=None, to_begin=None)

数组中连续元素之间的差异。

参数：

aryarray_like

如果需要，在获取差异之前将被展平。

to_endarray_like，可选

要附加到返回的差异末尾的数字。

to_beginarray_like，可选

要添加到返回的差异开头的数字。

ediff1dndarray

差异。宽泛地说，这是ary.flat[1:] - ary.flat[:-1]。

另请参阅

diff，gradient

笔记

当应用于掩码数组时，如果使用了to_begin和/或to_end参数，则此函数会丢弃掩码信息。

示例

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

>>> np.ediff1d(x, to_begin=-99, to_end=np.array([88, 99]))
array([-99,   1,   2, ...,  -7,  88,  99])

返回的数组始终为 1D。

>>> y = [[1, 2, 4], [1, 6, 24]]
>>> np.ediff1d(y)
array([ 1,  2, -3,  5, 18])

`numpy.gradient`

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

numpy.gradient(f, *varargs, axis=None, edge_order=1)

返回 N 维数组的梯度。

在内部点使用二阶精确中心差分，边界点使用一阶或二阶精确单边（向前或向后）差分计算梯度。因此返回的梯度与输入数组具有相同的形状。

参数：

farray_like

包含标量函数的样本的 N 维数组。

varargs标量或数组的列表，可选

f 值之间的间距。所有维度的默认单位间距。间距可以使用以下方式指定：

单个标量以指定所有维度的样本距离。
N 个标量以指定每个维度的常量采样距离。即 dx, dy, dz, …
N 个数组以指定 F 沿每个维度的值的坐标。数组的长度必须与相应维度的大小相匹配
任何组合的 N 个标量/数组，含义为 2. 和 3.。

如果 axis 给定，则 varargs 的数量必须等于轴的数量。默认值：1。

edge_order，可选

在边界处使用 N 阶精确差分计算梯度。默认值：1。

新版本 1.9.1 中的功能。

axisNone 或 int 或 int 元组，可选

仅沿着给定轴或轴计算梯度默认（axis = None）是计算输入数组的所有轴的梯度。轴可以是负数，此时从最后一个轴向第一个轴计数。

新版本 1.11.0 中的功能。

gradientndarray 或 ndarray 列表

一个 ndarray 列表（或仅当存在一个维度时为单个 ndarray）对应于 f 关于每个维度的导数。每个导数的形状与 f 相同。

注意事项

假设 (f\in C^{3})（即 (f) 至少具有 3 阶连续导数），令 (h_{*}) 为非齐次步长，我们最小化真实梯度与从相邻网格点的线性组合估计出的梯度之间的“一致性误差” (\eta_{i})：

[\eta_{i} = f_{i}^{\left(1\right)} - \left[ \alpha f\left(x_{i}\right) + \beta f\left(x_{i} + h_{d}\right) + \gamma f\left(x_{i}-h_{s}\right) \right]]

通过用它们的 Taylor 级数展开替换 (f(x_{i} + h_{d})) 和 (f(x_{i} - h_{s}))，这转化为解决以下线性系统：

[\begin{split}\left{ \begin{array}{r} \alpha+\beta+\gamma=0 \ \beta h_{d}-\gamma h_{s}=1 \ \beta h_{d}^{2}+\gamma h_{s}^{2}=0 \end{array} \right.\end{split}]

(f_{i}^{(1)}) 的结果近似如下：

[\hat f_{i}^{(1)} = \frac{ h_{s}^{2}f\left(x_{i} + h_{d}\right) + \left(h_{d}^{2} - h_{s}^{2}\right)f\left(x_{i}\right) - h_{d}^{2}f\left(x_{i}-h_{s}\right)} { h_{s}h_{d}\left(h_{d} + h_{s}\right)} + \mathcal{O}\left(\frac{h_{d}h_{s}^{2} + h_{s}h_{d}^{2}}{h_{d} + h_{s}}\right)]

值得注意的是，如果(h_{s}=h_{d})（即数据均匀分布），我们会得到标准的二阶近似：

[\hat f_{i}^{(1)}= \frac{f\left(x_{i+1}\right) - f\left(x_{i-1}\right)}{2h} + \mathcal{O}\left(h^{2}\right)]

通过类似的过程，可以得到边界使用的前向/后向近似。

参考文献

[1]

《数值数学（应用数学文本）》，2007 年 Quarteroni A., Sacco R., Saleri F. New York: Springer.

[2]

《地球物理流体动力学中的波动方程数值方法》（1999）Durran D. R. New York: Springer.

[3]

《任意间距网格上的有限差分公式生成》，1988 年 Fornberg B. 数学计算期刊 51, no. 184 : 699-706. PDF.

示例

>>> f = np.array([1, 2, 4, 7, 11, 16], dtype=float)
>>> np.gradient(f)
array([1\. , 1.5, 2.5, 3.5, 4.5, 5\. ])
>>> np.gradient(f, 2)
array([0.5 ,  0.75,  1.25,  1.75,  2.25,  2.5 ])

间距也可以用表示数值 F 沿尺度的坐标的数组来指定。例如，均匀间距：

>>> x = np.arange(f.size)
>>> np.gradient(f, x)
array([1\. ,  1.5,  2.5,  3.5,  4.5,  5\. ])

或者是非均匀的：

>>> x = np.array([0., 1., 1.5, 3.5, 4., 6.], dtype=float)
>>> np.gradient(f, x)
array([1\. ,  3\. ,  3.5,  6.7,  6.9,  2.5])

对于二维数组，返回值将是按轴排序的两个数组。在这个例子中，第一个数组表示行方向的梯度，第二个表示列方向的梯度：

>>> np.gradient(np.array([[1, 2, 6], [3, 4, 5]], dtype=float))
[array([[ 2.,  2., -1.],
 [ 2.,  2., -1.]]), array([[1\. , 2.5, 4\. ],
 [1\. , 1\. , 1\. ]])]

在这个例子中，也指定了间距：轴=0 均匀，轴=1 非均匀。

>>> dx = 2.
>>> y = [1., 1.5, 3.5]
>>> np.gradient(np.array([[1, 2, 6], [3, 4, 5]], dtype=float), dx, y)
[array([[ 1\. ,  1\. , -0.5],
 [ 1\. ,  1\. , -0.5]]), array([[2\. , 2\. , 2\. ],
 [2\. , 1.7, 0.5]])]

可以使用edge_order来指定边界的处理方式

>>> x = np.array([0, 1, 2, 3, 4])
>>> f = x**2
>>> np.gradient(f, edge_order=1)
array([1.,  2.,  4.,  6.,  7.])
>>> np.gradient(f, edge_order=2)
array([0., 2., 4., 6., 8.])

axis关键字可以用来指定计算梯度的轴的子集

>>> np.gradient(np.array([[1, 2, 6], [3, 4, 5]], dtype=float), axis=0)
array([[ 2.,  2., -1.],
 [ 2.,  2., -1.]])

`numpy.cross`

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

numpy.cross(a, b, axisa=-1, axisb=-1, axisc=-1, axis=None)

返回两个（向量数组的）叉积。

在 (R³) 中 a 和 b 的叉积是垂直于 a 和 b 的向量。如果 a 和 b 是向量数组，则默认情况下向量由 a 和 b 的最后一个轴定义，这些轴的维度可以为 2 或 3。当 a 或 b 的维度为 2 时，假定输入向量的第三个分量为零，并据此计算叉积。在两个输入向量维度都为 2 的情况下，返回叉积的 z 分量。

参数：

aarray_like

第一个向量的分量。

barray_like

第二个向量的分量。

axisaint，可选

定义向量(s)的 a 轴。默认情况下，为最后一个轴。

axisbint，可选

定义向量(s)的 b 轴。默认情况下，为最后一个轴。

axiscint，可选

包含叉积向量(s)的 c 轴。如果两个输入向量的维度都为 2，则忽略，因为返回值为标量。默认情况下，为最后一个轴。

axisint，可选

如果定义了，a、b 和 c 的轴定义了向量和叉积。覆盖 axisa、axisb 和 axisc。

cndarray

向量叉积。

引发：

ValueError

当 a 和/或 b 中向量的维度不等于 2 或 3 时。

另请参阅

inner

内积

outer

外积。

ix_

构造索引数组。

注意

1.9.0 版新功能。

支持输入的完全广播。

示例

向量叉积。

>>> x = [1, 2, 3]
>>> y = [4, 5, 6]
>>> np.cross(x, y)
array([-3,  6, -3])

一个维度为 2 的向量。

>>> x = [1, 2]
>>> y = [4, 5, 6]
>>> np.cross(x, y)
array([12, -6, -3])

等价地：

>>> x = [1, 2, 0]
>>> y = [4, 5, 6]
>>> np.cross(x, y)
array([12, -6, -3])

两个维度为 2 的向量。

>>> x = [1,2]
>>> y = [4,5]
>>> np.cross(x, y)
array(-3)

多个向量的叉积。请注意，叉积向量的方向由右手法则定义。

>>> x = np.array([[1,2,3], [4,5,6]])
>>> y = np.array([[4,5,6], [1,2,3]])
>>> np.cross(x, y)
array([[-3,  6, -3],
 [ 3, -6,  3]])

可以使用 axisc 关键字更改 c 的方向。

>>> np.cross(x, y, axisc=0)
array([[-3,  3],
 [ 6, -6],
 [-3,  3]])

使用 axisa 和 axisb 更改 x 和 y 的向量定义。

>>> x = np.array([[1,2,3], [4,5,6], [7, 8, 9]])
>>> y = np.array([[7, 8, 9], [4,5,6], [1,2,3]])
>>> np.cross(x, y)
array([[ -6,  12,  -6],
 [  0,   0,   0],
 [  6, -12,   6]])
>>> np.cross(x, y, axisa=0, axisb=0)
array([[-24,  48, -24],
 [-30,  60, -30],
 [-36,  72, -36]])

`numpy.trapz`

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

numpy.trapz(y, x=None, dx=1.0, axis=-1)

使用复合梯形法则沿给定轴积分。

如果提供了 x，则按顺序沿其元素进行积分 - 它们不会被排序。

沿给定轴上的每个 1d 切片积分 y (x)，计算 (\int y(x) dx)。当指定 x 时，这沿参数曲线积分，计算 (\int_t y(t) dt = \int_t y(t) \left.\frac{dx}{dt}\right|_{x=x(t)} dt)。

参数：

y 类数组

要积分的输入数组。

x 类数组，可选

对应于 y 值的采样点。如果 x 为 None，则假定采样点是均匀间隔的 dx。默认值为 None。

dx 标量，可选

当 x 为 None 时，样本点之间的间距。默认值为 1。

axis 整数，可选

要进行积分的轴。

trapz 浮点数或 ndarray

用梯形法则沿着单个轴对 y = n 维数组近似计算的定积分。如果 y 是一个一维数组，则结果是一个浮点数。如果 n 大于 1，则结果是一个 n-1 维数组。

另请参阅

sum, cumsum

注意事项

图片 [2] 说明了梯形法则 - 点的 y 轴位置将从 y 数组中取出，默认情况下点之间的 x 轴距离将为 1.0，或者可以使用 x 数组或 dx 标量提供。返回值将等于红线下的组合区域。

参考文献

[1]

Wikipedia 页面：en.wikipedia.org/wiki/Trapezoidal_rule

[2]

插图：en.wikipedia.org/wiki/File:Composite_trapezoidal_rule_illustration.png

示例

对均匀间隔的点使用梯形法则：

>>> np.trapz([1, 2, 3])
4.0

采样点之间的间距可以通过 x 或 dx 参数选择：

>>> np.trapz([1, 2, 3], x=[4, 6, 8])
8.0
>>> np.trapz([1, 2, 3], dx=2)
8.0

使用递减的 x 对应于反向积分：

>>> np.trapz([1, 2, 3], x=[8, 6, 4])
-8.0

更一般地说，x 用于沿参数曲线积分。我们可以使用以下方法估计积分 (\int_0¹ x² = 1/3)：

>>> x = np.linspace(0, 1, num=50)
>>> y = x**2
>>> np.trapz(y, x)
0.33340274885464394

或者估计圆的面积，注意我们重复了封闭曲线的样本：

>>> theta = np.linspace(0, 2 * np.pi, num=1000, endpoint=True)
>>> np.trapz(np.cos(theta), x=np.sin(theta))
3.141571941375841

可以沿指定轴应用 np.trapz 来进行多次计算：

>>> a = np.arange(6).reshape(2, 3)
>>> a
array([[0, 1, 2],
 [3, 4, 5]])
>>> np.trapz(a, axis=0)
array([1.5, 2.5, 3.5])
>>> np.trapz(a, axis=1)
array([2.,  8.])

`numpy.exp`

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

numpy.exp(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'exp'>

计算输入数组中所有元素的指数函数。

参数：

xarray_like

输入值。

outndarray，None 或 ndarray 和 None 的元组，可选

结果存储的位置。如果提供，则必须具有与输入广播到的形状相同的形状。如果未提供或为 None，则返回一个新分配的数组。元组（仅作为关键字参数）的长度必须等于输出的数量。

wherearray_like，可选

此条件将在输入上进行广播。在条件为真的位置，out数组将设置为 ufunc 的结果。在其他地方，out数组将保持其原始值。注意，如果通过默认值out=None创建了一个未初始化的out数组，则其中条件为假的位置将保持未初始化状态。

**kwargs

对于其他关键字参数，请参阅 ufunc 文档。

返回值：

outndarray 或标量

输出数组，为x的逐元素指数函数。如果x是标量，则输出为标量。

另请参阅

expm1

计算数组中所有元素的exp(x) - 1。

exp2

计算数组中所有元素的2**x。

注意事项

无理数e也被称为欧拉数。它的近似值为 2.718281，并且是自然对数的底数ln（这意味着，如果(x = \ln y = \log_e y)，那么(e^x = y)。对于实数输入，exp(x)始终为正数。

对于复数参数x = a + ib，我们可以写作(e^x = e^a e^{{ib})。第一项(e}a)已知（它是上面描述的实部参数）。第二项(e^{ib})是(\cos b + i \sin b)，是一个幅值为 1 且具有周期相位的函数。

参考文献

[1]

Wikipedia，“Exponential function”，en.wikipedia.org/wiki/Exponential_function

[2]

M. Abramovitz 和 I. A. Stegun，“Handbook of Mathematical Functions with Formulas, Graphs, and Mathematical Tables”，Dover，1964 年，第 69 页，personal.math.ubc.ca/~cbm/aands/page_69.htm

示例

在复平面中绘制exp(x)的幅值和相位：

>>> import matplotlib.pyplot as plt

>>> x = np.linspace(-2*np.pi, 2*np.pi, 100)
>>> xx = x + 1j * x[:, np.newaxis] # a + ib over complex plane
>>> out = np.exp(xx)

>>> plt.subplot(121)
>>> plt.imshow(np.abs(out),
...            extent=[-2*np.pi, 2*np.pi, -2*np.pi, 2*np.pi], cmap='gray')
>>> plt.title('Magnitude of exp(x)')

>>> plt.subplot(122)
>>> plt.imshow(np.angle(out),
...            extent=[-2*np.pi, 2*np.pi, -2*np.pi, 2*np.pi], cmap='hsv')
>>> plt.title('Phase (angle) of exp(x)')
>>> plt.show()

../../_images/numpy-exp-1.png

`numpy.expm1`

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

numpy.expm1(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'expm1'>

计算数组中所有元素的exp(x) - 1。

参数：

xarray_like

输入值。

outndarray，None 或 ndarray 和 None 的元组，可选

存储结果的位置。如果提供，必须具有输入广播到的形状。如果未提供或为 None，则返回一个新分配的数组。元组（仅作为关键字参数）的长度必须等于输出数。

wherearray_like，可选

此条件广播到输入。在条件为 True 的位置，out数组将设置为 ufunc 结果。在其他位置，＊out＊数组将保留其原始值。请注意，如果通过默认的out=None创建了一个未初始化的out数组，那么其中条件为 False 的位置将保持未初始化。

**kwargs

对于其他关键字参数，请参阅 ufunc 文档。

outndarray 或标量

逐元素指数减一：out = exp(x) - 1。如果x是标量，则这是一个标量。

请参阅

log1p

log(1 + x)，expm1 的反函数。

注意

该函数对于小值的x提供比exp(x) - 1更精确的结果。

例子

exp(1e-10) - 1的真实值为1.00000000005e-10，约为 32 个有效数字。此示例显示了在这种情况下 expm1 的优越性。

>>> np.expm1(1e-10)
1.00000000005e-10
>>> np.exp(1e-10) - 1
1.000000082740371e-10

`numpy.exp2`

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

numpy.exp2(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'exp2'>

计算输入数组中所有p的2**p。

参数：

xarray_like

输入值。

outndarray、None 或 ndarray 和 None 的元组，可选

存储结果的位置。如果提供，它必须具有输入广播到的形状。如果未提供或为 None，则返回一个新分配的数组。长度等于输出数量的元组（仅作为关键字参数）必须具有相同长度。

wherearray_like，可选

此条件会广播到输入上。在条件为 True 的位置，out 数组将设置为 ufunc 结果。否则，out 数组将保留其原始值。请注意，如果通过默认的out=None创建了未初始化的out数组，则其中条件为 False 的位置将保持未初始化。

**kwargs

对于其他关键字参数，请参阅 ufunc 文档。

返回值：

outndarray 或标量

按元素计算2的幂x。如果x是标量，则这是一个标量。

另请参见

power

注释

1.3.0 版中的新功能。

示例

>>> np.exp2([2, 3])
array([ 4.,  8.])

`numpy.log`

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

numpy.log(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'log'>

自然对数，逐元素地计算。

自然对数log是指数函数的反函数，因此log(exp(x)) = x。自然对数是以基数e为底的对数。

参数：

x类数组

输入值。

outndarray、None 或 ndarray 和 None 的元组，可选

存储结果的位置。如果提供，它必须具有与输入进行广播的形状。如果未提供或为 None，则返回一个新分配的数组。元组（仅作为关键字参数）的长度必须等于输出的数量。

where类数组，可选

此条件将广播到输入。在条件为 True 的位置，out数组将被设置为 ufunc 结果。在其他位置，out数组将保留其原始值。请注意，如果通过默认值out=None创建了一个未初始化的out数组，那么其中条件为 False 的位置将保持未初始化。

**kwargs

对于其他关键字参数，请参阅 ufunc 文档。

yndarray

逐元素地计算x的自然对数。如果x是标量，则结果是标量。

另请参见

log10, log2, log1p, emath.log

注释

对数是一个多值函数：对于每个x，都存在无数个z，使得exp(z) = x。约定是返回其虚部在(-pi, pi]之间的z。

对于实值输入数据类型，log总是返回实数输出。对于每个不能表示为实数或无限大的值，它将产生nan并设置无效的浮点错误标志。

对于复数输入，log是一个复解析函数，它具有一个分支切割线[-inf, 0]，并且在该线上方连续。log将浮点负零处理为无穷小的负数，符合 C99 标准。

在输入具有负实部和一个非常接近 0 的负复部分（趋近于 0）的情况下，结果非常接近-pi，以至于计算结果完全等于-pi。

参考资料

[1]

M. Abramowitz 和 I.A. Stegun，“数学函数手册”，第 10 次印刷，1964 年，第 67 页。personal.math.ubc.ca/~cbm/aands/page_67.htm

[2]

维基百科，“对数”zh.wikipedia.org/wiki/对数

示例

>>> np.log([1, np.e, np.e**2, 0])
array([  0.,   1.,   2., -Inf])

`numpy.log10`

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

numpy.log10(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'log10'>

返回输入数组的以 10 为底的对数，逐个元素计算。

参数：

xarray_like

输入值。

outndarray、None 或 ndarray 和 None 的元组，可选

存储结果的位置。如果提供，它必须具有输入广播到的形状。如果未提供或为 None，则返回一个新分配的数组。元组（仅作为关键字参数）的长度必须等于输出数量。

wherearray_like，可选

此条件在输入上进行广播。在条件为 True 的位置，out数组将设置为 ufunc 结果。在其他地方，out数组将保留其原始值。请注意，如果通过默认的out=None创建了一个未初始化的out数组，则其中条件为 False 的位置将保持未初始化状态。

**kwargs

对于其他仅关键字参数，请参阅 ufunc 文档。

yndarray

x的以 10 为底的对数，逐个元素计算。如果x是负数，则返回 NaN。如果x是标量，则返回标量。

另请参阅

emath.log10

注意事项

对数是一个多值函数：对于每个x，都有无限多个z使得10**z = x。约定返回其虚部位于(-pi, pi]的z。

对于实值输入数据类型，log10 总是返回实数输出。对于每个不能表示为实数或无穷大的值，它产生nan并设置无效浮点错误标志。

对于复值输入，log10 是一个具有分支切断[-inf, 0]的复解析函数，并且在其上方连续。 log10 将浮点负零视为无穷小的负数，符合 C99 标准。

在输入具有负实部和非常小的负复部分（接近 0）的情况下，结果非常接近-pi，以至于计算结果恰好为-pi。

参考

[1]

M. Abramowitz 和 I.A. Stegun，“数学函数手册”，第 10 次印刷，1964 年，第 67 页。 personal.math.ubc.ca/~cbm/aands/page_67.htm

[2]

维基百科，“对数”。 en.wikipedia.org/wiki/Logarithm

示例

>>> np.log10([1e-15, -3.])
array([-15.,  nan])

`numpy.log2`

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

numpy.log2(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'log2'>

基于 2 的对数* x *。

参数：

xarray_like

输入值。

outndarray、None 或 ndarray 和 None 的元组，可选

存储结果的位置。如果提供，则必须具有广播到输入的形状。如果未提供或为 None，则返回一个新分配的数组。一个元组（仅作为关键字参数）的长度必须等于输出的数量。

wherearray_like，可选

此条件在输入上进行广播。在条件为 True 的位置上，out数组将被设置为 ufunc 结果。在其他地方，out数组将保留其原始值。请注意，如果通过默认的out=None创建了一个未初始化的out数组，则其中条件为 False 的位置将保持未初始化。

**kwargs

对于其他仅限关键字的参数，请参见 ufunc 文档。

yndarray

基于 2 的对数* x 。如果x*是标量，则为标量。

另请参见

log，log10，log1p，emath.log2

注意

新版本 1.3.0 中添加。

对数是一个多值函数：对于每个* x ，存在无限多个 z ，使得 2 ** z = x 。约定返回其虚部在（-pi，pi] 范围内的 z *。

对于实值输入数据类型，log2始终返回实数输出。对于每个不能表示为实数字或无穷大的值，它产生nan并设置invalid浮点错误标志。

对于复值输入，log2是一个具有分支切割[-inf，0]并在其上方连续的复解析函数。log2将浮点负零视为无穷小的负数，符合 C99 标准。

在输入具有负实部和一个非常小的负复部（接近 0）的情况下，结果与-pi非常接近，以至于计算结果恰好是-pi。

示例

>>> x = np.array([0, 1, 2, 2**4])
>>> np.log2(x)
array([-Inf,   0.,   1.,   4.])

>>> xi = np.array([0+1.j, 1, 2+0.j, 4.j])
>>> np.log2(xi)
array([ 0.+2.26618007j,  0.+0.j        ,  1.+0.j        ,  2.+2.26618007j])

`numpy.log1p`

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

numpy.log1p(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'log1p'>

返回输入数组逐元素的自然对数。

计算 log(1 + x)。

参数：

x类似数组

输入值。

out ndarray、None 或包含 ndarray 和 None 的元组，可选

存储结果的位置。如果提供，则它必须具有输入广播到的形状。如果未提供或为 None，则返回一个新分配的数组。元组（仅作为关键字参数）的长度必须等于输出数量。

where 类似数组，可选

此条件广播至输入。在条件为 True 的位置，out 数组将设置为 ufunc 结果。在其他位置，out 数组将保持其原始值。请注意，如果通过默认值 out=None 创建一个未初始化的 out 数组，则其中条件为 False 的位置将保持未初始化状态。

**kwargs

其他关键字参数，请参阅 ufunc 文档。

返回值：

y 数组

1 + x 的自然对数，逐元素操作。如果 x 是标量，则结果也是标量。

另请参见

expm1

exp(x) - 1，log1p的逆操作。

注意事项

对于实数输入，log1p 在 1 + x == 1 的浮点精度下也很准确。

对数是一个多值函数：对于每个 x，存在无穷多个 z 使得 exp(z) = 1 + x。约定是返回其虚部位于 [-pi, pi] 范围内的 z。

对于实数输入数据类型，log1p 总是返回实数输出。对于每个不能表示为实数或无穷大的值，它产生 nan 并设置 invalid 浮点错误标志。

对于复数输入，log1p 是一个具有分支切割 [-inf, -1]，并且以其上的连续性的复解析函数。log1p 将浮点数负零视为一个无穷小的负数，符合 C99 标准。

参考资料

[1]

M. Abramowitz 和 I.A. Stegun，“数学函数手册”，第 10 版，1964 年，第 67 页。personal.math.ubc.ca/~cbm/aands/page_67.htm

[2]

维基百科，“对数”。en.wikipedia.org/wiki/Logarithm

示例

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

`numpy.logaddexp`

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

numpy.logaddexp(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'logaddexp'>

输入的指数求和的对数。

计算log(exp(x1) + exp(x2))。这个函数在统计学中很有用，因为计算的事件概率可能太小，以至于超出正常浮点数的范围。在这种情况下，存储计算的概率的对数。这个函数允许以这种方式存储的概率相加。

参数：

x1, x2array_like

输入值。如果x1.shape != x2.shape，它们必须可广播到一个公共形状（这成为输出的形状）。

outndarray、None 或者 ndarray 和 None 的元组，可选

存储结果的位置。如果提供，必须具有与输入广播到的形状相同的形状。如果未提供或为 None，则返回一个新分配的数组。作为关键字参数的元组（仅可能）必须具有与输出数量相等的长度。

wherearray_like，可选

此条件广播至输入。在条件为 True 的位置，out数组将被设置为 ufunc 的结果。在其他位置，out数组将保留其原始值。请注意，如果通过默认的out=None创建未初始化的out数组，则其中条件为 False 的位置将保持未初始化状态。

**kwargs

对于其他仅限关键字的参数，请参见 ufunc 文档。

resultndarray

对exp(x1) + exp(x2)的对数。如果x1和x2都是标量，则得到标量。

另请参见

logaddexp2

以 2 为底的输入指数求和的对数。

注意事项

新功能，在版本 1.3.0 中。

实例

>>> prob1 = np.log(1e-50)
>>> prob2 = np.log(2.5e-50)
>>> prob12 = np.logaddexp(prob1, prob2)
>>> prob12
-113.87649168120691
>>> np.exp(prob12)
3.5000000000000057e-50

`numpy.logaddexp2`

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

numpy.logaddexp2(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'logaddexp2'>

输入的指数幂的和的对数，以 2 为底。

计算log2(2**x1 + 2**x2)。在机器学习中，当计算的事件概率很小以至于超出正常浮点数的范围时，这个函数很有用。在这种情况下，可以使用计算概率的底 2 对数。该函数允许添加以这种方式存储的概率。

参数：

x1, x2 array_like

输入值。如果x1.shape != x2.shape，它们必须可以广播到一个共同的形状（这将成为输出的形状）。

out ndarray、None 或者 ndarray 和 None 的元组，可选

结果存储的位置。如果提供了，则必须具有广播到输入的形状。如果未提供或为 None，则会返回一个新分配的数组。作为关键字参数的元组必须具有与输出数量相等的长度。

where array_like，可选

这个条件在输入上广播。在条件为 True 的位置，out数组将设置为 ufunc 结果。在其他地方，out数组将保留其原始值。请注意，如果通过默认的out=None创建了一个未初始化的out数组，则其中条件为 False 的位置将保持未初始化状态。

**kwargs

对于其他关键字参数，请参见 ufunc 文档。

result ndarray

2**x1 + 2**x2的基 2 对数。如果x1和x2都是标量，则这是一个标量。

另请参见

logaddexp

输入的指数幂的和的对数。

注意

新版本 1.3.0 中的新内容。

示例

>>> prob1 = np.log2(1e-50)
>>> prob2 = np.log2(2.5e-50)
>>> prob12 = np.logaddexp2(prob1, prob2)
>>> prob1, prob2, prob12
(-166.09640474436813, -164.77447664948076, -164.28904982231052)
>>> 2**prob12
3.4999999999999914e-50

`numpy.i0`

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

numpy.i0(x)

第一类修改贝塞尔函数，阶数为 0。

通常表示为 (I_0)。

参数:

x 浮点数的 array_like

贝塞尔函数的参数。

输出 ndarray，形状 = x.shape，类型 = 浮点数

在 x 中的每个元素处评估的修改贝塞尔函数。

另请参见

scipy.special.i0, scipy.special.iv, scipy.special.ive

注意

推荐使用 scipy 的实现而不是这个函数：它是用 C 写成的正确的 ufunc，速度比这个快一个数量级以上。

我们使用了 Clenshaw 发表的算法 [1]，并且被 Abramowitz 和 Stegun [2] 引用，其中函数域被分成两个区间 [0,8] 和 (8,inf)，并且在每个区间中使用了切比雪夫多项式展开。使用 IEEE 算术在域 [0,30] 上的相对误差被记录为峰值为 5.8e-16，均方根为 1.4e-16 (n = 30000) [3]。

参考文献

[1]

C. W. Clenshaw，“数学函数的切比雪夫级数”，收录于 国家物理实验室数学表，第 5 卷，伦敦：女王陛下印刷局，1962 年。

[2]

M. Abramowitz 和 I. A. Stegun，数学函数手册，第 10 次印刷，纽约：多佛出版社，1964 年，第 379 页。 personal.math.ubc.ca/~cbm/aands/page_379.htm

[3]

metacpan.org/pod/distribution/Math-Cephes/lib/Math/Cephes.pod#i0:-Modified-Bessel-function-of-order-zero

示例

>>> np.i0(0.)
array(1.0)
>>> np.i0([0, 1, 2, 3])
array([1\.        , 1.26606588, 2.2795853 , 4.88079259])

`numpy.sinc`

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

numpy.sinc(x)

返回归一化的 sinc 函数。

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

注意

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

参数：

x数组

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

out数组

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

注意

sinc 的名称缩写为“sine cardinal”或“sinus cardinalis”。

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

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

参考

[1]

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

[2]

维基百科，“Sinc function”，en.wikipedia.org/wiki/Sinc_function

示例

>>> 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()

../../_images/numpy-sinc-1.png

`numpy.signbit`

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

numpy.signbit(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'signbit'>

返回元素级别的 True，其中设置了 signbit（小于零）。

参数：

x类似数组

输入值。

outndarray、None 或 ndarray 和 None 的元组，可选

存储结果的位置。如果提供了，它必须具有输入广播到的形状。如果未提供或为 None，则返回一个新分配的数组。一个元组（仅作为关键字参数）必须具有与输出数量相等的长度。

where类似数组，可选

此条件在输入上进行广播。在条件为 True 的位置，out数组将设置为 ufunc 结果。在其他位置，out数组将保留其原始值。请注意，如果通过默认的out=None创建了一个未初始化的out数组，则其中条件为 False 的位置将保持未初始化状态。

**kwargs

对于其他仅限关键字参数，请参阅 ufunc 文档。

result布尔值的 ndarray

输出数组，或者如果提供了则是对out的引用。如果x是标量，则这是一个标量。

示例

>>> np.signbit(-1.2)
True
>>> np.signbit(np.array([1, -2.3, 2.1]))
array([False,  True, False])

`numpy.copysign`

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

numpy.copysign(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'copysign'>

将 x1 的符号逐元素更改为 x2 的符号。

如果x2是标量，则其符号将被复制到x1的所有元素。

参数：

x1：array_like

要更改符号的值。

x2：array_like

将x2的符号复制到x1。如果x1.shape != x2.shape，它们必须能够广播到一个公共形状（该形状成为输出的形状）。

out：ndarray、None 或 ndarray 和 None 的元组，可选

where：array_like，可选

此条件在输入上进行广播。在条件为 True 的位置，out数组将设置为 ufunc 结果。在其他地方，out数组将保留其原始值。请注意，如果通过默认值out=None创建了未初始化的out数组，则其中条件为 False 的位置将保持未初始化状态。

**kwargs

对于其他仅限关键字参数，请参阅 ufunc 文档。

out：ndarray 或标量

具有x2符号的x1的值。如果x1和x2都是标量，则这是一个标量。

示例

>>> np.copysign(1.3, -1)
-1.3
>>> 1/np.copysign(0, 1)
inf
>>> 1/np.copysign(0, -1)
-inf

>>> np.copysign([-1, 0, 1], -1.1)
array([-1., -0., -1.])
>>> np.copysign([-1, 0, 1], np.arange(3)-1)
array([-1.,  0.,  1.])

`numpy.frexp`

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

numpy.frexp(x, [out1, out2, ]/, [out=(None, None), ]*, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'frexp'>

将 x 的元素分解为尾数和二次指数。

返回（尾数，指数），其中x = 尾数 * 2**指数。尾数位于开区间(-1, 1)内，而二次指数是带符号整数。

参数：

xarray_like

要分解的数字数组。

out1ndarray，可选

尾数的输出数组。必须与x具有相同的形状。

out2ndarray，可选

指数的输出数组。必须与x具有相同的形状。

outndarray，None 或 ndarray 和 None 的元组，可选

结果存储的位置。如果提供，必须具有输入广播到的形状。如果未提供或为 None，则返回一个新分配的数组。一个元组（仅作为关键字参数）必须具有与输出数量相等的长度。

wherearray_like，可选

此条件广播到输入。在条件为 True 的位置，out数组将设置为 ufunc 结果。在其他地方，out数组将保留其原始值。请注意，如果通过默认的out=None创建了一个未初始化的out数组，则其中条件为 False 的位置将保持未初始化。

**kwargs

对于其他仅限关键字参数，请参阅 ufunc 文档。

尾数ndarray

在-1 和 1 之间的浮点值。如果x是标量，则这是一个标量。

exponentndarray

2 的整数指数。如果x是标量，则这是一个标量。

另请参见

ldexp

计算y = x1 * 2**x2，即frexp的逆运算。

注意

不支持复杂的数据类型，它们会引发 TypeError。

示例

>>> x = np.arange(9)
>>> y1, y2 = np.frexp(x)
>>> y1
array([ 0\.   ,  0.5  ,  0.5  ,  0.75 ,  0.5  ,  0.625,  0.75 ,  0.875,
 0.5  ])
>>> y2
array([0, 1, 2, 2, 3, 3, 3, 3, 4])
>>> y1 * 2**y2
array([ 0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.])

`numpy.ldexp`

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

numpy.ldexp(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'ldexp'>

逐元素返回 x1 * 2**x2。

小数部分x1和二次幂指数x2用于构建浮点数x1 * 2**x2。

参数：

x1array_like

乘数数组。

x2array_like，int

二次幂指数数组。如果x1.shape != x2.shape，它们必须能够广播到一个公共形状（该形状成为输出的形状）。

outndarray、None 或 ndarray 和 None 的元组，可选

存储结果的位置。如果提供，必须具有输入广播到的形状。如果未提供或为 None，则返回一个新分配的数组。元组（仅作为关键字参数）的长度必须等于输出的数量。

wherearray_like，可选

此条件广播到输入。在条件为 True 的位置，out数组将设置为 ufunc 结果。在其他位置，out数组将保留其原始值。请注意，如果通过默认的out=None创建了未初始化的out数组，则其中条件为 False 的位置将保持未初始化状态。

**kwargs

对于其他仅限关键字参数，请参阅 ufunc 文档。

yndarray 或标量

x1 * 2**x2的结果。如果x1和x2都是标量，则结果是标量。

另请参见

frexp

从x = y1 * 2**y2返回(y1, y2)，是ldexp的逆操作。

注意

不支持复杂的数据类型，它们将引发 TypeError。

ldexp作为frexp的逆操作很有用，如果单独使用，更清晰的表达方式是x1 * 2**x2。

示例

>>> np.ldexp(5, np.arange(4))
array([ 5., 10., 20., 40.], dtype=float16)

>>> x = np.arange(6)
>>> np.ldexp(*np.frexp(x))
array([ 0.,  1.,  2.,  3.,  4.,  5.])

`numpy.nextafter`

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

numpy.nextafter(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'nextafter'>

返回向x2方向的x1之后的下一个浮点值，逐元素计算。

参数：

x1：类似数组

寻找下一个可表示值的数值。

x2：类似数组

寻找下一个可表示值x1的方向。如果x1.shape != x2.shape，它们必须能够广播到一个共同的形状（这将成为输出的形状）。

out：ndarray、None 或 ndarray 和 None 的元组，可选

where：类似数组，可选

此条件在输入上进行广播。在条件为 True 的位置，out数组将设置为 ufunc 结果。在其他地方，out数组将保留其原始值。请注意，如果通过默认值out=None创建了一个未初始化的out数组，则其中条件为 False 的位置将保持未初始化状态。

**kwargs

对于其他关键字参数，请参阅 ufunc 文档。

out：ndarray 或标量

x1在x2方向上的下一个可表示值。如果x1和x2都是标量，则这是一个标量。

示例

>>> eps = np.finfo(np.float64).eps
>>> np.nextafter(1, 2) == eps + 1
True
>>> np.nextafter([1, 2], [2, 1]) == [eps + 1, 2 - eps]
array([ True,  True])

`numpy.spacing`

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

numpy.spacing(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'spacing'>

返回x和最近的相邻数字之间的距离。

参数：

x：array_like

要查找间距的值。

out：ndarray、None 或 ndarray 和 None 的元组，可选

where：array_like，可选

**kwargs

对于其他仅限关键字参数，请参阅 ufunc 文档。

out：ndarray 或标量

x的值的间距。如果x是标量，则这是一个标量。

注意事项

它可以被视为 EPS 的一般化：spacing(np.float64(1)) == np.finfo(np.float64).eps，对于任何有限的x，在x + spacing(x)和x之间不应该有任何可表示的数字。

+- inf 和 NaN 的间距是 NaN。

示例

>>> np.spacing(1) == np.finfo(np.float64).eps
True

`numpy.lcm`

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

numpy.lcm(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'lcm'>

返回|x1|和|x2|的最小公倍数

参数：

x1, x2类似数组，整数

数组的值。如果x1.shape != x2.shape，它们必须能够广播到一个共同的形状（这将成为输出的形状）。

y数组或标量

输入的绝对值的最小公倍数如果x1和x2都是标量，则这是一个标量。

另请参阅

gcd

最大公约数

示例

>>> np.lcm(12, 20)
60
>>> np.lcm.reduce([3, 12, 20])
60
>>> np.lcm.reduce([40, 12, 20])
120
>>> np.lcm(np.arange(6), 20)
array([ 0, 20, 20, 60, 20, 20])

`numpy.gcd`

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

numpy.gcd(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'gcd'>

返回|x1|和|x2|的最大公约数

参数：

x1, x2数组样式，整数

值的数组。如果x1.shape != x2.shape，它们必须能够广播到一个公共形状（这将成为输出的形状）。

y数组或标量

输入绝对值的最大公约数，如果x1和x2都是标量，则为标量。

另请参阅

lcm

最小公倍数

示例

>>> np.gcd(12, 20)
4
>>> np.gcd.reduce([15, 25, 35])
5
>>> np.gcd(np.arange(6), 20)
array([20,  1,  2,  1,  4,  5])

`numpy.add`

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

numpy.add(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'add'>

逐元素添加参数。

参数：

x1，x2array_like

要相加的数组。如果x1.shape != x2.shape，它们必须能够广播到一个公共形状（这将成为输出的形状）。

outndarray、None 或 ndarray 和 None 的元组，可选

wherearray_like，可选

此条件在输入上进行广播。在条件为 True 的位置，out数组将设置为 ufunc 结果。在其他地方，out数组将保留其原始值。请注意，如果通过默认的out=None创建了未初始化的out数组，则其中条件为 False 的位置将保持未初始化状态。

**kwargs

对于其他仅限关键字参数，请参阅 ufunc 文档。

addndarray 或标量

x1和x2的逐元素和。如果x1和x2都是标量，则这是一个标量。

笔记

相当于数组广播中的x1 + x2。

示例

>>> np.add(1.0, 4.0)
5.0
>>> x1 = np.arange(9.0).reshape((3, 3))
>>> x2 = np.arange(3.0)
>>> np.add(x1, x2)
array([[  0.,   2.,   4.],
 [  3.,   5.,   7.],
 [  6.,   8.,  10.]])

+运算符可用作 ndarrays 上np.add的简写。

>>> x1 = np.arange(9.0).reshape((3, 3))
>>> x2 = np.arange(3.0)
>>> x1 + x2
array([[ 0.,  2.,  4.],
 [ 3.,  5.,  7.],
 [ 6.,  8., 10.]])

`numpy.reciprocal`

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

numpy.reciprocal(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'reciprocal'>

返回参数的倒数，逐个元素。

计算1/x。

参数：

x数组样式

输入数组。

out数组样式，无或数组和无的元组，可选

存储结果的位置。如果提供，它必须具有输入广播到的形状。如果未提供或为 None，则返回一个新分配的数组。一个元组（仅作为关键字参数）的长度必须等于输出数量。

where数组样式，可选

此条件广播到输入。在条件为 True 的位置，out数组将设置为 ufunc 结果。在其他地方，out数组将保留其原始值。请注意，如果通过默认out=None创建了未初始化的out数组，则其中条件为 False 的位置将保持未初始化。

**kwargs

对于其他仅限关键字参数，请参阅 ufunc 文档。

y数组

返回数组。如果x是标量，则这是一个标量。

注意事项

注意

此函数不适用于整数。

对于绝对值大于 1 的整数参数，由于 Python 处理整数除法的方式，结果始终为零。对于整数零，结果是溢出。

示例

>>> np.reciprocal(2.)
0.5
>>> np.reciprocal([1, 2., 3.33])
array([ 1\.       ,  0.5      ,  0.3003003])

`numpy.positive`

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

numpy.positive(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'positive'>

数值上的正值，逐元素。

版本 1.13.0 中新增。

参数：

x类似数组或标量

输入数组。

返回值：

y数组或标量

返回的数组或标量：y = +x。如果x是标量，则为标量。

注意事项

等同于x.copy()，但仅对支持算术运算的类型定义。

示例

>>> x1 = np.array(([1., -1.]))
>>> np.positive(x1)
array([ 1., -1.])

一元运算符+可用作 ndarrays 上np.positive的简写。

>>> x1 = np.array(([1., -1.]))
>>> +x1
array([ 1., -1.])

`numpy.negative`

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

numpy.negative(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'negative'>

数值负数，逐元素。

参数：

xarray_like 或标量

输入数组。

outndarray、None 或 ndarray 和 None 的元组，可选

存储结果的位置。如果提供，它必须具有输入广播到的形状。如果未提供或为 None，则返回一个新分配的数组。元组（仅作为关键字参数）的长度必须等于输出的数量。

wherearray_like，可选

**kwargs

对于其他仅限关键字参数，请参阅 ufunc 文档。

yndarray 或标量

返回的数组或标量：y = -x。如果x是标量，则这是一个标量。

示例

>>> np.negative([1.,-1.])
array([-1.,  1.])

一元-运算符可用作 ndarrays 上np.negative的简写。

>>> x1 = np.array(([1., -1.]))
>>> -x1
array([-1.,  1.])

`numpy.multiply`

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

numpy.multiply(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'multiply'>

逐元素相乘参数。

参数：

x1, x2array_like

要相乘的输入数组。如果 x1.shape != x2.shape，它们必须能够广播到一个共同的形状（这将成为输出的形状）。

outndarray，None，或元组的 ndarray 和 None，可选

wherearray_like，可选

此条件在输入上进行广播。在条件为 True 的位置，out 数组将设置为 ufunc 结果。在其他位置，out 数组将保留其原始值。请注意，如果通过默认的 out=None 创建了一个未初始化的 out 数组，则其中条件为 False 的位置将保持未初始化。

**kwargs

对于其他仅限关键字的参数，请参阅 ufunc 文档。

yndarray

x1 和 x2 的逐元素乘积。如果 x1 和 x2 都是标量，则这是一个标量。

注意

在数组广播方面等同于 x1 * x2。

示例

>>> np.multiply(2.0, 4.0)
8.0

>>> x1 = np.arange(9.0).reshape((3, 3))
>>> x2 = np.arange(3.0)
>>> np.multiply(x1, x2)
array([[  0.,   1.,   4.],
 [  0.,   4.,  10.],
 [  0.,   7.,  16.]])

* 运算符可用作对 ndarrays 上的 np.multiply 的简写。

>>> x1 = np.arange(9.0).reshape((3, 3))
>>> x2 = np.arange(3.0)
>>> x1 * x2
array([[  0.,   1.,   4.],
 [  0.,   4.,  10.],
 [  0.,   7.,  16.]])

`numpy.divide`

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

numpy.divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'divide'>

对参数进行逐元素划分。

参数：

x1类似数组

被除数数组。

x2类似数组

除数数组。如果x1.shape != x2.shape，它们必须能够广播到一个公共形状（这将成为输出的形状）。

out数组、None 或数组和 None 的元组，可选

where类似数组，可选

**kwargs

对于其他仅关键字参数，请参阅 ufunc 文档。

y数组或标量

商x1/x2，逐元素。如果x1和x2都是标量，则这是一个标量。

另请参见

seterr

设置是否在溢出、下溢和除零时引发警告或警告。

注意

在数组广播方面等效于x1 / x2。

true_divide(x1, x2)函数是divide(x1, x2)的别名。

示例

>>> np.divide(2.0, 4.0)
0.5
>>> x1 = np.arange(9.0).reshape((3, 3))
>>> x2 = np.arange(3.0)
>>> np.divide(x1, x2)
array([[nan, 1\. , 1\. ],
 [inf, 4\. , 2.5],
 [inf, 7\. , 4\. ]])

/运算符可用作 ndarrays 上np.divide的简写。

>>> x1 = np.arange(9.0).reshape((3, 3))
>>> x2 = 2 * np.ones(3)
>>> x1 / x2
array([[0\. , 0.5, 1\. ],
 [1.5, 2\. , 2.5],
 [3\. , 3.5, 4\. ]])

`numpy.power`

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

numpy.power(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'power'>

第一个数组元素按照第二个数组的幂逐元素提升。

将x1中的每个基数提升到x2中对应位置的幂。x1和x2必须能够广播到相同的形状。

将整数类型提升到负整数幂将引发ValueError。

将负值提升到非整数值将返回nan。要获得复杂的结果，将输入转换为复数，或指定dtype为complex（请参见下面的示例）。

参数：

x1数组样式

基数。

x2数组样式

指数。如果x1.shape != x2.shape，它们必须能够广播到一个公共形状（这将成为输出的形状）。

out ndarray、None 或 ndarray 和 None 的元组，可选

where数组样式，可选

此条件在输入上进行广播。在条件为 True 的位置，out数组将设置为 ufunc 结果。否则，out数组将保留其原始值。请注意，如果通过默认的out=None创建了一个未初始化的out数组，则其中条件为 False 的位置将保持未初始化。

**kwargs

对于其他仅限关键字参数，请参阅 ufunc 文档。

y ndarray

x1中的基数提升到x2中的指数。如果x1和x2都是标量，则这是一个标量。

另请参见

float_power

将整数提升为浮点数的幂函数

示例

将数组中的每个元素立方。

>>> x1 = np.arange(6)
>>> x1
[0, 1, 2, 3, 4, 5]
>>> np.power(x1, 3)
array([  0,   1,   8,  27,  64, 125])

将基数提升到不同的指数。

>>> x2 = [1.0, 2.0, 3.0, 3.0, 2.0, 1.0]
>>> np.power(x1, x2)
array([  0.,   1.,   8.,  27.,  16.,   5.])

广播的效果。

>>> x2 = np.array([[1, 2, 3, 3, 2, 1], [1, 2, 3, 3, 2, 1]])
>>> x2
array([[1, 2, 3, 3, 2, 1],
 [1, 2, 3, 3, 2, 1]])
>>> np.power(x1, x2)
array([[ 0,  1,  8, 27, 16,  5],
 [ 0,  1,  8, 27, 16,  5]])

**运算符可用作 ndarrays 上np.power的简写。

>>> x2 = np.array([1, 2, 3, 3, 2, 1])
>>> x1 = np.arange(6)
>>> x1 ** x2
array([ 0,  1,  8, 27, 16,  5])

将负值提升到非整数值将导致nan（并生成警告）。

>>> x3 = np.array([-1.0, -4.0])
>>> with np.errstate(invalid='ignore'):
...     p = np.power(x3, 1.5)
...
>>> p
array([nan, nan])

要获得复杂的结果，请给出参数dtype=complex。

>>> np.power(x3, 1.5, dtype=complex)
array([-1.83697020e-16-1.j, -1.46957616e-15-8.j])

`numpy.subtract`

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

numpy.subtract(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'subtract'>

逐元素相减参数。

参数：

x1, x2array_like

要相互减去的数组。如果x1.shape != x2.shape，它们必须可广播到一个公共形状（这将成为输出的形状）。

outndarray，None 或 ndarray 和 None 的元组，可选

wherearray_like，可选

这个条件在输入上进行广播。在条件为 True 的位置，out数组将被设置为 ufunc 的结果。在其他地方，out数组将保留其原始值。请注意，如果通过默认的out=None创建了一个未初始化的out数组，则其中条件为 False 的位置将保持未初始化状态。

**kwargs

对于其他仅限关键字参数，请参阅 ufunc 文档。

yndarray

x1和x2的逐元素差异。如果x1和x2都是标量，则这是一个标量。

注意

与数组广播方面的x1 - x2等效。

示例

>>> np.subtract(1.0, 4.0)
-3.0

>>> x1 = np.arange(9.0).reshape((3, 3))
>>> x2 = np.arange(3.0)
>>> np.subtract(x1, x2)
array([[ 0.,  0.,  0.],
 [ 3.,  3.,  3.],
 [ 6.,  6.,  6.]])

-运算符可用作 ndarrays 上np.subtract的简写。

>>> x1 = np.arange(9.0).reshape((3, 3))
>>> x2 = np.arange(3.0)
>>> x1 - x2
array([[0., 0., 0.],
 [3., 3., 3.],
 [6., 6., 6.]])

`numpy.true_divide`

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

numpy.true_divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'divide'>

按元素划分参数。

参数：

x1array_like

被除数数组。

x2array_like

除数数组。如果x1.shape != x2.shape，它们必须能够广播到一个公共形状（这将成为输出的形状）。

outndarray、None 或 ndarray 和 None 的元组，可选

wherearray_like，可选

此条件在输入上进行广播。在条件为 True 的位置，out数组将设置为 ufunc 结果。在其他地方，out数组将保留其原始值。请注意，如果通过默认out=None创建了未初始化的out数组，则其中条件为 False 的位置将保持未初始化状态。

**kwargs

对于其他仅限关键字的参数，请参阅 ufunc 文档。

yndarray 或标量

商x1/x2，按元素。如果x1和x2都是标量，则这是一个标量。

另请参阅

seterr

设置是否在溢出、下溢和除以零时引发警告或警告。

注意

等同于按元素进行广播的x1 / x2。

true_divide(x1, x2)函数是divide(x1, x2)的别名。

示例

>>> np.divide(2.0, 4.0)
0.5
>>> x1 = np.arange(9.0).reshape((3, 3))
>>> x2 = np.arange(3.0)
>>> np.divide(x1, x2)
array([[nan, 1\. , 1\. ],
 [inf, 4\. , 2.5],
 [inf, 7\. , 4\. ]])

/运算符可用作 ndarrays 上np.divide的简写。

>>> x1 = np.arange(9.0).reshape((3, 3))
>>> x2 = 2 * np.ones(3)
>>> x1 / x2
array([[0\. , 0.5, 1\. ],
 [1.5, 2\. , 2.5],
 [3\. , 3.5, 4\. ]])

`numpy.floor_divide`

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

numpy.floor_divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'floor_divide'>

返回小于或等于输入除法的最大整数。它等同于 Python 的//运算符，并与 Python 的%（remainder）函数配对，因此a = a % b + b * (a // b)直到舍入误差。

参数：

x1array_like

分子。

x2array_like

分母。如果x1.shape != x2.shape，它们必须能够广播到一个公共形状（这将成为输出的形状）。

outndarray、None 或 ndarray 和 None 的元组，可选

wherearray_like，可选

此条件广播到输入。在条件为 True 的位置，out数组将设置为 ufunc 结果。在其他地方，out数组将保留其原始值。请注意，如果通过默认的out=None创建了一个未初始化的out数组，则其中条件为 False 的位置将保持未初始化状态。

**kwargs

对于其他仅限关键字参数，请参阅 ufunc 文档。

yndarray

y = floor(x1/x2) 如果x1和x2都是标量，则为标量。

另请参阅

remainder

余数，与 floor_divide 互补。

divmod

同时执行地板除法和余数计算。

divide

标准除法。

floor

将数字四舍五入到最接近的整数向下取整。

ceil

将数字四舍五入到最接近的整数向上取整。

示例

>>> np.floor_divide(7,3)
2
>>> np.floor_divide([1., 2., 3., 4.], 2.5)
array([ 0.,  0.,  1.,  1.])

//运算符可用作 ndarrays 上np.floor_divide的简写。

>>> x1 = np.array([1., 2., 3., 4.])
>>> x1 // 2.5
array([0., 0., 1., 1.])

`numpy.float_power`

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

numpy.float_power(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'float_power'>

从第二个数组中提升的第一个数组元素，逐个元素。

将x1中的每个基数提升到x2中对应位置的幂。x1和x2必须能够广播到相同的形状。这与幂函数不同，因为整数、float16 和 float32 会提升为具有至少 float64 最小精度的浮点数，以便结果始终是不精确的。函数的意图是，对于负幂，该函数将返回可用的结果，并且对于正幂很少会溢出。

将负值提升到非整数值将返回nan。要获得复杂的结果，请将输入转换为复数，或指定dtype为complex（请参见下面的示例）。

1.12.0 版本中的新功能。

参数：

x1类数组

基数。

x2类数组

指数。如果x1.shape != x2.shape，它们必须能够广播到一个公共形状（这将成为输出的形状）。

out数组，None 或数组和 None 的元组，可选

where类数组，可选

此条件会广播到输入。在条件为 True 的位置，out数组将设置为 ufunc 结果。在其他地方，out数组将保留其原始值。请注意，如果通过默认的out=None创建了一个未初始化的out数组，则其中条件为 False 的位置将保持未初始化状态。

**kwargs

对于其他仅限关键字的参数，请参阅 ufunc 文档。

y数组

x1中的基数提升到x2中的指数。如果x1和x2都是标量，则这是一个标量。

另请参阅

power

保留类型的幂函数

示例

对列表中的每个元素进行立方运算。

>>> x1 = range(6)
>>> x1
[0, 1, 2, 3, 4, 5]
>>> np.float_power(x1, 3)
array([   0.,    1.,    8.,   27.,   64.,  125.])

将基数提升到不同的指数。

>>> x2 = [1.0, 2.0, 3.0, 3.0, 2.0, 1.0]
>>> np.float_power(x1, x2)
array([  0.,   1.,   8.,  27.,  16.,   5.])

广播的效果。

>>> x2 = np.array([[1, 2, 3, 3, 2, 1], [1, 2, 3, 3, 2, 1]])
>>> x2
array([[1, 2, 3, 3, 2, 1],
 [1, 2, 3, 3, 2, 1]])
>>> np.float_power(x1, x2)
array([[  0.,   1.,   8.,  27.,  16.,   5.],
 [  0.,   1.,   8.,  27.,  16.,   5.]])

将负值提升到非整数值将导致nan（并生成警告）。

>>> x3 = np.array([-1, -4])
>>> with np.errstate(invalid='ignore'):
...     p = np.float_power(x3, 1.5)
...
>>> p
array([nan, nan])

要获得复杂的结果，请给定参数dtype=complex。

>>> np.float_power(x3, 1.5, dtype=complex)
array([-1.83697020e-16-1.j, -1.46957616e-15-8.j])

`numpy.fmod`

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

numpy.fmod(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'fmod'>

返回元素级别的除法余数。

这是 C 库函数 fmod 的 NumPy 实现，余数与被除数 x1 的符号相同。它等同于 Matlab(TM) 的 rem 函数，不应与 Python 的模运算符 x1 % x2 混淆。

参数：

x1array_like

被除数。

x2array_like

除数。如果 x1.shape != x2.shape，它们必须能够广播到一个公共形状（这将成为输出的形状）。

outndarray, None, or tuple of ndarray and None, optional

wherearray_like, optional

此条件广播到输入。在条件为 True 的位置，out 数组将设置为 ufunc 结果。在其他位置，out 数组将保留其原始值。请注意，如果通过默认的 out=None 创建了一个未初始化的 out 数组，则其中条件为 False 的位置将保持未初始化状态。

**kwargs

对于其他仅限关键字参数，请参阅 ufunc 文档。

yarray_like

x1除以x2的余数。如果x1和x2都是标量，则结果是标量。

另请参阅

remainder

等同于 Python 的 % 运算符。

divide

注意事项

对于负被除数和除数的模运算结果受约定限制。对于 fmod，结果的符号与被除数的符号相同，而对于 remainder，结果的符号与除数的符号相同。fmod 函数等同于 Matlab(TM) 的 rem 函数。

示例

>>> np.fmod([-3, -2, -1, 1, 2, 3], 2)
array([-1,  0, -1,  1,  0,  1])
>>> np.remainder([-3, -2, -1, 1, 2, 3], 2)
array([1, 0, 1, 1, 0, 1])

>>> np.fmod([5, 3], [2, 2.])
array([ 1.,  1.])
>>> a = np.arange(-3, 3).reshape(3, 2)
>>> a
array([[-3, -2],
 [-1,  0],
 [ 1,  2]])
>>> np.fmod(a, [2,2])
array([[-1,  0],
 [-1,  0],
 [ 1,  0]])

`numpy.mod`

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

numpy.mod(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'remainder'>

返回除法的逐元素余数。

计算与 floor_divide 函数互补的余数。它等同于 Python 模运算符x1 % x2，并且与除数 x2 具有相同的符号。与 np.remainder 等效的 MATLAB 函数是 mod。

警告

不应与以下混淆：

Python 3.7 的 math.remainder 和 C 的 remainder，计算 IEEE 余数，这是round(x1 / x2)的补数。
MATLAB rem 函数或 C % 运算符，它是int(x1 / x2)的补数。

参数：

x1array_like

除数数组。

x2array_like

除数数组。如果 x1.shape != x2.shape，它们必须能够广播到一个公共形状（这将成为输出的形状）。

outndarray、None 或 ndarray 和 None 的元组，可选

wherearray_like，可选

**kwargs

关于其他仅限关键字参数，请参阅 ufunc 文档。

yndarray

商 floor_divide(x1, x2) 的逐元素余数。如果 x1 和 x2 都是标量，则这是一个标量。

另请参见

floor_divide

Python // 运算符的等价物。

divmod

同时执行向下取整和取余。

fmod

等价于 MATLAB rem 函数。

divide, floor

笔记

当x2为 0 且x1和x2都是（数组）整数时返回 0。mod是remainder的别名。

示例

>>> np.remainder([4, 7], [2, 3])
array([0, 1])
>>> np.remainder(np.arange(7), 5)
array([0, 1, 2, 3, 4, 0, 1])

% 运算符可用作np.remainder在 ndarrays 上的简写。

>>> x1 = np.arange(7)
>>> x1 % 5
array([0, 1, 2, 3, 4, 0, 1])

`numpy.modf`

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

numpy.modf(x, [out1, out2, ]/, [out=(None, None), ]*, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'modf'>

返回一个数组的小数部分和整数部分。

如果给定的数字是负数，则分数部分和整数部分为负数。

参数:

x类似数组

输入数组。

out数组, None，或数组和 None 的元组，可选

结果存储的位置。如果提供，它必须具有输入广播到的形状。如果未提供或为 None，则返回一个新分配的数组。作为关键字参数的元组（仅可能）的长度必须等于输出的数量。

where类似数组，可选

此条件广播到输入上。在条件为 True 的位置，out数组将设置为 ufunc 结果。否则，out数组将保留其原始值。请注意，如果通过默认的out=None创建了一个未初始化的out数组，则其中条件为 False 的位置将保持未初始化。

**kwargs

对于其他关键字参数，请参阅 ufunc 文档。

y1数组

x的小数部分。如果x是标量，则这是一个标量。

y2数组

x的整数部分。如果x是标量，则这是一个标量。

另请参阅

divmod

使用divmod(x, 1)等同于交换返回值的modf，除了它总是有一个正余数。

注

对于整数输入，返回值为浮点数。

示例

>>> np.modf([0, 3.5])
(array([ 0\. ,  0.5]), array([ 0.,  3.]))
>>> np.modf(-0.5)
(-0.5, -0)

`numpy.remainder`

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

numpy.remainder(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'remainder'>

返回元素的除法余数。

计算与 floor_divide 函数互补的余数。它等价于 Python 取模运算符 x1 % x2，并且与除数 x2 具有相同的符号。与 np.remainder 等效的 MATLAB 函数是 mod。

警告

这不应与混淆：

Python 3.7 的 math.remainder 和 C 的 remainder，计算 IEEE 余数，这是 round(x1 / x2) 的补数。
MATLAB 的 rem 函数和 C 的 % 运算符，这是 int(x1 / x2) 的补数。

参数：

x1array_like

被除数数组。

x2array_like

除数数组。如果 x1.shape != x2.shape，则它们必须可广播到一个公共形状（这成为输出的形状）。

outndarray、None 或者 ndarray 和 None 的元组，可选

存储结果的位置。如果提供，则其形状必须广播到输入的形状。如果未提供或为 None，则返回一个新分配的数组。元组（仅作为关键字参数）的长度必须等于输出的数量。

wherearray_like，可选

此条件将广播到输入。在条件为 True 的位置，out 数组将设置为 ufunc 结果。在其他位置，out 数组将保留其原始值。请注意，如果通过默认的 out=None 创建了一个未初始化的 out 数组，则其中条件为 False 的位置将保持未初始化。

**kwargs

对于其他仅限关键字参数，请参阅 ufunc 文档。

yndarray

除法商 floor_divide(x1, x2) 的元素余数。如果 x1 和 x2 都是标量，则这是一个标量。

另请参见

floor_divide

Python // 运算符的等价物。

divmod

同时进行地板除法和余数运算。

fmod

MATLAB rem 函数的等价物。

divide、floor

注意

当 x2 为 0 且 x1 和 x2 都是（数组的）整数时返回 0。mod 是 remainder 的别名。

示例

>>> np.remainder([4, 7], [2, 3])
array([0, 1])
>>> np.remainder(np.arange(7), 5)
array([0, 1, 2, 3, 4, 0, 1])

% 运算符可以在 ndarray 上用作 np.remainder 的简写。

>>> x1 = np.arange(7)
>>> x1 % 5
array([0, 1, 2, 3, 4, 0, 1])

`numpy.divmod`

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

numpy.divmod(x1, x2, [out1, out2, ]/, [out=(None, None), ]*, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'divmod'>

同时返回逐元素商和余数。

新版本中的 1.13.0。

np.divmod(x, y)等同于(x // y, x % y)，但更快，因为它避免了冗余工作。它用于在 NumPy 数组上实现 Python 内置函数divmod。

参数：

x1 array_like

被除数数组。

x2 array_like

除数数组。如果x1.shape != x2.shape，则它们必须可广播到一个共同的形状（这成为输出的形状）。

out ndarray、None 或 ndarray 和 None 的元组，可选

结果存储的位置。如果提供，它必须具有输入广播到的形状。如果未提供或为 None，则返回一个新分配的数组。一个元组（仅作为关键字参数）必须具有等于输出数量的长度。

where array_like，可选

此条件在输入上进行广播。在条件为 True 的位置，out数组将被设置为 ufunc 结果。其他地方，out数组将保持其原始值。请注意，如果通过默认的out=None创建了未初始化的out数组，则其中条件为 False 的位置将保持未初始化。

**kwargs

对于其他仅限关键字参数，请参阅 ufunc 文档。

out1 ndarray

从地板除法得到的逐元素商。如果x1和x2都是标量，则这是一个标量。

out2 ndarray

从地板除法得到的逐元素余数。如果x1和x2都是标量，则这是一个标量。

另请参见

floor_divide

等同于 Python 的//运算符。

remainder

等同于 Python 的%运算符。

modf

等同于divmod(x, 1)对于正数x，其返回值已交换。

例子

>>> np.divmod(np.arange(5), 3)
(array([0, 0, 0, 1, 1]), array([0, 1, 2, 0, 1]))

可以使用divmod函数作为对 ndarrays 上的np.divmod的简写。

>>> x = np.arange(5)
>>> divmod(x, 3)
(array([0, 0, 0, 1, 1]), array([0, 1, 2, 0, 1]))

`numpy.angle`

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

numpy.angle(z, deg=False)

返回复数参数的角度。

参数:

zarray_like

复数或复数序列。

degbool，可选

如果为 True，则以度为单位返回角度；如果为 False（默认），则以弧度为单位返回。

anglendarray 或标量

复平面上从正实轴逆时针方向的角度范围为 (-pi, pi]，数据类型为 numpy.float64。

1.16.0 版更改: 此函数适用于像ma.array这样的 ndarray 子类。

参见

arctan2

absolute

注意

尽管复数 0 的角度未定义，numpy.angle(0)返回值为 0。

示例

>>> np.angle([1.0, 1.0j, 1+1j])               # in radians
array([ 0\.        ,  1.57079633,  0.78539816]) # may vary
>>> np.angle(1+1j, deg=True)                  # in degrees
45.0

`numpy.real`

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

numpy.real(val)

返回复数参数的实部。

参数：

valarray_like

输入数组。

outndarray 或标量

复数参数的实部。如果val是实数，则输出使用val的类型。如果val有复数元素，则返回类型为浮点数。

参见

real_if_close, imag, angle

示例

>>> a = np.array([1+2j, 3+4j, 5+6j])
>>> a.real
array([1.,  3.,  5.])
>>> a.real = 9
>>> a
array([9.+2.j,  9.+4.j,  9.+6.j])
>>> a.real = np.array([9, 8, 7])
>>> a
array([9.+2.j,  8.+4.j,  7.+6.j])
>>> np.real(1 + 1j)
1.0

`numpy.imag`

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

numpy.imag(val)

返回复数参数的虚部。

参数：

val类似数组

输入数组。

返回值：

outndarray or scalar

复数参数的虚部。如果val是实数，则使用val的类型输出。如果val具有复数元素，则返回类型为浮点数。

另请参阅

real, angle, real_if_close

例子

>>> a = np.array([1+2j, 3+4j, 5+6j])
>>> a.imag
array([2.,  4.,  6.])
>>> a.imag = np.array([8, 10, 12])
>>> a
array([1\. +8.j,  3.+10.j,  5.+12.j])
>>> np.imag(1 + 1j)
1.0

`numpy.conj`

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

numpy.conj(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'conjugate'>

返回复数的共轭，逐元素进行计算。

复数的共轭通过改变其虚部的符号而得到。

参数：

x array_like

输入值。

out ndarray、None 或者 ndarray 和 None 的元组，可选

存储结果的位置。如果提供，必须具有与输入广播到的形状相同的形状。如果未提供或为 None，则返回一个新分配的数组。一个元组（仅作为关键字参数可能）的长度必须等于输出的数量。

where array_like，可选

此条件广播到输入。在条件为真的位置，out 数组将设置为 ufunc 的结果。否则，out 数组将保留其原始值。请注意，如果通过默认的out=None创建了未初始化的out数组，则条件为假的位置将保持未初始化状态。

**kwargs

其他关键字参数，请查看 ufunc 文档。

返回值：

y ndarray

x 的复数共轭，具有与 y 相同的数据类型。如果 x 是标量，则其结果也是标量。

注意

conj 是conjugate的别名：

>>> np.conj is np.conjugate
True

示例

>>> np.conjugate(1+2j)
(1-2j)

>>> x = np.eye(2) + 1j * np.eye(2)
>>> np.conjugate(x)
array([[ 1.-1.j,  0.-0.j],
 [ 0.-0.j,  1.-1.j]])

`numpy.conjugate`

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

numpy.conjugate(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'conjugate'>

逐元素返回复共轭。

复数的复共轭是通过改变其虚部的符号得到的。

参数：

xarray_like

输入值。

outndarray, None, or tuple of ndarray and None, optional

存储结果的位置。如果提供，它必须具有输入广播到的形状。如果未提供或为 None，则返回一个新分配的数组。元组（仅限关键字参数）的长度必须等于输出的数量。

wherearray_like, optional

此条件通过输入进行广播。在条件为真的位置，out数组将设为 ufunc 结果。在其他位置，out数组将保持其原始值。请注意，如果通过默认的out=None创建了一个未初始化的out数组，那么条件为假的位置将保持未初始化状态。

**kwargs

对于其他仅限关键字参数，请参阅 ufunc docs。

yndarray

x的复共轭，与y具有相同的 dtype。如果x是标量，则这是一个标量。

注释

conj是conjugate的别名：

>>> np.conj is np.conjugate
True

示例

>>> np.conjugate(1+2j)
(1-2j)

>>> x = np.eye(2) + 1j * np.eye(2)
>>> np.conjugate(x)
array([[ 1.-1.j,  0.-0.j],
 [ 0.-0.j,  1.-1.j]])

`numpy.maximum`

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

numpy.maximum(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'maximum'>

数组元素的逐元素最大值。

比较两个数组并返回一个包含逐元素最大值的新数组。如果被比较的元素之一是 NaN，则返回该元素。如果两个元素都是 NaN，则返回第一个。后面的区别对于复数 NaN 很重要，它们被定义为至少一个实部或虚部是 NaN。其最终效果是 NaN 被传播。

参数：

x1, x2 array_like

包含要进行比较的元素的数组。如果x1.shape != x2.shape，它们必须能够广播到一个公共形状（这成为输出的形状）。

out ndarray、None 或 ndarray 和 None 组成的元组，可选

位置存储结果。如果提供了，它必须具有输入广播到的形状。如果未提供或为 None，则返回一个新分配的数组。一个元组（仅作为关键字参数）必须具有长度等于输出数量。

where array_like，可选

此条件被广播到输入。在条件为 True 的位置，out数组将设置为 ufunc 结果。在其他地方，out数组将保留其原始值。请注意，如果通过默认的out=None创建了未初始化的out数组，则其中条件为 False 的位置将保持未初始化状态。

**kwargs

对于其他只能作为关键字参数的参数，请参阅 ufunc 文档。

y ndarray 或标量

x1和x2的逐元素最大值。如果x1和x2都是标量，则为标量。

另请参见

minimum

两个数组的逐元素最小值，传播 NaN 值。

fmax

两个数组的逐元素最大值，忽略 NaN 值。

amax

数组在给定轴向的最大值传播 NaN 值。

nanmax

数组在给定轴向的最大值，忽略 NaN 值。

fmin, amin, nanmin

注

当 x1 和 x2 都不是 nan 时，最大值相当于np.where(x1 >= x2, x1, x2)，但它更快并且进行适当的广播。

示例

>>> np.maximum([2, 3, 4], [1, 5, 2])
array([2, 5, 4])

>>> np.maximum(np.eye(2), [0.5, 2]) # broadcasting
array([[ 1\. ,  2\. ],
 [ 0.5,  2\. ]])

>>> np.maximum([np.nan, 0, np.nan], [0, np.nan, np.nan])
array([nan, nan, nan])
>>> np.maximum(np.Inf, 1)
inf

`numpy.max`

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

numpy.max(a, axis=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)

返回数组的最大值或沿轴的最大值。

参数:

a类似数组

输入数据。

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

在哪个轴上执行操作。默认情况下，使用扁平化的输入。

新版本 1.7.0。

如果这是一个整数元组，则将在多个轴上选择最大值，而不是之前的单个轴或所有轴。

outndarray，可选

输出结果的备用数组，必须与预期输出具有相同的形状和缓冲区长度。更多详情请参见输出类型确定。

keepdims布尔值，可选

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

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

initial标量，可选

输出元素的最小值。必须出现在允许对空切片进行计算的情况下。详情请参见reduce。

新版本 1.15.0。

wherebool 数组，可选

要比较的最大元素。详情请参见reduce。

新版本 1.17.0。

maxndarray 或标量

a 的最大值。如果 axis 为 None，则结果是标量值。如果 axis 是整数，则结果是维度为 a.ndim - 1 的数组。如果 axis 是元组，则结果是维度为 a.ndim - len(axis) 的数组。

另请参见

amin

沿给定轴的数组的最小值，传播任何 NaN。

nanmax

忽略任何 NaN，沿着给定轴的数组的最大值。

maximum

两个数组的逐元素最大值，传播任何 NaN。

fmax

两个数组的逐元素最大值，忽略任何 NaN。

argmax

返回最大值的索引。

nanmin，minimum，fmin

注意

NaN 值被传播，即如果至少有一个项目为 NaN，则相应的最大值也将为 NaN。要忽略 NaN 值（MATLAB 规则），请使用 nanmax。

不要对 2 个数组进行逐元素比较使用max；当a.shape[0]为 2 时，maximum(a[0], a[1])比max(a, axis=0)更快。

例子

>>> a = np.arange(4).reshape((2,2))
>>> a
array([[0, 1],
 [2, 3]])
>>> np.max(a)           # Maximum of the flattened array
3
>>> np.max(a, axis=0)   # Maxima along the first axis
array([2, 3])
>>> np.max(a, axis=1)   # Maxima along the second axis
array([1, 3])
>>> np.max(a, where=[False, True], initial=-1, axis=0)
array([-1,  3])
>>> b = np.arange(5, dtype=float)
>>> b[2] = np.NaN
>>> np.max(b)
nan
>>> np.max(b, where=~np.isnan(b), initial=-1)
4.0
>>> np.nanmax(b)
4.0

您可以使用初始值来计算空片段的最大值，或者将其初始化为不同的值：

>>> np.max([[-50], [10]], axis=-1, initial=0)
array([ 0, 10])

注意，初始值被用作确定最大值的元素之一，不同于默认参数 Python 的 max 函数，后者仅用于空可迭代对象。

>>> np.max([5], initial=6)
6
>>> max([5], default=6)
5

posted @ 2024-06-24 14:56 绝不原创的飞龙阅读(2) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

龙哥盟

掠夺·扩张·投机·博弈

NumPy-1-26-中文文档-十五-

NumPy 1.26 中文文档（十五）

numpy.unwrap

numpy.deg2rad

numpy.rad2deg

numpy.sinh

numpy.cosh

numpy.tanh

numpy.arcsinh

numpy.arccosh

numpy.arctanh

numpy.round

numpy.around

numpy.rint

numpy.fix

numpy.floor

numpy.ceil

numpy.trunc

numpy.prod

numpy.sum

numpy.nanprod

numpy.nansum

numpy.cumprod

numpy.cumsum

numpy.nancumprod

numpy.nancumsum

numpy.diff

numpy.ediff1d

numpy.gradient

numpy.cross

numpy.trapz

numpy.exp

numpy.expm1

numpy.exp2

numpy.log

numpy.log10

numpy.log2

numpy.log1p

numpy.logaddexp

numpy.logaddexp2

numpy.i0

numpy.sinc

numpy.signbit

numpy.copysign

numpy.frexp

numpy.ldexp

numpy.nextafter

numpy.spacing

numpy.lcm

numpy.gcd

numpy.add

numpy.reciprocal

numpy.positive

numpy.negative

numpy.multiply

numpy.divide

numpy.power

numpy.subtract

numpy.true_divide

numpy.floor_divide

numpy.float_power

numpy.fmod

numpy.mod

numpy.modf

numpy.remainder

numpy.divmod

numpy.angle

numpy.real

numpy.imag

numpy.conj

numpy.conjugate

numpy.maximum

numpy.max

公告

`numpy.unwrap`

`numpy.deg2rad`

`numpy.rad2deg`

`numpy.sinh`

`numpy.cosh`

`numpy.tanh`

`numpy.arcsinh`

`numpy.arccosh`

`numpy.arctanh`

`numpy.round`

`numpy.around`

`numpy.rint`

`numpy.fix`

`numpy.floor`

`numpy.ceil`

`numpy.trunc`

`numpy.prod`

`numpy.sum`

`numpy.nanprod`

`numpy.nansum`

`numpy.cumprod`

`numpy.cumsum`

`numpy.nancumprod`

`numpy.nancumsum`

`numpy.diff`

`numpy.ediff1d`

`numpy.gradient`

`numpy.cross`

`numpy.trapz`

`numpy.exp`

`numpy.expm1`

`numpy.exp2`

`numpy.log`

`numpy.log10`

`numpy.log2`

`numpy.log1p`

`numpy.logaddexp`

`numpy.logaddexp2`

`numpy.i0`

`numpy.sinc`

`numpy.signbit`

`numpy.copysign`

`numpy.frexp`

`numpy.ldexp`

`numpy.nextafter`

`numpy.spacing`

`numpy.lcm`

`numpy.gcd`

`numpy.add`

`numpy.reciprocal`

`numpy.positive`

`numpy.negative`

`numpy.multiply`

`numpy.divide`

`numpy.power`

`numpy.subtract`

`numpy.true_divide`

`numpy.floor_divide`

`numpy.float_power`

`numpy.fmod`

`numpy.mod`

`numpy.modf`

`numpy.remainder`

`numpy.divmod`

`numpy.angle`

`numpy.real`

`numpy.imag`

`numpy.conj`

`numpy.conjugate`

`numpy.maximum`

`numpy.max`