NumPy-1-26-中文文档-七-

NumPy 1.26 中文文档（七）

原文：numpy.org/doc/

常量

原文：numpy.org/doc/1.26/reference/constants.html

NumPy 包含几个常量：

numpy.Inf

IEEE 754 浮点表示的（正）无穷大。

使用inf，因为Inf、Infinity、PINF和infty都是inf的别名。更多详情，请参见inf。

参见

inf

numpy.Infinity

IEEE 754 浮点表示的（正）无穷大。

使用inf，因为Inf、Infinity、PINF和infty都是inf的别名。更多详情，请参见inf。

参见

inf

numpy.NAN

NaN 的 IEEE 754 浮点表示。

NaN和NAN是nan的等效定义。请使用nan而不是NAN。

参见

nan

numpy.NINF

IEEE 754 浮点表示的负无穷大。

yfloat

负无穷大的浮点表示。

参见

isinf：显示哪些元素是正无穷大或负无穷大

isposinf：显示哪些元素是正无穷大

isneginf：显示哪些元素是负无穷大

isnan：显示哪些元素是 NaN

isfinite：显示哪些元素是有限的（不是 NaN、正无穷大或负无穷大之一）

注意

NumPy 使用 IEEE 二进制浮点算术标准（IEEE 754）。这意味着 NaN 不等同于无穷大。同时，正无穷大也不等同于负无穷大。但无穷大等同于正无穷大。

示例

>>> np.NINF
-inf
>>> np.log(0)
-inf

numpy.NZERO

负零的 IEEE 754 浮点表示。

yfloat

负零的浮点表示。

参见

PZERO：定义正零。

isinf：显示哪些元素是正无穷大或负无穷大。

isposinf：显示哪些元素是正无穷大。

isneginf：显示哪些元素是负无穷大。

isnan：显示哪些元素是 NaN。

isfinite：显示哪些元素是有限的 - 不是 NaN、正无穷大或负无穷大之一

NaN、正无穷大和负无穷大。

注意

NumPy 使用 IEEE 二进制浮点算术标准（IEEE 754）。负零被视为有限数。

示例

>>> np.NZERO
-0.0
>>> np.PZERO
0.0

>>> np.isfinite([np.NZERO])
array([ True])
>>> np.isnan([np.NZERO])
array([False])
>>> np.isinf([np.NZERO])
array([False])

numpy.NaN

NaN 的 IEEE 754 浮点表示。

NaN和NAN是nan的等效定义。请使用nan而不是NaN。

参见

nan

numpy.PINF

IEEE 754 浮点表示的（正）无穷大。

使用inf，因为Inf、Infinity、PINF和infty都是inf的别名。更多详情，请参见inf。

参见

inf

numpy.PZERO

IEEE 754 浮点表示正零。

yfloat

正零的浮点表示。

参见

NZERO：定义负零。

isinf：显示哪些元素是正无穷大或负无穷大。

isposinf：显示哪些元素是正无穷大。

isneginf：显示哪些元素是负无穷大。

isnan：显示哪些元素不是一个数字。

isfinite：显示哪些元素是有限的 - 不是不是一个数字、正无穷大和负无穷大之一

不是一个数字、正无穷大和负无穷大。

注意

NumPy 使用 IEEE 二进制浮点算术标准（IEEE 754）。正零被视为有限数。

示例

>>> np.PZERO
0.0
>>> np.NZERO
-0.0

>>> np.isfinite([np.PZERO])
array([ True])
>>> np.isnan([np.PZERO])
array([False])
>>> np.isinf([np.PZERO])
array([False])

numpy.e

欧拉常数，自然对数的底数，纳皮尔常数。

e = 2.71828182845904523536028747135266249775724709369995...

参见

exp：指数函数 log：自然对数

参考

en.wikipedia.org/wiki/E_%28mathematical_constant%29

numpy.euler_gamma

γ = 0.5772156649015328606065120900824024310421...

参考

en.wikipedia.org/wiki/Euler-Mascheroni_constant

numpy.inf

IEEE 754 浮点表示（正）无穷大。

yfloat

正无穷大的浮点表示。

参见

isinf：显示哪些元素是正无穷大或负无穷大

isposinf：显示哪些元素是正无穷大

isneginf：显示哪些元素是负无穷大

isnan：显示哪些元素不是一个数字

isfinite：显示哪些元素是有限的（不是不是一个数字、正无穷大和负无穷大之一��

注意

NumPy 使用 IEEE 二进制浮点算术标准（IEEE 754）。这意味着不是一个数字不等同于无穷大。而且正无穷大不等同于负无穷大。但无穷大等同于正无穷大。

Inf、Infinity、PINF和infty都是inf的别名。

示例

>>> np.inf
inf
>>> np.array([1]) / 0.
array([ Inf])

numpy.infty

IEEE 754 浮点表示（正）无穷大。

使用inf，因为Inf、Infinity、PINF和infty都是inf的别名。更多详情，请参见inf。

参见

inf

numpy.nan

IEEE 754 浮点表示不是一个数字（NaN）。

y：不是一个数字的浮点表示。

参见

isnan：显示哪些元素不是一个数字。

isfinite：显示哪些元素是有限的（不是 NaN、正无穷大和负无穷大之一）

注意

NumPy 使用 IEEE 标准的二进制浮点运算（IEEE 754）。这意味着 NaN 不等同于无穷大。

NaN和NAN是nan的别名。

示例

>>> np.nan
nan
>>> np.log(-1)
nan
>>> np.log([-1, 1, 2])
array([        NaN,  0\.        ,  0.69314718])

numpy.newaxis

一个方便的别名，用于索引数组。

示例

>>> newaxis is None
True
>>> x = np.arange(3)
>>> x
array([0, 1, 2])
>>> x[:, newaxis]
array([[0],
[1],
[2]])
>>> x[:, newaxis, newaxis]
array([[[0]],
[[1]],
[[2]]])
>>> x[:, newaxis] * x
array([[0, 0, 0],
[0, 1, 2],
[0, 2, 4]])

外积，与outer(x, y)相同：

>>> y = np.arange(3, 6)
>>> x[:, newaxis] * y
array([[ 0,  0,  0],
[ 3,  4,  5],
[ 6,  8, 10]])

x[newaxis, :]等同于x[newaxis]和x[None]：

>>> x[newaxis, :].shape
(1, 3)
>>> x[newaxis].shape
(1, 3)
>>> x[None].shape
(1, 3)
>>> x[:, newaxis].shape
(3, 1)

numpy.pi

pi = 3.1415926535897932384626433...

参考资料

en.wikipedia.org/wiki/Pi

通用函数（ufunc）

原文：numpy.org/doc/1.26/reference/ufuncs.html

另请参阅

通用函数（ufunc）基础知识

通用函数（或简称为 ufunc）是一种以逐元素方式在ndarrays上操作的函数，支持数组广播、类型转换和其他几个标准功能。换句话说，ufunc 是一个为接受固定数量特定输入并产生固定数量特定输出的函数提供“矢量化”包装器。有关通用函数的详细信息，请参阅通用函数（ufunc）基础知识。

`ufunc`

`numpy.ufunc`()	在整个数组上逐元素操作的函数。

可选关键字参数

所有 ufunc 都接受可选关键字参数。其中大多数代表高级用法，通常不会被使用。

out

新版本 1.6 中新增。

第一个输出可以作为位置参数或关键字参数提供。关键字‘out’参数与位置参数不兼容。

新版本 1.10 中新增。

预计‘out’关键字参数将是一个元组，每个输出一个条目（对于由 ufunc 分配的数组，可以为 None）。对于具有单个输出的 ufunc，传递单个数组（而不是包含单个数组的元组）也是有效的。

将单个数组传递给具有多个输出的 ufunc 的‘out’关键字参数已被弃用，在 numpy 1.10 中将会发出警告，并在将来的版本中引发错误。

如果‘out’为 None（默认值），则会创建一个未初始化的返回数组。然后，输出数组将用 ufunc 的结果填充在广播‘where’为 True 的位置。如果‘where’是标量 True（默认值），则这对应于整个输出被填充。请注意，未明确填充的输出将保留其未初始化的值。

新版本 1.13 中新增。

在 ufunc 输入和输出操作数存在内存重叠的操作被定义为与没有内存重叠的等效操作相同。受影响的操作根据需要进行临时复制以消除数据依赖性。由于检测这些情况在计算上是昂贵的，因此使用了一种启发式方法，这可能在极少数情况下导致不必要的临时复制。对于启发式分析足够简单的操作，即使数组重叠，也不会进行临时复制，如果可以推断不需要复制。例如，np.add(a, b, out=a)不会涉及复制。

where

新版本 1.7 中新增。

接受一个布尔数组，该数组与操作数一起广播。True 值表示在该位置计算 ufunc，False 值表示保持输出中的值不变。此参数不能用于通用 ufunc，因为这些 ufunc 接受非标量输入。

请注意，如果创建了一个未初始化的返回数组，False 值将使这些值未初始化。

axes

版本 1.15 中新增。

一个包含轴索引的元组列表，通用 ufunc 应该在这些轴上操作。例如，对于一个适用于矩阵乘法的签名(i,j),(j,k)->(i,k)，基本元素是二维矩阵，这些矩阵被认为存储在每个参数的最后两个轴中。相应的轴关键字将是[(-2, -1), (-2, -1), (-2, -1)]。为简单起见，对于操作在 1 维数组（向量）上的通用 ufunc，可以接受一个整数而不是单个元素元组，对于所有输出都是标量的通用 ufunc，可以省略输出元组。

axis

版本 1.15 中新增。

一个通用 ufunc 应该操作的单个轴。这是对操作在单个共享核心维度上的 ufunc 的快捷方式，相当于为每个单核心维度参数传入(axis,)的条目和对于所有其他参数传入()。例如，对于签名(i),(i)->()，相当于传入axes=[(axis,), (axis,), ()]。

keepdims

版本 1.15 中新增。

如果设置为True，那些被减少的轴将保留在结果中作为一个大小为一的维度，以便结果能正确地广播到输入。此选项仅适用于操作具有相同核心维度数量的输入和没有核心维度的输出的通用 ufunc，即具有类似(i),(i)->()或(m,m)->()的签名。如果使用，可以通过axes和axis来控制输出中维度的位置。

casting

版本 1.6 中新增。

可能是‘no’、‘equiv’、‘safe’、‘same_kind’或‘unsafe’。请参阅can_cast以了解参数值的解释。

提供了一个关于允许何种类型转换的策略。为了与 NumPy 之前版本的兼容性，默认为 numpy < 1.7 时为‘unsafe’。在 numpy 1.7 中开始了向‘same_kind’的过渡，其中 ufunc 对于在‘unsafe’规则下允许的调用会产生 DeprecationWarning，但在‘same_kind’规则下不允许。从 numpy 1.10 开始，默认为‘same_kind’。

order

版本 1.6 中新增。

指定输出数组的计算迭代顺序/内存布局。默认为‘K’。‘C’表示输出应为 C 连续，‘F’表示 F 连续，‘A’表示如果输入是 F 连续且不是 C 连续，则为 F 连续，否则为 C 连续，‘K’表示尽可能与输入的元素顺序匹配。

dtype

版本 1.6 中新增。

覆盖输出数组的 DType，方式与signature相同。这应该确保计算的精度匹配。所选的确切计算 DTypes 可能取决于 ufunc，输入可能被转换为此 DType 以执行计算。

subok

版本 1.6 中新增。

默认为 true。如果设置为 false，则输出将始终是严格的数组，而不是子类型。

signature

可以是 Dtype、DTypes 元组或特殊的签名字符串，指示 ufunc 的输入和输出类型。

此参数允许用户指定用于计算的确切 DTypes。必要时将使用转换。除非signature为该数组为None，否则不考虑输入数组的实际 DType。

当所有 DTypes 都固定时，选择特定的循环或者如果没有匹配的循环存在则引发错误。如果某些 DTypes 未指定并且保留为None，则行为可能取决于 ufunc。此时，ufunc 的types属性提供了可用签名的列表。（此列表可能缺少 NumPy 未定义的 DTypes。）

signature仅指定 DType 类/类型。例如，它可以指定操作应为datetime64或float64操作。它不指定datetime64时间单位或float64字节顺序。

为了向后兼容，此参数也可以提供为sig，尽管更倾向于使用长格式。请注意，这不应与存储在 ufunc 对象的signature属性中的广义 ufunc signature 混淆。

extobj

长度为 3 的列表，指定 ufunc 缓冲区大小、错误模式整数和错误回调函数。通常，这些值在特定线程的字典中查找。在此传递它们可以绕过该查找并使用为错误模式提供的低级规范。例如，在需要在循环中对小数组进行多次 ufunc 调用的计算中，这可能很有用作为优化。

属性

通用函数具有一些信息性属性。这些属性都不能被设置。

doc	每个 ufunc 的文档字符串。文档字符串的第一部分是根据输出数量、名称和输入数量动态生成的。文档字符串的第二部分是在创建时提供的，并与 ufunc 一起存储。
name	ufunc 的名称。
`ufunc.nin`	输入的数量。
`ufunc.nout`	输出的数量。
`ufunc.nargs`	参数的数量。
`ufunc.ntypes`	类型的数量。
`ufunc.types`	返回一个按输入->输出分组的类型列表。
`ufunc.identity`	标识值。
`ufunc.signature`	通用 ufunc 操作的核心元素的定义。

方法

`ufunc.reduce`(array[, axis, dtype, out, ...])	通过沿一个轴应用 ufunc，将`array`的维度减少一个。
`ufunc.accumulate`(array[, axis, dtype, out])	对所有元素应用运算符的结果进行累积。
`ufunc.reduceat`(array, indices[, axis, ...])	在单个轴上执行指定切片的（局部）归约。
`ufunc.outer`(A, B, /, **kwargs)	将 ufunc op 应用于所有(a, b)对，其中 a 在A中，b 在B中。
`ufunc.at`(a, indices[, b])	对由'indices'指定的元素在操作数'a'上执行无缓冲区的原地操作。

警告

对具有处理结果的范围“太小”的数据类型的数组进行类似归约的操作将悄悄地包装。应使用dtype来增加进行减少的数据类型的大小。

可用的 ufunc

目前在numpy中定义了 60 多个通用函数，涵盖了多种操作类型。当使用相关的中缀符号时（例如，当写入a + b时，如果a或b是ndarray，则内部会自动调用add(a, b)），一些 ufunc 将自动在数组上调用。尽管如此，您可能仍希望使用 ufunc 调用，以使用可选的输出参数将输出放置在您选择的对象（或对象）中。

请记住，每个 ufunc 都是逐元素操作。因此，每个标量 ufunc 将被描述为在一组标量输入上操作以返回一组标量输出。

注意

即使使用了可选的输出参数，ufunc 仍会返回其输出。

数学运算

`add`(x1, x2, /[, out, where, casting, order, ...])	逐元素相加参数。
`subtract`(x1, x2, /[, out, where, casting, ...])	逐元素相减。
`multiply`(x1, x2, /[, out, where, casting, ...])	逐元素相乘。
`matmul`(x1, x2, /[, out, casting, order, ...])	两个数组的矩阵乘积。
`divide`(x1, x2, /[, out, where, casting, ...])	逐元素相除。
`logaddexp`(x1, x2, /[, out, where, casting, ...])	计算输入指数之和的对数。
`logaddexp2`(x1, x2, /[, out, where, casting, ...])	以 2 为底，计算输入指数之和的对数。
`true_divide`(x1, x2, /[, out, where, ...])	逐元素相除。
`floor_divide`(x1, x2, /[, out, where, ...])	返回输入的商的最大整数，小于或等于该商。
`negative`(x, /[, out, where, casting, order, ...])	数值取负，逐元素操作。
`positive`(x, /[, out, where, casting, order, ...])	数值取正，逐元素操作。
`power`(x1, x2, /[, out, where, casting, ...])	第一个数组元素按第二个数组元素的幂逐元素计算。
`float_power`(x1, x2, /[, out, where, ...])	第一个数组元素按第二个数组元素的幂逐元素计算。
`remainder`(x1, x2, /[, out, where, casting, ...])	返回除法的逐元素余数。
`mod`(x1, x2, /[, out, where, casting, order, ...])	返回除法的逐元素余数。
`fmod`(x1, x2, /[, out, where, casting, ...])	返回除法的逐元素余数。
`divmod`(x1, x2[, out1, out2], / [[, out, ...])	同时返回逐元素商和余数。
`absolute`(x, /[, out, where, casting, order, ...])	逐元素计算绝对值。
`fabs`(x, /[, out, where, casting, order, ...])	逐元素计算绝对值。
`rint`(x, /[, out, where, casting, order, ...])	将数组中的元素四舍五入到最近的整数。
`sign`(x, /[, out, where, casting, order, ...])	返回数字的逐元素符号指示。
`heaviside`(x1, x2, /[, out, where, casting, ...])	计算 Heaviside 阶跃函数。
`conj`(x, /[, out, where, casting, order, ...])	返回复共轭，逐元素计算。
`conjugate`(x, /[, out, where, casting, ...])	返回复共轭，逐元素计算。
`exp`(x, /[, out, where, casting, order, ...])	计算输入数组中所有元素的指数。
`exp2`(x, /[, out, where, casting, order, ...])	计算输入数组中所有p的2p。
`log`(x, /[, out, where, casting, order, ...])	自然对数，逐元素计算。
`log2`(x, /[, out, where, casting, order, ...])	x 的以 2 为底的对数。
`log10`(x, /[, out, where, casting, order, ...])	返回输入数组的以 10 为底的对数，逐元素计算。
`expm1`(x, /[, out, where, casting, order, ...])	计算数组中所有元素的`exp(x) - 1`。
`log1p`(x, /[, out, where, casting, order, ...])	返回输入数组加一后的自然对数，逐元素计算。
`sqrt`(x, /[, out, where, casting, order, ...])	返回数组的非负平方根，逐元素计算。
`square`(x, /[, out, where, casting, order, ...])	返回输入的逐元素平方。
`cbrt`(x, /[, out, where, casting, order, ...])	返回数组的立方根，逐元素计算。
`reciprocal`(x, /[, out, where, casting, ...])	返回参数的倒数，逐元素计算。
`gcd`(x1, x2, /[, out, where, casting, order, ...])	返回`\|x1\|`和`\|x2\|`的最大公约数。
`lcm`(x1, x2, /[, out, where, casting, order, ...])	返回`\|x1\|`和`\|x2\|`的最小公倍数。

Tip

可选的输出参数可用于帮助您在大型计算中节省内存。如果您的数组很大，复杂的表达式可能需要比绝对必要的时间更长，因为会创建和（稍后）销毁临时计算空间。例如，表达式 G = A * B + C 等同于 T1 = A * B; G = T1 + C; del T1。将更快地执行为 G = A * B; add(G, C, G)，这与 G = A * B; G += C 相同。

三角函数

所有三角函数在需要角度时使用弧度。度数与弧度的比率为 (180^{\circ}/\pi)。

`sin`(x, /[, out, where, casting, order, ...])	逐元素计算正弦函数。
`cos`(x, /[, out, where, casting, order, ...])	逐元素计算余弦函数。
`tan`(x, /[, out, where, casting, order, ...])	逐元素计算正切函数。
`arcsin`(x, /[, out, where, casting, order, ...])	逐元素计算反正弦函数。
`arccos`(x, /[, out, where, casting, order, ...])	逐元素计算反余弦函数。
`arctan`(x, /[, out, where, casting, order, ...])	逐元素计算反正切函数。
`arctan2`(x1, x2, /[, out, where, casting, ...])	逐元素计算 `x1/x2` 的反正切值，并正确选择象限。
`hypot`(x1, x2, /[, out, where, casting, ...])	给定直角三角形的“腿”，返回其斜边。
`sinh`(x, /[, out, where, casting, order, ...])	逐元素计算双曲正弦函数。
`cosh`(x, /[, out, where, casting, order, ...])	逐元素计算双曲余弦函数。
`tanh`(x, /[, out, where, casting, order, ...])	逐元素计算双曲正切函数。
`arcsinh`(x, /[, out, where, casting, order, ...])	逐元素计算反双曲正弦函数。
`arccosh`(x, /[, out, where, casting, order, ...])	逐元素计算反双曲余弦函数。
`arctanh`(x, /[, out, where, casting, order, ...])	逐元素计算反双曲正切函数。
`degrees`(x, /[, out, where, casting, order, ...])	将弧度转换为角度。
`角度转弧度`(x, /[, out, where, casting, order, ...])	将角度从度转换为弧度。
`度转弧度`(x, /[, out, where, casting, order, ...])	将角度从度转换为弧度。
`弧度转角度`(x, /[, out, where, casting, order, ...])	将角度从弧度转换为度。

位操作函数

这些函数都需要整数参数，并且它们操作这些参数的位模式。

`按位与`(x1, x2, /[, out, where, ...])	逐元素计算两个数组的按位与。
`按位或`(x1, x2, /[, out, where, casting, ...])	逐元素计算两个数组的按位或。
`按位异或`(x1, x2, /[, out, where, ...])	逐元素计算两个数组的按位异或。
`按位取反`(x, /[, out, where, casting, order, ...])	计算逐元素的按位取反或按位非。
`左移`(x1, x2, /[, out, where, casting, ...])	将整数的位向左移动。
`右移`(x1, x2, /[, out, where, ...])	将整数的位向右移动。

比较函数

`大于`(x1, x2, /[, out, where, casting, ...])	返回逐元素的(x1 > x2)的真值。
`大于等于`(x1, x2, /[, out, where, ...])	返回逐元素的(x1 >= x2)的真值。
`小于`(x1, x2, /[, out, where, casting, ...])	返回逐元素的(x1 < x2)的真值。
`小于等于`(x1, x2, /[, out, where, casting, ...])	返回逐元素的(x1 <= x2)的真值。
`不等于`(x1, x2, /[, out, where, casting, ...])	返回逐元素的(x1 != x2)。
`相等`(x1, x2, /[, out, where, casting, ...])	返回逐元素的(x1 == x2)。

警告

不要使用 Python 关键字and和or来组合逻辑数组表达式。这些关键字将测试整个数组的真值（而不是你可能期望的逐元素）。请使用按位运算符&和|代替。

`logical_and`(x1, x2, /[, out, where, ...])	计算 x1 与 x2 的逻辑与值，逐元素进行。
`logical_or`(x1, x2, /[, out, where, casting, ...])	计算 x1 或 x2 的逻辑或值，逐元素进行。
`logical_xor`(x1, x2, /[, out, where, ...])	计算 x1 与 x2 的逻辑异或值，逐元素进行。
`logical_not`(x, /[, out, where, casting, ...])	计算 x 的逻辑非值，逐元素进行。

警告

位运算符 & 和 | 是执行逐元素数组比较的正确方式。请确保您理解运算符的优先级：(a > 2) & (a < 5) 是正确的语法，因为 a > 2 & a < 5 会导致错误，因为首先评估 2 & a。

`maximum`(x1, x2, /[, out, where, casting, ...])	数组元素的逐元素最大值。

提示

Python 函数 max() 可以在一维数组上找到最大值，但是使用较慢的序列接口。最大 ufunc 的 reduce 方法要快得多。此外，max() 方法对于大于一维的数组可能不会给出您期望的答案。最小值的 reduce 方法还允许您计算数组的总最小值。

`minimum`(x1, x2, /[, out, where, casting, ...])	数组元素的逐元素最小值。

警告

maximum(a, b) 的行为与 max(a, b) 不同。作为一个 ufunc，maximum(a, b) 对 a 和 b 进行逐元素比较，并根据两个数组中的哪个元素较大来选择结果的每个元素。相反，max(a, b) 将对象 a 和 b 视为一个整体，查看 a > b 的（总体）真值，并使用它来返回 a 或 b（作为一个整体）。minimum(a, b) 和 min(a, b) 之间也存在类似的差异。

`fmax`(x1, x2, /[, out, where, casting, ...])	数组元素的逐元素最大值。
`fmin`(x1, x2, /[, out, where, casting, ...])	数组元素的逐元素最小值。

浮点函数

请记住，所有这些函数都是在数组上逐元素进行操作，返回一个数组输出。描述仅详细说明了单个操作。

`isfinite`(x, /[, out, where, casting,��order, ...])	逐元素测试是否为有限值（既不是无穷大也不是非数字）。
`isinf`(x, /[, out, where, casting, order, ...])	逐元素测试是否为正无穷或负无穷。
`isnan`(x, /[, out, where, casting, order, ...])	逐元素测试是否为 NaN，并将结果作为布尔数组返回。
`isnat`(x, /[, out, where, casting, order, ...])	逐元素测试是否为 NaT（不是时间），并将结果作为布尔数组返回。
`fabs`(x, /[, out, where, casting, order, ...])	逐元素计算绝对值。
`signbit`(x, /[, out, where, casting, order, ...])	返回元素为 True 的位置，其中 signbit 被设置（小于零）。
`copysign`(x1, x2, /[, out, where, casting, ...])	将 x1 的符号更改为 x2 的符号，逐元素操作。
`nextafter`(x1, x2, /[, out, where, casting, ...])	返回 x1 朝向 x2 的下一个浮点值，逐元素操作。
`spacing`(x, /[, out, where, casting, order, ...])	返回 x 与最近相邻数字之间的距离。
`modf`(x[, out1, out2], / [[, out, where, ...])	返回数组的小数部分和整数部分，逐元素操作。
`ldexp`(x1, x2, /[, out, where, casting, ...])	返回 x1 * 2**x2，逐元素操作。
`frexp`(x[, out1, out2], / [[, out, where, ...])	将 x 的元素分解为尾数和二次指数。
`fmod`(x1, x2, /[, out, where, casting, ...])	返回除法的元素余数。
`floor`(x, /[, out, where, casting, order, ...])	返回输入的下限，逐元素操作。
`ceil`(x, /[, out, where, casting, order, ...])	返回输入的上限，逐元素操作。
`trunc`(x, /[, out, where, casting, order,��...])	返回输入的截断值，逐元素操作。

`ufunc`

`numpy.ufunc`()	逐元素在整个数组上操作的函数。

可选关键字参数

所有 ufuncs 都接受可选的关键字参数。其中大多数代表高级用法，通常不会被使用。

out

自版本 1.6 新增。

第一个输出可以作为位置参数或关键字参数提供。关键字‘out’参数与位置参数不兼容。

版本 1.10 中的新内容。

预期‘out’关键字参数是一个元组，每个输出一个条目（对于由 ufunc 分配的数组，可以为 None）。对于具有单个输出的 ufunc，传递单个数组（而不是包含单个数组的元组）也是有效的。

将单个数组传递给具有多个输出的 ufunc 的‘out’关键字参数已被弃用，并将在 numpy 1.10 中引发警告，并在将来的版本中引发错误。

如果‘out’为 None（默认值），则创建一个未初始化的返回数组。然后，输出数组将用 ufunc 的结果填充在广播‘where’为 True 的位置。如果‘where’是标量 True（默认值），则这对应于整个输出被填充。请注意，未明确填充的输出将保留其未初始化的值。

版本 1.13 中的新内容。

对于具有内存重叠的 ufunc 输入和输出操作，其定义与没有内存重叠的等效操作相同。受影响的操作根据需要制作临时副本以消除数据依赖性。由于检测这些情况在计算上是昂贵的，因此使用启发式方法，这可能在罕见情况下导致不必要的临时副本。对于启发式分析足够简单以分析的数据依赖性的操作，即使数组重叠，也不会制作临时副本，如果可以推断不需要副本。例如，np.add(a, b, out=a)不会涉及副本。

where

版本 1.7 中的新内容。

接受与操作数一起广播的布尔数组。True 的值表示在该位置计算 ufunc，False 的值表示保持输出中的值不变。此参数不能用于通用 ufunc，因为这些 ufunc 接受非标量输入。

请注意，如果创建了一个未初始化的返回数组，则 False 的值将使这些值保持未初始化。

轴

版本 1.15 中的新内容。

一个包含轴的索引元组列表，通用 ufunc 应该在其上操作。例如，对于适用于矩阵乘法的签名(i,j),(j,k)->(i,k)，基本元素是二维矩阵，这些矩阵被认为存储在每个参数的最后两个轴中。相应的轴关键字将是[(-2, -1), (-2, -1), (-2, -1)]。为简单起见，对于操作在 1 维数组（向量）上的通用 ufunc，可以接受单个整数而不是单个元素元组，并且对于所有输出都是标量的通用 ufunc，可以省略输出元组。

轴

版本 1.15 中的新内容。

一个广义 ufunc 应该操作的单个轴。这是对于操作在单个共享核心维度上的 ufunc 的快捷方式，相当于为每个单核心维度参数传递(axis,)的axes条目和对于所有其他参数传递()。例如，对于签名(i),(i)->()，等效于传递axes=[(axis,), (axis,), ()]。

keepdims

版本 1.15 中新增。

如果设置为True，则将被减少的轴保留在结果中作为大小为一的维度，以便结果正确地广播到输入。此选项仅适用于对所有具有相同核心维度数量的输入进行操作并且输出没有核心维度的广义 ufunc，即具有类似(i),(i)->()或(m,m)->()的签名。如果使用，可以使用axes和axis来控制输出中的维度位置。

casting

版本 1.6 中新增。

可能是‘no’、‘equiv’、‘safe’、‘same_kind’或‘unsafe’。有关参数值的解释，请参见can_cast。

提供了允许的转换类型的策略。为了与 NumPy 的先前版本兼容，对于 numpy < 1.7，默认为‘unsafe’。在 numpy 1.7 中，开始过渡到‘same_kind’，其中 ufunc 对于在‘unsafe’规则下允许的调用会产生 DeprecationWarning，但在‘same_kind’规则下不允许。从 numpy 1.10 开始，默认为‘same_kind’。

order

版本 1.6 中新增。

dtype

版本 1.6 中新增。

subok

版本 1.6 中新增。

默认为 true。如果设置为 false，则输出将始终是严格的数组，而不是子类型。

signature

可以是 Dtype、DTypes 元组或指示 ufunc 的输入和输出类型的特殊签名字符串。

此参数允许用户指定用于计算的确切 DTypes。必要时将进行强制转换。除非signature为该数组的None，否则不考虑输入数组的实际 DType。

当所有 DTypes 都固定时，将选择特定的循环或者如果没有匹配的循环存在则引发错误。如果某些 DTypes 未指定并且保留为None，则行为可能取决于 ufunc。此时，ufunc 的types属性提供了可用签名列表。（此列表可能缺少 NumPy 未定义的 DTypes。）

signature仅指定 DType 类/类型。例如，它可以指定操作应为datetime64或float64操作。它不指定datetime64时间单位或float64字节顺序。

为了向后兼容，此参数也可以提供为sig，尽管长格式更受推荐。请注意，这不应与存储在 ufunc 对象的signature属性中的广义 ufunc signature 混淆。

extobj

一个长度为 3 的列表，指定了 ufunc 缓冲区大小、错误模式整数和错误回调函数。通常，这些值在线程特定的字典中查找。在这里传递它们可以避免该查找，并使用提供的错误模式的低级规范。例如，这可能对在循环中对小数组进行多次 ufunc 调用的计算进行优化。

属性

通用函数具有一些信��属性。这些属性都不能被设置。

doc	每个 ufunc 的文档字符串。文档字符串的第一部分是根据输出数量、名称和输入数量动态生成的。文档字符串的第二部分是在创建时提供的，并与 ufunc 一起存储。
name	ufunc 的名称。
`ufunc.nin`	输入的数量。
`ufunc.nout`	输出的数量。
`ufunc.nargs`	参数的数量。
`ufunc.ntypes`	类型的数量。
`ufunc.types`	返回一个按输入->输出分组的类型列表。
`ufunc.identity`	标识值。
`ufunc.signature`	一个广义 ufunc 操作的核心元素的定义。

方法

`ufunc.reduce`(array[, axis, dtype, out, ...])	通过沿一个轴应用 ufunc，将`array`的维度减少一个。
`ufunc.accumulate`(array[, axis, dtype, out])	累积应用操作符到所有元素的结果。
`ufunc.reduceat`(array, indices[, axis, ...])	在单个轴上执行（局部）指定切片的 reduce。
`ufunc.outer`(A, B, /, **kwargs)	将 ufunc op 应用于所有(a, b)对，其中 a 在A中，b 在B中。
`ufunc.at`(a, indices[, b])	对由'indices'指定的元素在操作数'a'上执行非缓冲区内操作。

警告

对于具有范围“太小”以处理结果的数据类型的数组上的类似减少操作将静默包装。应该使用dtype来增加进行减少操作的数据类型的大小。 ### 可选关键字参数

所有 ufunc 都接受可选的关键字参数。其中大多数代表高级用法，通常不会被使用。

out

新功能在版本 1.6 中引入。

第一个输出可以作为位置参数或关键字参数提供。关键字‘out’参数与位置参数不兼容。

新功能在版本 1.10 中引入。

“out”关键字参数应该是一个元组，每个输出对应一个条目（对于需要由 ufunc 分配的数组，可以为 None）。对于只有一个输出的 ufunc，传递单个数组（而不是包含单个数组的元组）也是有效的。

在‘out’关键字参数中传递单个数组给具有多个输出的 ufunc 已被弃用，在 numpy 1.10 中会引发警告，在将来的版本中会引发错误。

如果‘out’为 None（默认值），则创建一个未初始化的返回数组。然后，输出数组将用广播“where”为 True 的位置中的 ufunc 结果填充。如果‘where’是标量 True（默认值），则对应��整个输出被填充。请注意，未明确填充的输出将保留其未初始化的值。

新功能在版本 1.13 中引入。

当 ufunc 输入和输出操作数具有内存重叠时，定义为与没有内存重叠的等效操作相同。受影响的操作根据需要进行临时复制以消除数据依赖性。由于检测这些情况的计算成本很高，因此使用了一种启发式方法，这可能在极少数情况下导致不必要的临时复制。对于启发式分析可以分析的数据依赖性简单到足以消除临时复制的操作，即使数组重叠，也不会进行复制。例如，np.add(a, b, out=a)将不涉及复制。

where

新功能在版本 1.7 中引入。

接受一个布尔数组，该数组与操作数一起进行广播。True 值指示在该位置计算 ufunc，False 值指示保持输出中的值不变。此参数不能用于广义 ufunc，因为这些 ufunc 接受非标量输入。

注意，如果创建了一个未初始化的返回数组，False 的值将使这些值保持未初始化。

axes

新功能在版本 1.15 中引入。

一个包含广义 ufunc 应该操作的轴索引的元组列表。例如，对于适用于矩阵乘法的签名(i,j),(j,k)->(i,k)，基本元素是二维矩阵，这些矩阵被认为存储在每个参数的最后两个轴中。相应的轴关键字将是[(-2, -1), (-2, -1), (-2, -1)]。为简单起见，对于操作 1 维数组（向量）的广义 ufunc，可以接受单个整数而不是单个元素元组，并且对于所有输出都是标量的广义 ufunc，可以省略输出元组。

axis

版本 1.15 中的新功能。

广义 ufunc 应该操作的单个轴。这是一个快捷方式，用于操作一个单一共享核心维度的 ufunc，相当于为每个单一核心维度参数传递(axis,)的axes条目和对于所有其他参数传递()。例如，对于签名(i),(i)->()，等效于传递axes=[(axis,), (axis,), ()]。

keepdims

版本 1.15 中的新功能。

如果设置为True，则被减少的轴将保留在结果中作为一个大小为一的维度，以便结果正确地广播到输入。此选项仅适用于操作所有具有相同核心维度数量的输入和没有核心维度的输出的广义 ufunc，即具有类似(i),(i)->()或(m,m)->()的签名。如果使用，可以使用axes和axis来控制输出中维度的位置。

casting

版本 1.6 中的新功能。

可能是‘no’、‘equiv’、‘safe’、‘same_kind’或‘unsafe’。有关参数值的解释，请参见can_cast。

提供允许的转换类型的策略。为了与 NumPy 先前版本的兼容性，默认情况下为 numpy < 1.7 为‘unsafe’。在 numpy 1.7 中，开始过渡到‘same_kind’，其中 ufunc 对于在‘unsafe’规则下允许的调用会产生 DeprecationWarning，但在‘same_kind’规则下不允许。从 numpy 1.10 开始，默认为‘same_kind’。

order

版本 1.6 中的新功能。

指定输出数组的计算迭代顺序/内存布局。默认为‘K’。‘C’表示输出应为 C 连续，‘F’表示 F 连续，‘A’表示如果输入为 F 连续且不是 C 连续，则为 F 连续，否则为 C 连续，‘K’表示尽可能与输入的元素顺序匹配。

dtype

版本 1.6 中的新功能。

重写输出数组的数据类型，方式与signature相同。这应该确保计算的精度匹配。所选的确切计算数据类型可能取决于 ufunc，输入可能会转换为此数据类型以执行计算。

subok

版本 1.6 中的新功能。

默认为 true。如果设置为 false，则输出将始终是严格的数组，而不是子类型。

signature

可以是一个 Dtype、一个 DTypes 元组或一个指示 ufunc 的输入和输出类型的特殊签名字符串。

此参数允许用户指定用于计算的确切 DTypes。必要时将使用强制转换。除非signature为该数组的None，否则不考虑输入数组的实际 DType。

当所有的 DTypes 都是固定的时，会选择特定的循环，或者如果没有匹配的循环存在则会引发错误。如果某些 DTypes 未指定并且保持为None，则行为可能取决于 ufunc。此时，ufunc 的types属性提供了可用签名的列表。（此列表可能缺少 NumPy 未定义的 DTypes。）

signature仅指定 DType 类/类型。例如，它可以指定操作应该是datetime64或float64操作。它不指定datetime64时间单位或float64字节顺序。

为了向后兼容，此参数也可以提供为sig，尽管更倾向于使用长形式。请注意，这不应与存储在 ufunc 对象的signature属性中的广义 ufunc signature 混淆。

extobj

一个长度为 3 的列表，指定了 ufunc 缓冲区大小、错误模式整数和错误回调函数。通常，这些值在特定线程的字典中查找。在此处传递它们可以避免该查找并使用为错误模式提供的低级规范。例如，对于在循环中对小数组进行多次 ufunc 调用的计算，这可能是有用的优化。

属性

通用函数具有一些信息属性。这些属性都不能被设置。

doc	每个 ufunc 的文档字符串。文档字符串的第一部分是根据输出的数量、名称和输入的数量动态生成的。文档字符串的第二部分在创建时提供并与 ufunc 一起存储。
name	ufunc 的名称。
`ufunc.nin`	输入的数量。
`ufunc.nout`	输出的数量。
`ufunc.nargs`	参数的数量。
`ufunc.ntypes`	类型的数量。
`ufunc.types`	返回一个按输入->输出分组的类型列表。
`ufunc.identity`	标识值。
`ufunc.signature`	定义广义 ufunc 操作的核心元素。

方法

`ufunc.reduce`(array[, axis, dtype, out, ...])	通过沿一个轴应用 ufunc 来减少`array`的维度。
`ufunc.accumulate`(array[, axis, dtype, out])	对所有元素应用运算符的结果进行累积。
`ufunc.reduceat`(array, indices[, axis, ...])	在单个轴上执行指定切片的（局部）缩减。
`ufunc.outer`(A, B, /, **kwargs)	将 ufunc op应用于所有(a, b)对，其中 a 在A中，b 在B中。
`ufunc.at`(a, indices[, b])	对由'indices'指定的操作数'a'执行无缓冲区的原地操作。

警告

对于具有范围“太小”以处理结果的数据类型的数组进行类似于reduce的操作将会静默地进行包装。应该使用dtype来增加进行缩减的数据类型的大小。

可用的 ufuncs

目前在numpy中定义了 60 多个通用函数，涵盖了一系列各种操作的一个或多个类型。当使用相关的中缀符号时，一些 ufuncs 会自动在数组上调用（例如，当写入a + b时，内部会调用add(a, b)，当a或b是ndarray时）。然而，您可能仍然希望使用 ufunc 调用，以使用可选的输出参数将输出放置在您选择的对象（或对象）中。

请记住，每个 ufunc 都是逐元素操作。因此，每个标量 ufunc 将被描述为在一组标量输入上操作以返回一组标量输出。

注意

即使使用可选的输出参数，ufunc 仍会返回其输出。

数学运算

`add`(x1, x2, /[, out, where, casting, order, ...])	逐元素相加参数。
`subtract`(x1, x2, /[, out, where, casting, ...])	逐元素相减。
`multiply`(x1, x2, /[, out, where, casting, ...])	逐元素相乘参数。
`matmul`(x1, x2, /[, out, casting, order, ...])	两个数组的矩阵乘积。
`divide`(x1, x2, /[, out, where, casting, ...])	逐元素相除参数。
`logaddexp`(x1, x2, /[, out, where, casting, ...])	输入指数之和的对数。
`logaddexp2`(x1, x2, /[, out, where, casting, ...])	以 2 为底输入指数之和的对数。
`true_divide`(x1, x2, /[, out, where, ...])	逐元素相除。
`floor_divide`(x1, x2, /[, out, where, ...])	返回输入除法的最大整数小于或等于。
`negative`(x, /[, out, where, casting, order, ...])	数值负数，逐元素。
`positive`(x, /[, out, where, casting, order, ...])	数值正数，逐元素。
`power`(x1, x2, /[, out, where, casting, ...])	第一个数组元素按第二个数组的幂逐元素提升。
`float_power`(x1, x2, /[, out, where, ...])	第一个数组元素按第二个数组的幂逐元素提升。
`remainder`(x1, x2, /[, out, where, casting, ...])	返回除法的逐元素余数。
`mod`(x1, x2, /[, out, where, casting, order, ...])	返回除法的逐元素余数。
`fmod`(x1, x2, /[, out, where, casting, ...])	返回除法的逐元素余数。
`divmod`(x1, x2[, out1, out2], / [[, out, ...])	同时返回逐元素商和余数。
`absolute`(x, /[, out, where, casting, order, ...])	逐元素计算绝对值。
`fabs`(x, /[, out, where, casting, order, ...])	逐元素计算绝对值。
`rint`(x, /[, out, where, casting, order, ...])	将数组元素四舍五入到最接近的整数。
`sign`(x, /[, out, where, casting, order, ...])	返回一个数字的逐元素符号指示。
`heaviside`(x1, x2, /[, out, where, casting, ...])	计算海维赛德阶跃函数。
`conj`(x, /[, out, where, casting, order, ...])	返回复共轭，逐元素操作。
`conjugate`(x, /[, out, where, casting, ...])	返回复共轭，逐元素操作。
`exp`(x, /[, out, where, casting, order, ...])	计算输入数组中所有元素的指数。
`exp2`(x, /[, out, where, casting, order, ...])	计算输入数组中所有p的2p。
`log`(x, /[, out, where, casting, order, ...])	自然对数，逐元素操作。
`log2`(x, /[, out, where, casting, order, ...])	x的以 2 为底的对数。
`log10`(x, /[, out, where, casting, order, ...])	返回输入数组的以 10 为底的对数，逐元素操作。
`expm1`(x, /[, out, where, casting, order, ...])	计算数组中所有元素的`exp(x) - 1`。
`log1p`(x, /[, out, where, casting, order, ...])	返回输入数组加 1 后的自然对数，逐元素操作。
`sqrt`(x, /[, out, where, casting, order, ...])	返回数组的非负平方根，逐元素操作。
`square`(x, /[, out, where, casting, order, ...])	返回输入的逐元素平方。
`cbrt`(x, /[, out, where, casting, order, ...])	返回数组的立方根，逐元素操作。
`reciprocal`(x, /[, out, where, casting, ...])	返回参数的倒数，逐元素操作。
`gcd`(x1, x2, /[, out, where, casting, order, ...])	返回`\|x1\|`和`\|x2\|`的最大公约数
`lcm`(x1, x2, /[, out, where, casting, order, ...])	返回`\|x1\|`和`\|x2\|`的最小公倍数

提示

可选的输出参数可用于帮助您节省大型计算的内存。如果您的数组很大，复杂的表达式可能需要比绝对必要的更长的时间，因为会创建和（稍后）销毁临时计算空间。例如，表达式G = A * B + C等同于T1 = A * B; G = T1 + C; del T1。将更快地执行为G = A * B; add(G, C, G)，这与G = A * B; G += C相同。

三角函数

所有三角函数在需要角度时都使用弧度。度与弧度的比值为 (180^{\circ}/\pi)。

`sin`(x, /[, out, where, casting, order, ...])	正弦，逐元素计算。
`cos`(x, /[, out, where,��casting, order, ...])	余弦，逐元素计算。
`tan`(x, /[, out, where, casting, order, ...])	计算正切，逐元素计算。
`arcsin`(x, /[, out, where, casting, order, ...])	逆正弦，逐元素计算。
`arccos`(x, /[, out, where, casting, order, ...])	逆三角余弦，逐元素计算。
`arctan`(x, /[, out, where, casting, order, ...])	逆正切，逐元素计算。
`arctan2`(x1, x2, /[, out, where, casting, ...])	对`x1/x2`进行元素级别的反正切运算，正确选择象限。
`hypot`(x1, x2, /[, out, where, casting, ...])	给定直角三角形的“腿”，返回其斜边。
`sinh`(x, /[, out, where, casting, order, ...])	双曲正弦，逐元素计算。
`cosh`(x, /[, out, where, casting, order, ...])	双曲余弦，逐元素计算。
`tanh`(x, /[, out, where, casting, order, ...])	计算双曲正切，逐元素计算。
`arcsinh`(x, /[, out, where, casting, order, ...])	逆双曲正弦，逐元素计算。
`arccosh`(x, /[, out, where, casting, order, ...])	逆双曲余弦，逐元素计算。
`arctanh`(x, /[, out, where, casting, order, ...])	逆双曲正切，逐元素计算。
`degrees`(x, /[, out, where, casting, order, ...])	将角度从弧度转换为度。
`radians`(x, /[, out, where, casting, order, ...])	将角度从度转换为弧度。
`deg2rad`(x, /[, out, where, casting, order, ...])	将角度从度转换为弧度。
`rad2deg`(x, /[, out, where, casting, order, ...])	将角度从弧度转换为度。

位操作函数

这些函数都需要整数参数，并且会操作这些参数的位模式。

`bitwise_and`(x1, x2, /[, out, where, ...])	计算两个数组的按位 AND。
`bitwise_or`(x1, x2, /[, out, where, casting, ...])	计算两个数组的按位 OR。
`bitwise_xor`(x1, x2, /[, out, where, ...])	计算两个数组的按位异或。
`invert`(x, /[, out, where, casting, order, ...])	计算按位取反，或按位 NOT，逐元素进行。
`left_shift`(x1, x2, /[, out, where, casting, ...])	将整数的位向左移动。
`right_shift`(x1, x2, /[, out, where, ...])	将整数的位向右移动。

比较函数

`greater`(x1, x2, /[, out, where, casting, ...])	返回（x1 > x2）的逐元素真值。
`greater_equal`(x1, x2, /[, out, where, ...])	返回（x1 >= x2）的逐元素真值。
`less`(x1, x2, /[, out, where, casting, ...])	返回（x1 < x2）的逐元素真值。
`less_equal`(x1, x2, /[, out, where, casting, ...])	返回（x1 <= x2）的逐元素真值。
`not_equal`(x1, x2, /[, out, where, casting, ...])	返回（x1 != x2）的逐元素真值。
`equal`(x1, x2, /[, out, where, casting, ...])	返回（x1 == x2）的逐元素真值。

警告

不要使用 Python 关键字and和or来组合逻辑数组表达式。这些关键字将测试整个数组的真值（而不是逐元素如您所期望的）。请使用按位运算符&和|代替。

`logical_and`(x1, x2, /[, out, where, ...])	计算 x1 AND x2 的逐元素真值。
`logical_or`(x1, x2, /[, out, where, casting, ...])	计算 x1 OR x2 的逐元素真值。
`logical_xor`(x1, x2, /[, out, where, ...])	计算 x1 XOR x2 的逐元素真值。
`logical_not`(x, /[, out, where, casting, ...])	计算逐元素的 NOT x 的真值。

警告

位运算符 & 和 | 是执行逐元素数组比较的正确方式。确保你理解运算符优先级：(a > 2) & (a < 5) 是正确的语法，因为 a > 2 & a < 5 会导致错误，因为 2 & a 首先被计算。

`maximum`(x1, x2, /[, out, where, casting, ...])	数组元素的逐元素最大值。

提示

Python 函数 max() 会在一维数组上找到最大值，但是会使用较慢的序列接口。最大值 ufunc 的 reduce 方法要快得多。此外，max() 方法对于维数大于一的数组不会给出你可能期望的答案。最小值的 reduce 方法也允许你计算数组的总最小值。

`minimum`(x1, x2, /[, out, where, casting, ...])	数组元素的逐元素最小值。

警告

maximum(a, b) 的行为与 max(a, b) 不同。作为 ufunc，maximum(a, b) 对 a 和 b 执行逐元素比较，并根据两个数组中的哪个元素较大选择结果的每个元素。相反，max(a, b) 将对象 a 和 b 视为一个整体，查看 a > b 的（总体）真值，并使用它来返回 a 或 b（作为一个整体）。minimum(a, b) 和 min(a, b) 之间也存在类似的差异。

`fmax`(x1, x2, /[, out, where, casting, ...])	数组元素的逐元素最大值。
`fmin`(x1, x2, /[, out, where, casting, ...])	数组元素的逐元素最小值。

浮点函数

请记住，所有这些函数都是在数组上逐元素操作，返回一个数组输出。描述仅详细说明了单个操作。

`isfinite`(x, /[, out, where, casting, order, ...])	逐元素测试是否为有限值（既不是无穷大��不是非数字）。
`isinf`(x, /[, out, where, casting, order, ...])	逐元素测试是否为正无穷或负无穷。
`isnan`(x, /[, out, where, casting, order, ...])	逐元素测试是否为 NaN，并将结果作为布尔数组返回。
`isnat`(x, /[, out, where, casting, order, ...])	逐元素测试是否为 NaT（不是时间），并将结果作为布尔数组返回。
`fabs`(x, /[, out, where, casting, order, ...])	计算逐元素的绝对值。
`signbit`(x, /[, out, where, casting, order, ...])	返回元素为 True 的位置，其中 signbit 被设置（小于零）。
`copysign`(x1, x2, /[, out, where, casting, ...])	将 x1 的符号更改为 x2 的符号，��元素操作。
`nextafter`(x1, x2, /[, out, where, casting, ...])	返回 x1 朝向 x2 的下一个浮点值，逐元素操作。
`spacing`(x, /[, out, where, casting, order, ...])	返回 x 与最近相邻数字之间的距离。
`modf`(x[, out1, out2], / [[, out, where, ...])	返回数组的小数部分和整数部分，逐元素操作。
`ldexp`(x1, x2, /[, out, where, casting, ...])	返回 x1 * 2**x2，逐元素操作。
`frexp`(x[, out1, out2], / [[, out, where, ...])	将 x 的元素分解为尾数和二次幂。
`fmod`(x1, x2, /[, out, where, casting, ...])	返回除法的逐元素余数。
`floor`(x, /[, out, where, casting, order, ...])	返回输入的下限，逐元素操作。
`ceil`(x, /[, out, where, casting, order, ...])	返回输入的上限，逐元素操作。
`trunc`(x, /[, out, where, casting, order, ...])	返回输入的截断值，逐元素操作。

数学运算

`add`(x1, x2, /[, out, where, casting, order, ...])	逐元素相加。
`subtract`(x1, x2, /[, out, where, casting, ...])	逐元素相减。
`multiply`(x1, x2, /[, out, where, casting, ...])	逐元素相乘。
`matmul`(x1, x2, /[, out, casting, order, ...])	两个数组的矩阵乘积。
`divide`(x1, x2, /[, out, where, casting, ...])	逐元素相除。
`logaddexp`(x1, x2, /[, out, where, casting, ...])	对输入的指数求和的对数。
`logaddexp2`(x1, x2, /[, out, where, casting, ...])	以 2 为底对输入的指数求和的对数。
`true_divide`(x1, x2, /[, out, where, ...])	逐元素相除。
`floor_divide`(x1, x2, /[, out, where, ...])	返回输入的除法结果的最大整数部分。
`negative`(x, /[, out, where, casting, order, ...])	数值负数，逐元素操作。
`positive`(x, /[, out, where, casting, order, ...])	数值正数，逐元素操作。
`power`(x1, x2, /[, out, where, casting, ...])	将第一个数组的元素分别提升到第二个数组的幂，逐元素操作。
`float_power`(x1, x2, /[, out, where, ...])	将第一个数组的元素分别提升到第二个数组的幂，逐元素操作。
`remainder`(x1, x2, /[, out, where, casting, ...])	返回除法的逐元素余数。
`mod`(x1, x2, /[, out, where, casting, order, ...])	返回除法的逐元素余数。
`fmod`(x1, x2, /[, out, where, casting, ...])	返回除法的逐元素余数。
`divmod`(x1, x2[, out1, out2], / [[, out, ...])	同时返回逐元素商和余数。
`absolute`(x, /[, out, where, casting, order, ...])	计算逐元素的绝对值。
`fabs`(x, /[, out, where, casting, order, ...])	计算逐元素的绝对值。
`rint`(x, /[, out, where, casting, order, ...])	将数组元素四舍五入到最接近的整数。
`sign`(x, /[, out, where, casting, order, ...])	返回数值的逐元素符号指示。
`heaviside`(x1, x2, /[, out, where, casting, ...])	计算 Heaviside 阶跃函数。
`conj`(x, /[, out, where, casting, order, ...])	返回逐元素的复共轭。
`conjugate`(x, /[, out, where, casting, ...])	返回逐元素的复共轭。
`exp`(x, /[, out, where, casting, order, ...])	计算输入数组中所有元素的指数。
`exp2`(x, /[, out, where, casting, order, ...])	计算输入数组中所有 p 的 2p。
`log`(x, /[, out, where, casting, order, ...])	自然对数，逐元素操作。
`log2`(x, /[, out, where, casting, order, ...])	x 的以 2 为底的对数。
`log10`(x, /[, out, where, casting, order, ...])	返回输入数组的以 10 为底的对数，逐元素操作。
`expm1`(x, /[, out, where, casting, order, ...])	计算数组中所有元素的`exp(x) - 1`。
`log1p`(x, /[, out, where, casting, order, ...])	返回输入数组加一的自然对数，逐元素操作。
`sqrt`(x, /[, out, where, casting, order, ...])	返回数组的非负平方根，逐元素操作。
`square`(x, /[, out, where, casting, order, ...])	返回输入的逐元素平方。
`cbrt`(x, /[, out, where, casting, order, ...])	返回数组的立方根，逐元素操作。
`reciprocal`(x, /[, out, where, casting, ...])	返回参数的倒数，逐元素操作。
`gcd`(x1, x2, /[, out, where, casting, order, ...])	返回`\|x1\|`和`\|x2\|`的最大公约数
`lcm`(x1, x2, /[, out, where, casting, order, ...])	返回`\|x1\|`和`\|x2\|`的最小公倍数

提示

可选的输出参数可用于帮助您节省大型计算的内存。如果您的数组很大，复杂的表达式可能会因为创建和（后来）销毁临时计算��间而比绝对必要的时间长。例如，表达式 G = A * B + C 等同于 T1 = A * B; G = T1 + C; del T1。将更快地执行为 G = A * B; add(G, C, G)，这与 G = A * B; G += C 相同。

三角函数

所有三角函数在需要角度时使用弧度。度与弧度的比值为 (180^{\circ}/\pi)。

`sin`(x, /[, out, where, casting, order, ...])	正弦，逐元素操作。
`cos`(x, /[, out, where, casting, order, ...])	余弦，逐元素操作。
`tan`(x, /[, out, where, casting, order, ...])	计算正切，逐元素操作。
`arcsin`(x, /[, out, where, casting, order, ...])	反正弦，逐元素操作。
`arccos`(x, /[, out, where, casting, order, ...])	逐元素计算反余弦。
`arctan`(x, /[, out, where, casting, order, ...])	逐元素计算反正切。
`arctan2`(x1, x2, /[, out, where, casting, ...])	计算`x1/x2`的反正切，正确选择象限。
`hypot`(x1, x2, /[, out, where, casting, ...])	给定直角三角形的“腿”，返回其斜边。
`sinh`(x, /[, out, where, casting, order, ...])	双曲正弦，逐��素操作。
`cosh`(x, /[, out, where, casting, order, ...])	双曲余弦，逐元素操作。
`tanh`(x, /[, out, where, casting, order, ...])	计算双曲正切，逐元素操作。
`arcsinh`(x, /[, out, where, casting, order, ...])	逐元素计算反双曲正弦。
`arccosh`(x, /[, out, where, casting, order, ...])	逐元素计算反双曲余弦。
`arctanh`(x, /[, out, where, casting, order, ...])	逐元素计算反双曲正切。
`degrees`(x, /[, out, where, casting, order, ...])	将弧度转换为角度。
`radians`(x, /[, out, where, casting, order, ...])	将角度转换为弧度。
`deg2rad`(x, /[, out, where, casting, order, ...])	将角度转换为弧度。
`rad2deg`(x, /[, out, where, casting, order, ...])	将弧度转换为角度。

位操作函数

这些函数都需要整数参数，并操作这些参数的位模式。

`bitwise_and`(x1, x2, /[, out, where, ...])	计算两个数组的按位与。
`bitwise_or`(x1, x2, /[, out, where, casting, ...])	计算两个数组的按位或。
`bitwise_xor`(x1, x2, /[, out, where, ...])	计算两个数组的按位异或。
`invert`(x, /[, out, where, casting, order, ...])	计算按位反转，或按位 NOT，逐元素。
`left_shift`(x1, x2, /[, out, where, casting, ...])	将整数的位向左移动。
`right_shift`(x1, x2, /[, out, where, ...])	将整数的位向右移动。

比较函数

`greater`(x1, x2, /[, out, where, casting, ...])	返回(x1 > x2)的逐元素真值。
`greater_equal`(x1, x2, /[, out, where, ...])	返回(x1 >= x2)的逐元素真值。
`less`(x1, x2, /[, out, where, casting, ...])	返回(x1 < x2)的逐元素真值。
`less_equal`(x1, x2, /[, out, where, casting, ...])	返回(x1 <= x2)的逐元素真值。
`not_equal`(x1, x2, /[, out, where, casting, ...])	返回(x1 != x2)的逐元素真值。
`equal`(x1, x2, /[, out, where, casting, ...])	返回(x1 == x2)的逐元素真值。

警告

不要使用 Python 关键字and和or来组合逻辑数组表达式。这些关键字将测试整个数组的真值（而不是你可能期望的逐个元素）。请使用按位运算符&和|代替。

`logical_and`(x1, x2, /[, out, where, ...])	计算 x1 和 x2 的逐元素真值。
`logical_or`(x1, x2, /[, out, where, casting, ...])	计算 x1 或 x2 的逐元素真值。
`logical_xor`(x1, x2, /[, out, where, ...])	计算 x1 XOR x2 的逐元素真值。
`logical_not`(x, /[, out, where, casting, ...])	计算逐元素的 NOT x 的真值。

警告

按位运算符&和|是执行逐元素数组比较的正确方式。确保您理解运算符优先级：(a > 2) & (a < 5)是正确的语法，因为a > 2 & a < 5会导致错误，因为2 & a首先被计算。

`maximum`(x1, x2, /[, out, where, casting, ...])	数组元素的逐元素最大值。

提示

Python 函数 max() 将在一维数组上找到最大值，但是它将使用较慢的序列接口来执行。通用函数的 reduce 方法要快得多。此外，max() 方法对于维数大于一的数组不会给出您可能期望的答案。最小值的 reduce 方法还允许您计算数组的总最小值。

`minimum`(x1, x2, /[, out, where, casting, ...])	数组元素的逐元素最小值。

警告

maximum(a, b) 的行为与 max(a, b) 不同。作为一个通用函数，maximum(a, b) 对 a 和 b 进行逐元素比较，并根据两个数组中的哪个元素较大来选择结果的每个元素。相反，max(a, b) 将对象 a 和 b 视为一个整体，查看 a > b 的（总体）真值，并使用它来返回 a 或 b（作为一个整体）。minimum(a, b) 和 min(a, b) 之间也存在类似的差异。

`fmax`(x1, x2, /[, out, where, casting, ...])	数组元素的逐元素最大值。
`fmin`(x1, x2, /[, out, where, casting, ...])	数组元素的逐元素最小值。

浮点函数

所有这些函数都是对数组进行逐元素操作，返回一个数组输出。描述细节仅涉及单个操作。

`isfinite`(x, /[, out, where, casting, order, ...])	逐元素测试是否为有限数（既不是无穷大也不是非数）。
`isinf`(x, /[, out, where, casting, order, ...])	逐元素测试是否为正无穷或负无穷。
`isnan`(x, /[, out, where, casting, order, ...])	逐元素测试是否为 NaN，并将结果作为布尔数组返回。
`isnat`(x, /[, out, where, casting, order, ...])	逐元素测试是否为 NaT（不是时间），并将结果作为布尔数组返回。
`fabs`(x, /[, out, where, casting, order, ...])	计算元素的绝对值。
`signbit`(x, /[, out, where, casting, order, ...])	返回元素为 True 的逐元素位置，其中符号位设置为负（小于零）。
`copysign`(x1, x2, /[, out, where, casting, ...])	将 x1 的符号更改为 x2 的符号，逐元素进行。
`nextafter`(x1, x2, /[, out, where, casting, ...])	返回 x1 朝向 x2 的下一个浮点值，逐元素进行。
`spacing`(x, /[, out, where, casting, order, ...])	返回 x 与最近相邻数之间的距离。
`modf`(x[, out1, out2], / [[, out, where, ...])	返回数组的小数部分和整数部分，逐元素操作。
`ldexp`(x1, x2, /[, out, where, casting, ...])	返回 x1 * 2**x2，逐元素操作。
`frexp`(x[, out1, out2], / [[, out, where, ...])	将 x 的元素分解为尾数和二次指数。
`fmod`(x1, x2, /[, out, where, casting, ...])	返回除法的逐元素余数。
`floor`(x, /[, out, where, casting, order, ...])	返回输入的向下取整值，逐元素操作。
`ceil`(x, /[, out, where, casting, order, ...])	返回输入的向上取整值，逐元素操作。
`trunc`(x, /[, out, where, casting, order, ...])	返回输入的截断值，逐元素操作。

`numpy.ufunc`

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

class numpy.ufunc

在整个数组上逐元素操作的函数。

要查看特定 ufunc 的文档，请使用info。例如，np.info(np.sin)。因为 ufuncs 是用 C 语言编写的（为了速度）并通过 NumPy 的 ufunc 功能链接到 Python 中，所以当在 ufunc 上调用 help()时，Python 的 help()函数会找到这个页面。

在通用函数（ufunc）文档中可以找到对 ufunc 的详细解释。

调用 ufuncs： op(*x[, out], where=True, **kwargs)

对参数**x逐元素应用op*，广播参数。

广播规则为：

长度为 1 的维度可以添加到任一数组的前面。
数组可以沿着长度为 1 的维度重复。

参数：

*xarray_like

输入数组。

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

放置结果的替代数组对象；如果提供，它必须具有输入广播到的形状。数组的元组（仅作为关键字参数）的长度必须等于输出的数量；对于要由 ufunc 分配的未初始化输出，请使用 None。

wherearray_like，可选

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

**kwargs

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

rndarray 或 ndarray 的元组

r将具有数组x广播到的形状；如果提供了out，则将返回它。如果没有，则将分配r并可能包含未初始化的值。如果函数有多个输出，则结果将是数组的元组。

属性：

identity

标识值。

nargs

参数的数量。

nin

输入的数量。

nout

输出的数量。

ntypes

类型的数量。

signature

广义 ufunc 操作的核心元素的定义。

types

返回一个按输入->输出分组的类型列表。

方法

`__call__`(args, *kwargs)	作为函数调用自身。
`accumulate`(array[, axis, dtype, out])	累积将运算符应用于所有元素的结果。
`at`(a, indices[, b])	对由'indices'指定的元素在操作数'a'上执行无缓冲就地操作。
`outer`(A, B, /, **kwargs)	将 ufunc op 应用于所有(a, b)对，其中 a 在A中，b 在B中。
`reduce`(array[, axis, dtype, out, keepdims, ...])	通过沿着一个轴应用 ufunc 来减少`array`的维度。
`reduceat`(array, indices[, axis, dtype, out])	在单个轴上执行指定切片的（局部）reduce。
`resolve_dtypes`(dtypes, *[, signature, ...])	查找 NumPy 将用于操作的数据类型。

`numpy.ufunc.nin`

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

属性

ufunc.nin

输入的数量。

数据属性，包含 ufunc 将作为输入处理的参数数量。

示例

>>> np.add.nin
2
>>> np.multiply.nin
2
>>> np.power.nin
2
>>> np.exp.nin
1

`numpy.ufunc.nout`

numpy.org/doc/1.26/reference/generated/numpy.ufunc.nout.html

属性

ufunc.nout

输出的数量。

包含 ufunc 将作为输出处理的参数数量的数据属性。

注意事项

由于所有的 ufunc 都可以接受输出参数，这个值始终为（至少）1。

示例

>>> np.add.nout
1
>>> np.multiply.nout
1
>>> np.power.nout
1
>>> np.exp.nout
1

`numpy.ufunc.nargs`

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

attribute

ufunc.nargs

参数数量。

包含 ufunc 所需参数数量（包括可选参数）的数据属性。

Notes

通常，这个值会比你期望的多一个，因为所有的 ufunc 都会带有可选的“out”参数。

Examples

>>> np.add.nargs
3
>>> np.multiply.nargs
3
>>> np.power.nargs
3
>>> np.exp.nargs
2

`numpy.ufunc.ntypes`

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

属性

ufunc.ntypes

类型数量。

ufunc 可操作的数值 NumPy 类型数量，总共有 18 种。

另请参阅

numpy.ufunc.types

示例

>>> np.add.ntypes
18
>>> np.multiply.ntypes
18
>>> np.power.ntypes
17
>>> np.exp.ntypes
7
>>> np.remainder.ntypes
14

`numpy.ufunc.types`

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

属性

ufunc.types

返回一个按输入->输出分组的类型列表。

数据属性列出了 ufunc 可以提供的数据类型“域-范围”分组。数据类型使用字符代码给出。

另请参阅

numpy.ufunc.ntypes

示例

>>> np.add.types
['??->?', 'bb->b', 'BB->B', 'hh->h', 'HH->H', 'ii->i', 'II->I', 'll->l',
'LL->L', 'qq->q', 'QQ->Q', 'ff->f', 'dd->d', 'gg->g', 'FF->F', 'DD->D',
'GG->G', 'OO->O']

>>> np.multiply.types
['??->?', 'bb->b', 'BB->B', 'hh->h', 'HH->H', 'ii->i', 'II->I', 'll->l',
'LL->L', 'qq->q', 'QQ->Q', 'ff->f', 'dd->d', 'gg->g', 'FF->F', 'DD->D',
'GG->G', 'OO->O']

>>> np.power.types
['bb->b', 'BB->B', 'hh->h', 'HH->H', 'ii->i', 'II->I', 'll->l', 'LL->L',
'qq->q', 'QQ->Q', 'ff->f', 'dd->d', 'gg->g', 'FF->F', 'DD->D', 'GG->G',
'OO->O']

>>> np.exp.types
['f->f', 'd->d', 'g->g', 'F->F', 'D->D', 'G->G', 'O->O']

>>> np.remainder.types
['bb->b', 'BB->B', 'hh->h', 'HH->H', 'ii->i', 'II->I', 'll->l', 'LL->L',
'qq->q', 'QQ->Q', 'ff->f', 'dd->d', 'gg->g', 'OO->O']

`numpy.ufunc.identity`

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

属性

ufunc.identity

单位值。

包含 ufunc 的单位元素的数据属性，如果存在的话。如果不存在，则属性值为 None。

示例

>>> np.add.identity
0
>>> np.multiply.identity
1
>>> np.power.identity
1
>>> print(np.exp.identity)
None

`numpy.ufunc.signature`

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

属性

ufunc.signature

通用 ufunc 操作的核心元素的定义。

签名确定每个输入/输出数组的维度如何分割为核心和循环维度：

签名中的每个维度都与相应传入数组的维度匹配，从形状元组的末尾开始。
在签名中分配给相同标签的核心维度必须具有完全匹配的大小，不执行广播。
所有输入中的核心维度都被移除，剩余维度被一起广播，定义了循环维度。

注意

通用 ufunc 在许多 linalg 函数内部以及测试套件中使用；下面的示例取自这些函数。对于操作标量的 ufunc，签名为 None，这相当于每个参数都是‘()’。

示例

>>> np.core.umath_tests.matrix_multiply.signature
'(m,n),(n,p)->(m,p)'
>>> np.linalg._umath_linalg.det.signature
'(m,m)->()'
>>> np.add.signature is None
True  # equivalent to '(),()->()'

`numpy.ufunc.reduce`

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

方法

ufunc.reduce(array, axis=0, dtype=None, out=None, keepdims=False, initial=<no value>, where=True)

通过沿一个轴应用 ufunc，将array的维度减少一个。

让 (array.shape = (N_0, ..., N_i, ..., N_{M-1}))。那么 (ufunc.reduce(array, axis=i)[k_0, ..,k_{i-1}, k_{i+1}, .., k_{M-1}]) = 在 (range(N_i)) 上迭代 j，对每个 (array[k_0, ..,k_{i-1}, j, k_{i+1}, .., k_{M-1}]) 应用 ufunc 的累积结果。对于一维数组，reduce 产生等效于的结果：

r = op.identity # op = ufunc
for i in range(len(A)):
  r = op(r, A[i])
return r

例如，add.reduce() 等同于 sum()。

参数：

array类似数组

要操作的数组。

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

执行缩减的轴或轴。默认值（axis = 0）是在输入数组的第一个维度上执行缩减。axis可以是负数，此时从最后一个轴到第一个轴计数。

1.7.0 版本中的新功能。

如果这是 None，则在所有轴上执行缩减。如果这是整数元组，则在多个轴上执行缩减，而不是像以前那样在单个轴或所有轴上执行缩减。

对于不可交换或不可结合的操作，对多个轴进行缩减是没有明确定义的。ufuncs 目前在这种情况下不会引发异常，但将来可能会这样做。

dtype数据类型代码，可选

用于表示中间结果的类型。如果提供了输出数组，则默认为输出数组的数据类型，如果没有提供输出数组，则默认为输入数组的数据类型。

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

存储结果的位置。如果未提供或为 None，则返回一个新分配的数组。为了与ufunc.__call__保持一致，如果作为关键字给出，则可能会被包装在一个包含 1 个元素的元组中。

1.13.0 版本中的更改：允许关键字参数为元组。

keepdims布尔值，可选

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

1.7.0 版本中的新功能。

initial标量，可选

用于开始缩减的值。如果 ufunc 没有身份或 dtype 为对象，则默认为 None - 否则默认为 ufunc.identity。如果给定None，则使用缩减的第一个元素，如果缩减为空，则抛出错误。

1.15.0 版本中的新功能。

where布尔值数组，可选

一个布尔数组，广播以匹配array的维度，并选择要包含在缩减中的元素。请注意，对于像minimum这样没有定义身份的 ufunc，还必须传入initial。

1.17.0 版本中的新功能。

rndarray

减少后的数组。如果提供了out，r是它的引用。

示例

>>> np.multiply.reduce([2,3,5])
30

一个多维数组的示例：

>>> X = np.arange(8).reshape((2,2,2))
>>> X
array([[[0, 1],
 [2, 3]],
 [[4, 5],
 [6, 7]]])
>>> np.add.reduce(X, 0)
array([[ 4,  6],
 [ 8, 10]])
>>> np.add.reduce(X) # confirm: default axis value is 0
array([[ 4,  6],
 [ 8, 10]])
>>> np.add.reduce(X, 1)
array([[ 2,  4],
 [10, 12]])
>>> np.add.reduce(X, 2)
array([[ 1,  5],
 [ 9, 13]])

您可以使用initial关键字参数来使用不同的值初始化减少操作，并使用where来选择要包括的特定元素：

>>> np.add.reduce([10], initial=5)
15
>>> np.add.reduce(np.ones((2, 2, 2)), axis=(0, 2), initial=10)
array([14., 14.])
>>> a = np.array([10., np.nan, 10])
>>> np.add.reduce(a, where=~np.isnan(a))
20.0

允许对空数组进行减少操作，而通常它们会失败，即对于没有身份的 ufuncs。

>>> np.minimum.reduce([], initial=np.inf)
inf
>>> np.minimum.reduce([[1., 2.], [3., 4.]], initial=10., where=[True, False])
array([ 1., 10.])
>>> np.minimum.reduce([])
Traceback (most recent call last):
  ...
ValueError: zero-size array to reduction operation minimum which has no identity

`numpy.ufunc.accumulate`

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

方法

ufunc.accumulate(array, axis=0, dtype=None, out=None)

累积将操作符应用于所有元素的结果。

对于一维数组，累积产生等效于的结果：

r = np.empty(len(A))
t = op.identity        # op = the ufunc being applied to A's  elements
for i in range(len(A)):
    t = op(t, A[i])
    r[i] = t
return r

例如，add.accumulate() 等同于 np.cumsum()。

对于多维数组，累积仅沿一个轴应用（默认为轴零；请参见下面的示例），因此如果想要沿多个轴累积，则需要重复使用。

参数：

arrayarray_like

要操作的数组。

axisint，可选

应用累积的轴；默认为零。

dtype数据类型代码，可选

用于表示中间结果的数据类型。如果提供了输出数组，则默认为输出数组的数据类型，如果未提供输出数组，则默认为输入数组的数据类型。

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

存储结果的位置。如果未提供或为 None，则返回一个新分配的数组。为了与ufunc.__call__保持一致，如果作为关键字给出，可能会被包装在一个包含 1 个元素的元组中。

从版本 1.13.0 更改：允许关键字参数为元组。

rndarray

累积的值。如果提供了out，r是out的引用。

示例

1-D 数组示例：

>>> np.add.accumulate([2, 3, 5])
array([ 2,  5, 10])
>>> np.multiply.accumulate([2, 3, 5])
array([ 2,  6, 30])

2-D 数组示例：

>>> I = np.eye(2)
>>> I
array([[1.,  0.],
 [0.,  1.]])

沿轴 0（行）累积，向下列：

>>> np.add.accumulate(I, 0)
array([[1.,  0.],
 [1.,  1.]])
>>> np.add.accumulate(I) # no axis specified = axis zero
array([[1.,  0.],
 [1.,  1.]])

沿轴 1（列）累积，通过行：

>>> np.add.accumulate(I, 1)
array([[1.,  1.],
 [0.,  1.]])

`numpy.ufunc.reduceat`

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

方法

ufunc.reduceat(array, indices, axis=0, dtype=None, out=None)

在单个轴上使用指定切片进行（局部）约简。

对于range(len(indices))中的 i，reduceat计算ufunc.reduce(array[indices[i]:indices[i+1]])，这成为最终结果中与axis平行的第 i 个广义“行”（即，在 2-D 数组中，例如，如果axis = 0，它成为第 i 行，但如果axis = 1，它成为第 i 列）。有三个例外情况：

当i = len(indices) - 1（即对于最后一个索引），indices[i+1] = array.shape[axis]。
如果indices[i] >= indices[i + 1]，则第 i 个广义“行”就是array[indices[i]。
如果indices[i] >= len(array)或indices[i] < 0，则会引发错误。

输出的形状取决于indices的大小，并且可能比array大（如果len(indices) > array.shape[axis]）。

参数：

array类似数组

要操作的数组。

indices类似数组

配对的索引，逗号分隔（而不是冒号），指定要约简的切片。

axis整数，可选

应用reduceat的轴。

dtype数据类型代码，可选

用于表示中间结果的类型。如果提供了输出数组，则默认为输出数组的数据类型，如果未提供输出数组，则为输入数组的数据类型。

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

存储结果的位置。如果未提供或为 None，则返回一个新分配的数组。为了与ufunc.__call__保持一致，如果作为关键字给出，则可以将其包装在一个 1 元组中。

在版本 1.13.0 中更改：允许关键字参数为元组。

rndarray

约简的值。如果提供了out，r是out的引用。

注意

一个描述性示例：

如果array是 1-D，则函数ufunc.accumulate(array)与ufunc.reduceat(array, indices)[::2]相同，其中indices为range(len(array) - 1)，并在每隔一个元素中放置零：indices = zeros(2 * len(array) - 1)，indices[1::2] = range(1, len(array))。

不要被这个属性的名称所迷惑：reduceat(array)不一定比array小。

示例

要对四个连续值进行累加：

>>> np.add.reduceat(np.arange(8),[0,4, 1,5, 2,6, 3,7])[::2]
array([ 6, 10, 14, 18])

一个 2-D 示例：

>>> x = np.linspace(0, 15, 16).reshape(4,4)
>>> x
array([[ 0.,   1.,   2.,   3.],
 [ 4.,   5.,   6.,   7.],
 [ 8.,   9.,  10.,  11.],
 [12.,  13.,  14.,  15.]])

# reduce such that the result has the following five rows:
# [row1 + row2 + row3]
# [row4]
# [row2]
# [row3]
# [row1 + row2 + row3 + row4]

>>> np.add.reduceat(x, [0, 3, 1, 2, 0])
array([[12.,  15.,  18.,  21.],
 [12.,  13.,  14.,  15.],
 [ 4.,   5.,   6.,   7.],
 [ 8.,   9.,  10.,  11.],
 [24.,  28.,  32.,  36.]])

# reduce such that result has the following two columns:
# [col1 * col2 * col3, col4]

>>> np.multiply.reduceat(x, [0, 3], 1)
array([[   0.,     3.],
 [ 120.,     7.],
 [ 720.,    11.],
 [2184.,    15.]])

`numpy.ufunc.outer`

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

方法

ufunc.outer(A, B, /, **kwargs)

将 ufunc op应用于所有(a, b)对，其中 a 在A中，b 在B中。

让M = A.ndim，N = B.ndim。那么op.outer(A, B)的结果C是一个维度为 M + N 的数组，使得：

[C[i_0, ..., i_{M-1}, j_0, ..., j_{N-1}] = op(A[i_0, ..., i_{M-1}], B[j_0, ..., j_{N-1}])]

对于一维的A和B，这等同于：

r = empty(len(A),len(B))
for i in range(len(A)):
    for j in range(len(B)):
        r[i,j] = op(A[i], B[j])  # op = ufunc in question

参数：

Aarray_like

第一个数组

Barray_like

第二个数组

kwargs任意

传递给 ufunc 的参数。通常是dtype或out。查看ufunc以获取所有可用参数的全面概述。

rndarray

输出数组

另请参阅

numpy.outer

一个比np.multiply.outer弱的版本，将所有输入展平为 1D。这主要是为了与旧代码兼容而存在。

tensordot

np.tensordot(a, b, axes=((), ()))和np.multiply.outer(a, b)对于 a 和 b 的所有维度行为相同。

示例

>>> np.multiply.outer([1, 2, 3], [4, 5, 6])
array([[ 4,  5,  6],
 [ 8, 10, 12],
 [12, 15, 18]])

多维示例：

>>> A = np.array([[1, 2, 3], [4, 5, 6]])
>>> A.shape
(2, 3)
>>> B = np.array([[1, 2, 3, 4]])
>>> B.shape
(1, 4)
>>> C = np.multiply.outer(A, B)
>>> C.shape; C
(2, 3, 1, 4)
array([[[[ 1,  2,  3,  4]],
 [[ 2,  4,  6,  8]],
 [[ 3,  6,  9, 12]]],
 [[[ 4,  8, 12, 16]],
 [[ 5, 10, 15, 20]],
 [[ 6, 12, 18, 24]]]])

`numpy.ufunc.at`

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

方法

ufunc.at(a, indices, b=None, /)

对由“indices”指定的元素在操作数‘a’上执行无缓冲原地操作。对于加法 ufunc，此方法等效于a[indices] += b，只是对于多次索引的元素进行了累积。例如，a[[0,0]] += 1由于缓冲只会增加第一个元素一次，而add.at(a, [0,0], 1)会增加第一个元素两次。

自版本 1.8.0 起新增。

参数：

a类似数组

执行原地操作的数组。

indices类似数组或元组

类似数组索引对象或切片对象，用于对第一个操作数进行索引。如果第一个操作数具有多个维度，则索引可以是类似数组索引对象或切片对象的元组。

b类似数组

需要两个操作数的 ufunc 的第二个操作数。在索引或切片后，操作数必须能够广播到第一个操作数。

示例

将第 0 和第 1 项设置为它们的负值：

>>> a = np.array([1, 2, 3, 4])
>>> np.negative.at(a, [0, 1])
>>> a
array([-1, -2,  3,  4])

增加第 0 和第 1 项，并将第 2 项增加两次：

>>> a = np.array([1, 2, 3, 4])
>>> np.add.at(a, [0, 1, 2, 2], 1)
>>> a
array([2, 3, 5, 4])

将第一个数组中的第 0 和第 1 项加到第二个数组中，并将结果存储在第一个数组中：

>>> a = np.array([1, 2, 3, 4])
>>> b = np.array([1, 2])
>>> np.add.at(a, [0, 1], b)
>>> a
array([2, 4, 3, 4])

例程

原文：numpy.org/doc/1.26/reference/routines.html

在本章中，例程文档字符串按功能分组呈现。许多文档字符串包含示例代码，演示了例程的基本用法。这些示例假定 NumPy 已导入：

>>> import numpy as np

一个方便的执行示例的方法是使用 IPython 的 %doctest_mode 模式，允许粘贴多行示例并保留缩进。

数组创建例程
- 从形状或值创建
- 从现有数据创建
- 创建记录数组 (numpy.rec)
- 创建字符数组 (numpy.char)
- 数值范围
- 构建矩阵
- 矩阵类
数组操作例程
- 基本操作
- 改变数组形状
- 类似转置的操作
- 改变维度数量
- 改变数组类型
- 连接数组
- 分割数组
- 平铺数组
- 添加和移除元素
- 重新排列元素
二进制操作
- 逐元素位操作
- 位打包
- 输出格式化
字符串操作
- 字符串操作
- 比较
- 字符串信息
- 便利类
C-Types 外部函数接口 (numpy.ctypeslib)
- as_array
- as_ctypes
- as_ctypes_type
- load_library
- ndpointer
- c_intp
日期时间支持函数
- numpy.datetime_as_string
- numpy.datetime_data
- 工作日函数
数据类型例程
- numpy.can_cast
- numpy.promote_types
- numpy.min_scalar_type
- numpy.result_type
- numpy.common_type
- numpy.obj2sctype
- 创建数据类型
- 数据类型信息
- 数据类型测试
- 杂项
具有自动域的数学函数
- 函数
浮点错误处理
- 设置和获取错误处理
- 内部函数
离散傅立叶变换（numpy.fft）
- 标准 FFT
- 实数 FFT
- Hermitian FFTs
- 辅助例程
- 背景信息
- 实现细节
- 类型提升
- 归一化
- 实数和 Hermitian 变换
- 更高维度
- 参考资料
- 示例
函数式编程
- numpy.apply_along_axis
- numpy.apply_over_axes
- numpy.vectorize
- numpy.frompyfunc
- numpy.piecewise
NumPy 特定的帮助函数
- 查找帮助
- 阅读帮助
输入和输出
- NumPy 二进制文件（NPY，NPZ）
- 文本文件
- 原始二进制文件
- 字符串格式化
- 内存映射文件
- 文本格式选项
- 基数-n 表示
- 数据源
- 二进制格式描述
线性代数（numpy.linalg）
- @ 运算符
- 矩阵和向量乘积
- 分解
- 矩阵特征值
- 范数和其他数字
- 解方程和矩阵求逆
- 异常
- 同时对多个矩阵进行线性代数运算
逻辑函数
- 真值测试
- 数组内容
- 数组类型测试
- 逻辑运算
- 比较
掩码数组操作
- 常数
- 创建
- 检查数组
- 操作 MaskedArray
- 掩码操作
- 转换操作
- 掩码数组算术
数学函数
- 三角函数
- 双曲函数
- 四舍五入
- 求和、乘积、差异
- 指数和对数
- 其他特殊函数
- 浮点数例程
- 有理例程
- 算术运算
- 处理复数
- 极值查找
- 杂项
矩阵库（numpy.matlib）
- numpy.matlib.empty
- numpy.matlib.zeros
- numpy.matlib.ones
- numpy.matlib.eye
- numpy.matlib.identity
- numpy.matlib.repmat
- numpy.matlib.rand
- numpy.matlib.randn
杂项例程
- 性能调优
- 内存范围
- 数组混合
- NumPy 版本比较
- 实用工具
- 类似 Matlab 的函数
填充数组
- numpy.pad
多项式
- 从numpy.poly1d过渡到numpy.polynomial
- 多项式包文档
- 传统多项式文档
随机抽样（numpy.random）
- 快速开始
- 设计
- 概念
- 特性
集合例程
- numpy.lib.arraysetops
- 创建适当的集合
- 布尔运算
排序、搜索和计数
- 排序
- 搜索
- 计数
统计
- 顺序统计
- 平均值和方差
- 相关性
- 直方图
测试支持（numpy.testing）
- 断言
- 断言（不推荐）
- 装饰器
- 测试运行
- 指南
支持测试覆盖（numpy.testing.overrides）
- 实用函数
窗口函数
- 各种窗口函数

数组创建例程

原文：numpy.org/doc/1.26/reference/routines.array-creation.html

From shape or value

`empty`(shape[, dtype, order, like])	返回一个给定形状和类型的新数组，但不初始化条目。
`empty_like`(prototype[, dtype, order, subok, ...])	返回一个与给定数组具有相同形状和类型的新数组。
`eye`(N[, M, k, dtype, order, like])	返回一个二维数组，对角线上为 1，其他地方为 0。
`identity`(n[, dtype, like])	返回单位矩阵。
`ones`(shape[, dtype, order, like])	返回一个给定形状和类型的新数组，填充为 1。
`ones_like`(a[, dtype, order, subok, shape])	返回一个与给定数组具有相同形状和类型的全 1 数组。
`zeros`(shape[, dtype, order, like])	返回一个给定形状和类型的新数组，填充为零。
`zeros_like`(a[, dtype, order, subok, shape])	返回一个与给定数组具有相同形状和类型的零数组。
`full`(shape, fill_value[, dtype, order, like])	返回一个给定形状和类型的新数组，填充为fill_value。
`full_like`(a, fill_value[, dtype, order, ...])	返回一个与给定数组具有相同形状和类型的全数组。

From existing data

`array`(object[, dtype, copy, order, subok, ...])	创建一个数组。
`asarray`(a[, dtype, order, like])	将输入转换为数组。
`asanyarray`(a[, dtype, order, like])	将输入转换为 ndarray，但通过 ndarray 子类。
`ascontiguousarray`(a[, dtype, like])	返回一个在内存中连续的数组（ndim >= 1）（C 顺序）。
`asmatrix`(data[, dtype])	将输入解释为矩阵。
`copy`(a[, order, subok])	返回给定对象的数组副本。
`frombuffer`(buffer[, dtype, count, offset, like])	将缓冲区解释为一维数组。
`from_dlpack`(x, /)	从实现`__dlpack__`协议的对象创建一个 NumPy 数组。
`fromfile`(file[, dtype, count, sep, offset, like])	从文本或二进制文件中的数据构造一个数组。
`fromfunction`(function, shape, *[, dtype, like])	通过在每个坐标上执行函数来构造一个数组。
`fromiter`(iter, dtype[, count, like])	从可迭代对象创建一个新的一维数组。
`fromstring`(string[, dtype, count, like])	从字符串中的文本数据初始化一个新的一维数组。
`loadtxt`(fname[, dtype, comments, delimiter, ...])	从文本文件中加载数据。

创建记录数组 (`numpy.rec`)

注意

numpy.rec 是numpy.core.records的首选别名。

`core.records.array`(obj[, dtype, shape, ...])	从各种对象构造一个记录数组。
`core.records.fromarrays`(arrayList[, dtype, ...])	从（扁平化的）数组列表创建一个记录数组
`core.records.fromrecords`(recList[, dtype, ...])	从文本形式的记录列表创建一个 recarray。
`core.records.fromstring`(datastring[, dtype, ...])	从二进制数据创建一个记录数组

| core.records.fromfile(fd[, dtype, shape, ...]) | 从二进制文件数据创建一个数组 | ## 创建字符数组 (numpy.char)

注意

numpy.char 是numpy.core.defchararray的首选别名。

`core.defchararray.array`(obj[, itemsize, ...])	创建一个`chararray`。
`core.defchararray.asarray`(obj[, itemsize, ...])	将输入转换为`chararray`，仅在必要时复制数据。

数值范围

`arange`([start,] stop[, step,][, dtype, like])	返回给定区间内均匀间隔的值。
`linspace`(start, stop[, num, endpoint, ...])	返回指定区间内均匀间隔的数字。
`logspace`(start, stop[, num, endpoint, base, ...])	在对数刻度上均匀间隔的数字。
`geomspace`(start, stop[, num, endpoint, ...])	在对数刻度上均匀间隔的数字（几何级数）。
`meshgrid`(*xi[, copy, sparse, indexing])	从坐标向量返回坐标矩阵的列表。
`mgrid`	返回一个密集的多维“网格”。
`ogrid`	返回一个开放的多维“网格”。

构建矩阵

`diag`(v[, k])	提取对角线或构造对角线数组。
`diagflat`(v[, k])	使用输入的扁平化内容创建一个二维数组作为对角线。
`tri`(N[, M, k, dtype, like])	对角线及其以下为 1，其他位置为 0 的数组。
`tril`(m[, k])	数组的下三角。
`triu`(m[, k])	数组的上三角。
`vander`(x[, N, increasing])	生成一个范德蒙德矩阵。

矩阵类

`mat`(data[, dtype])	将输入解释为矩阵。
`bmat`(obj[, ldict, gdict])	从字符串、嵌套序列或数组构建矩阵对象。

来自形状或值

`empty`(shape[, dtype, order, like])	返回给定形状和类型的新数组，但不初始化条目。
`empty_like`(prototype[, dtype, order, subok, ...])	返回与给定数组相同形状和类型的新数组。
`eye`(N[, M, k, dtype, order, like])	返回一个对角线为 1，其他位置为 0 的二维数组。
`identity`(n[, dtype, like])	返回单位矩阵。
`ones`(shape[, dtype, order, like])	返回一个给定形状和类型的新数组，填充为 1。
`ones_like`(a[, dtype, order, subok, shape])	返回一个与给定数组相同形状和类型的全为 1 的数组。
`zeros`(shape[, dtype, order, like])	返回一个给定形状和类型的新数组，填充为 0。
`zeros_like`(a[, dtype, order, subok, shape])	返回一个与给定数组相同形状和类型的全为 0 的数组。
`full`(shape, fill_value[, dtype, order, like])	返回一个给定形状和类型的新数组，填充为fill_value。
`full_like`(a, fill_value[, dtype, order, ...])	返回一个与给定数组相同形状和类型的全为指定值的数组。

从现有数据

`array`(object[, dtype, copy, order, subok, ...])	创建一个数组。
`asarray`(a[, dtype, order, like])	将输入转换为数组。
`asanyarray`(a[, dtype, order, like])	将输入转换为 ndarray，但通过 ndarray 子类。
`ascontiguousarray`(a[, dtype, like])	返回一个在内存中连续的数组（ndim >= 1）（C 顺序）。
`asmatrix`(data[, dtype])	将输入解释为矩阵。
`copy`(a[, order, subok])	返回给定对象的数组副本。
`frombuffer`(buffer[, dtype, count, offset, like])	将缓冲区解释为一维数组。
`from_dlpack`(x, /)	从实现`__dlpack__`协议的对象创建一个 NumPy 数组。
`fromfile`(file[, dtype, count, sep, offset, like])	从文本或二进制文件中的数据构造数组。
`fromfunction`(function, shape, *[, dtype, like])	通过在每个坐标上执行函数来构造数组。
`fromiter`(iter, dtype[, count, like])	从可迭代对象创建一个新的一维数组。
`fromstring`(string[, dtype, count, like])	从字符串中的文本数据初始化一个新的一维数组。
`loadtxt`(fname[, dtype, comments, delimiter, ...])	从文本文件加载数据。

创建记录数组（`numpy.rec`）

注意

numpy.rec 是 numpy.core.records 的首选别名。

`core.records.array`(obj[, dtype, shape, ...])	从各种对象构造一个记录数组。
`core.records.fromarrays`(arrayList[, dtype, ...])	从（扁平化的）数组列表创建一个记录数组
`core.records.fromrecords`(recList[, dtype, ...])	从文本形式的记录列表创建一个记录数组。
`core.records.fromstring`(datastring[, dtype, ...])	从二进制数据创建一个记录数组
`core.records.fromfile`(fd[, dtype, shape, ...])	从二进制文件数据创建一个数组

创建字符数组（`numpy.char`）

注意

numpy.char 是 numpy.core.defchararray 的首选别名。

`core.defchararray.array`(obj[, itemsize, ...])	创建一个`chararray`。
`core.defchararray.asarray`(obj[, itemsize, ...])	将输入转换为`chararray`，仅在必要时复制数据。

数值范围

`arange`([start,] stop[, step,][, dtype, like])	在给定区间内返回均匀间隔的值。
`linspace`(start, stop[, num, endpoint, ...])	返回在指定区间上均匀间隔的数字。
`logspace`(start, stop[, num, endpoint, base, ...])	返回在对数刻度上均匀间隔的数字。
`geomspace`(start, stop[, num, endpoint, ...])	在对数刻度上均匀间隔的数字（几何级数）。
`meshgrid`(*xi[, copy, sparse, indexing])	从坐标向量返回坐标矩阵的列表。
`mgrid`	返回一个密集的多维“网格”。
`ogrid`	返回一个开放的多维“网格”。

构建矩阵

`diag`(v[, k])	提取对角线或构造对角线数组。
`diagflat`(v[, k])	创建一个以输入展平数组为对角线的二维数组。
`tri`(N[, M, k, dtype, like])	在给定对角线及其以下位置为 1，其他位置为 0 的数组。
`tril`(m[, k])	数组的下三角。
`triu`(m[, k])	数组的上三角。
`vander`(x[, N, increasing])	生成一个范德蒙德矩阵。

矩阵类

`mat`(data[, dtype])	将输入解释为矩阵。
`bmat`(obj[, ldict, gdict])	从字符串、嵌套序列或数组构建一个矩阵对象。

`numpy.empty`

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

numpy.empty(shape, dtype=float, order='C', *, like=None)

返回一个给定形状和类型的新数组，而不初始化条目。

参数：

shapeint 或 int 元组

空数组的形状，例如，(2, 3)或2。

dtype数据类型，可选

数组的期望输出数据类型，例如，numpy.int8。默认为numpy.float64。

order，可选，默认值：‘C’

决定是否以行主要（C 风格）或列主要（Fortran 风格）顺序存储多维数据在内存中。

likearray_like，可选

参考对象，允许创建不是 NumPy 数组的数组。如果传入 like 的类似数组支持 __array_function__ 协议，则结果将由它定义。在这种情况下，它确保创建一个与通过此参数传入的对象兼容的数组对象。

1.20.0 版中的新内容。

outndarray

未初始化（任意）数据的给定形状、dtype 和顺序的数组。对象数组将初始化为 None。

另请参阅

返回一个形状和输入类型的空数组。

返回一个将值设置为一的新数组。

返回一个将值设置为零的新数组。

返回一个给定形状并填充值的新数组。

注意

empty，与zeros不同，不会将数组值设置为零，因此可能稍微更快。另一方面，需要用户手动设置数组中的所有值，应谨慎使用。

示例

>>> np.empty([2, 2])
array([[ -9.74499359e+001,   6.69583040e-309],
 [  2.13182611e-314,   3.06959433e-309]])         #uninitialized

>>> np.empty([2, 2], dtype=int)
array([[-1073741821, -1067949133],
 [  496041986,    19249760]])                     #uninitialized

`numpy.empty_like`

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

numpy.empty_like(prototype, dtype=None, order='K', subok=True, shape=None)

返回一个具有与给定数组相同形状和类型的新数组。

参数：

原型array_like

原型的形状和数据类型定义了返回数组的相同属性。

数据类型数据类型，可选

覆盖结果的数据类型。

自版本 1.6.0 起新增。

顺序，可选

覆盖结果的内存布局。‘C’表示 C 顺序，‘F’表示 F 顺序，‘A’表示如果原型是 Fortran 连续的，则为‘F’，否则为‘C’。‘K’表示尽可能与原型的布局匹配。

自版本 1.6.0 起新增。

subokbool，可选。

如果为 True，则新创建的数组将使用原型的子类类型，否则将是基类数组。默认为 True。

形状int 或 int 序列，可选。

覆盖结果的形状。如果 order=’K’且维数不变，则尝试保持顺序，否则，暗示 order=’C’。

自版本 1.17.0 起新增。

输出ndarray

具有与原型相同形状和类型的未初始化（任意）数据的数组。

参见

ones_like

返回一个具有输入形状和类型的零数组。

zeros_like

返回一个具有输入形状和类型的零数组。

full_like的输出

返回一个具有输入形状并填充值的新数组。

empty

返回一个新的未初始化数组。

注意

此函数不初始化返回的数组；要做到这一点，请使用zeros_like或ones_like。它可能比设置数组值的函数稍微快一些。

示例

>>> a = ([1,2,3], [4,5,6])                         # a is array-like
>>> np.empty_like(a)
array([[-1073741821, -1073741821,           3],    # uninitialized
 [          0,           0, -1073741821]])
>>> a = np.array([[1., 2., 3.],[4.,5.,6.]])
>>> np.empty_like(a)
array([[ -2.00000715e+000,   1.48219694e-323,  -2.00000572e+000], # uninitialized
 [  4.38791518e-305,  -2.00000715e+000,   4.17269252e-309]])

`numpy.eye`

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

numpy.eye(N, M=None, k=0, dtype=<class 'float'>, order='C', *, like=None)

返回一个二维数组，对角线上为 1，其他位置为 0。

参数：

Nint

输出中的行数。

Mint，可选

输出中的列数。如果为 None，则默认为N。

kint，可选

对角线的索引：0（默认）指的是主对角线，正值指的是上对角线，负值指的是下对角线。

dtype数据类型，可选

返回数组的数据类型。

order，可选

输出是否应以行主序（C 风格）或列主序（Fortran 风格）存储在内存中。

新版本为 1.14.0。

likearray_like，可选

参考对象，允许创建不是 NumPy 数组的数组。如果传入的类似数组支持__array_function__协议，则结果将由它定义。在这种情况下，它确保创建一个与通过此参数传入的对象兼容的数组对象。

新版本为 1.20.0。

Indarray，形状为(N,M)

一个数组，其中所有元素都等于零，除了第k个对角线，其值等于一。

另请参阅

identity

（几乎）等效函数

diag

从用户指定的一维数组生成对角线二维数组。

示例

>>> np.eye(2, dtype=int)
array([[1, 0],
 [0, 1]])
>>> np.eye(3, k=1)
array([[0.,  1.,  0.],
 [0.,  0.,  1.],
 [0.,  0.,  0.]])

`numpy.identity`

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

numpy.identity(n, dtype=None, *, like=None)

返回单位矩阵。

单位矩阵是一个主对角线上为 1 的方阵。

参数：

nint

n x n 输出中的行数（和列数）。

dtype数据类型，可选

输出的数据类型。默认为float。

likearray_like，可选

参考对象，允许创建不是 NumPy 数组的数组。如果传入like的类似数组支持__array_function__协议，则结果将由它定义。在这种情况下，它确保创建一个与通过此参数传入的数组兼容的数组对象。

新版本 1.20.0 中新增。

outndarray

n x n 数组，其主对角线设置为 1，所有其他元素为 0。

示例

>>> np.identity(3)
array([[1.,  0.,  0.],
 [0.,  1.,  0.],
 [0.,  0.,  1.]])

`numpy.ones`

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

numpy.ones(shape, dtype=None, order='C', *, like=None)

返回一个给定形状和类型的新数组，填充为 1。

参数：

shapeint 或 int 序列

新数组的形状，例如，(2, 3)或2。

dtype数据类型，可选

数组的期望数据类型，例如，numpy.int8。默认为numpy.float64。

order，可选，默认为：C

决定在内存中以行主要（C 风格）或列主要（Fortran 风格）顺序存储多维数据。

likearray_like，可选

参考对象，允许创建不是 NumPy 数组的数组。如果传入like的类似数组支持__array_function__协议，则结果将由它定义。在这种情况下，它确保创建一个与通过此参数传入的对象兼容的数组对象。

新版本 1.20.0 中新增。

outndarray

具有给定形状、dtype 和顺序的全 1 数组。

参见

ones_like

返回一个形状和输入类型相同的全 1 数组。

empty

返回一个新的未初始化数组。

zeros

返回一个将值设置为零的新数组。

full

返回一个给定形状填充为指定值的新数组。

示例

>>> np.ones(5)
array([1., 1., 1., 1., 1.])

>>> np.ones((5,), dtype=int)
array([1, 1, 1, 1, 1])

>>> np.ones((2, 1))
array([[1.],
 [1.]])

>>> s = (2,2)
>>> np.ones(s)
array([[1.,  1.],
 [1.,  1.]])

`numpy.ones_like`

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

numpy.ones_like(a, dtype=None, order='K', subok=True, shape=None)

返回一个形状和类型与给定数组相同的 1 数组。

参数：

a类似数组

a的形状和数据类型定义了返回数组的相同属性。

dtype数据类型，可选

覆盖结果的数据类型。

版本 1.6.0 中新增。

order，可选

覆盖结果的内存布局。‘C’表示 C 顺序，‘F’表示 F 顺序，‘A’表示如果a是 Fortran 连续的则为‘F’，否则为‘C’。‘K’表示尽可能与a的布局匹配。

版本 1.6.0 中新增。

subok布尔值，可选。

如果为 True，则新创建的数组将使用a的子类类型，否则将是基类数组。默认为 True。

shapeint 或 int 序列，可选。

覆盖结果的形状。如果 order=’K’且维数不变，则尝试保持顺序，否则，暗示 order=’C’。

版本 1.17.0 中新增。

outndarray

具有与a相同形状和类型的 1 数组。

另请参阅

empty_like

返回一个形状和输入类型相同的空数组。

zeros_like

返回一个形状和输入类型相同的零数组。

full_like

返回一个形状与输入相同且填充有值的新数组。

ones

返回一个将值设置为 1 的新数组。

示例

>>> x = np.arange(6)
>>> x = x.reshape((2, 3))
>>> x
array([[0, 1, 2],
 [3, 4, 5]])
>>> np.ones_like(x)
array([[1, 1, 1],
 [1, 1, 1]])

>>> y = np.arange(3, dtype=float)
>>> y
array([0., 1., 2.])
>>> np.ones_like(y)
array([1.,  1.,  1.])

`numpy.zeros`

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

numpy.zeros(shape, dtype=float, order='C', *, like=None)

返回一个给定形状和类型、填充有零的新数组。

参数：

shape整数或整数元组

新数组的形状，例如，(2, 3) 或 2。

dtype数据类型，可选

数组的期望数据类型，例如，numpy.int8。默认为numpy.float64。

order，可选，默认为‘C’

是否在内存中以行主要（C 风格）或列主要（Fortran 风格）顺序存储多维数据。

like类似数组，可选

参考对象，允许创建不是 NumPy 数组的数组。如果传入的类似数组支持 like 的 __array_function__ 协议，则结果将由它定义。在这种情况下，它确保创建一个与通过此参数传入的对象兼容的数组对象。

新版本 1.20.0 中新增。

outndarray

具有给定形状、数据类型和顺序的零数组。

另请参阅

zeros_like

返回一个形状和输入类型的零数组。

empty

返回一个新的未初始化数组。

ones

返回一个将值设置为一的新数组。

full

返回一个给定形状且填充有值的新数组。

示例

>>> np.zeros(5)
array([ 0.,  0.,  0.,  0.,  0.])

>>> np.zeros((5,), dtype=int)
array([0, 0, 0, 0, 0])

>>> np.zeros((2, 1))
array([[ 0.],
 [ 0.]])

>>> s = (2,2)
>>> np.zeros(s)
array([[ 0.,  0.],
 [ 0.,  0.]])

>>> np.zeros((2,), dtype=[('x', 'i4'), ('y', 'i4')]) # custom dtype
array([(0, 0), (0, 0)],
 dtype=[('x', '<i4'), ('y', '<i4')])

`numpy.zeros_like`

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

numpy.zeros_like(a, dtype=None, order='K', subok=True, shape=None)

返回一个与给定数组相同形状和类型的零数组。

参数：

a类似数组

a的形状和数据类型定义了返回数组的这些相同属性。

dtype数据类型，可选

覆盖结果的数据类型。

新版本 1.6.0。

order，可选

覆盖结果的内存布局。‘C’表示 C 顺序，‘F’表示 F 顺序，‘A’表示如果a是 Fortran 连续的，则为‘F’，否则为‘C’。‘K’表示尽可能与a的布局匹配。

新版本 1.6.0。

subokbool，可选。

如果为 True，则新创建的数组将使用a的子类类型，否则将是基类数组。默认为 True。

shapeint 或 int 序列，可选。

覆盖结果的形状。如果 order=’K’且维度数量不变，则尝试保持顺序，否则，暗示 order=’C’。

新版本 1.17.0。

outndarray

与a相同形状和类型的零数组。

另请参阅

empty_like

返回一个形状和类型与输入相同的空数组。

ones_like

返回一个形状和类型与输入相同的全 1 数组。

full_like

返回一个形状与输入相同且填充有值的新数组。

zeros

返回一个将值设置为零的新数组。

示例

>>> x = np.arange(6)
>>> x = x.reshape((2, 3))
>>> x
array([[0, 1, 2],
 [3, 4, 5]])
>>> np.zeros_like(x)
array([[0, 0, 0],
 [0, 0, 0]])

>>> y = np.arange(3, dtype=float)
>>> y
array([0., 1., 2.])
>>> np.zeros_like(y)
array([0.,  0.,  0.])

`numpy.full`

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

numpy.full(shape, fill_value, dtype=None, order='C', *, like=None)

返回一个给定形状和类型、填充有fill_value的新数组。

参数：

shape整数或整数序列

新数组的形状，例如(2, 3)或2。

fill_value标量或类似数组

填充值。

dtype数据类型，可选

数组的期望数据类型，默认值为 None，表示

np.array(fill_value).dtype。

order，可选

是否在内存中以 C 或 Fortran 连续（行或列方式）顺序存储多维数据。

like类似数组，可选

参考对象，允许创建不是 NumPy 数组的数组。如果传入的类似数组like支持__array_function__协议，则结果将由其定义。在这种情况下，它确保创建一个与通过此参数传入的兼容的数组对象。

1.20.0 版本中的新内容。

outndarray

具有给定形状、dtype 和顺序的fill_value数组。

另请参见

full_like

返回一个形状与输入相同且填充有值的新数组。

empty

返回一个新的未初始化数组。

ones

返回一个将值设置为 1 的新数组。

zeros

返回一个将值设置为零的新数组。

示例

>>> np.full((2, 2), np.inf)
array([[inf, inf],
 [inf, inf]])
>>> np.full((2, 2), 10)
array([[10, 10],
 [10, 10]])

>>> np.full((2, 2), [1, 2])
array([[1, 2],
 [1, 2]])

`numpy.full_like`

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

numpy.full_like(a, fill_value, dtype=None, order='K', subok=True, shape=None)

返回一个与给定数组相同形状和类型的全数组。

参数：

a类似数组

a的形状和数据类型定义了返回数组的这些相同属性。

fill_value类似数组

填充值。

dtype数据类型，可选

覆盖结果的数据类型。

order，可选

subok布尔值，可选。

如果为 True，则新创建的数组将使用a的子类类型，否则将是一个基类数组。默认为 True。

shapeint 或 int 序列，可选。

覆盖结果的形状。如果 order=’K’且维度数量不变，则尝试保持顺序，否则，暗示 order=’C’。

1.17.0 版本中的新功能。

outndarray

用与a相同形状和类型的fill_value数组。

参见

empty_like

返回一个形状和类型与输入相同的空数组。

ones_like

返回一个形状和类型与输入相同的全 1 数组。

zeros_like

返回一个形状和类型与输入相同的全 0 数组。

full

返回一个给定形状的新数组，填充值为 value。

示例

>>> x = np.arange(6, dtype=int)
>>> np.full_like(x, 1)
array([1, 1, 1, 1, 1, 1])
>>> np.full_like(x, 0.1)
array([0, 0, 0, 0, 0, 0])
>>> np.full_like(x, 0.1, dtype=np.double)
array([0.1, 0.1, 0.1, 0.1, 0.1, 0.1])
>>> np.full_like(x, np.nan, dtype=np.double)
array([nan, nan, nan, nan, nan, nan])

>>> y = np.arange(6, dtype=np.double)
>>> np.full_like(y, 0.1)
array([0.1, 0.1, 0.1, 0.1, 0.1, 0.1])

>>> y = np.zeros([2, 2, 3], dtype=int)
>>> np.full_like(y, [0, 0, 255])
array([[[  0,   0, 255],
 [  0,   0, 255]],
 [[  0,   0, 255],
 [  0,   0, 255]]])

`numpy.array`

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

numpy.array(object, dtype=None, *, copy=True, order='K', subok=False, ndmin=0, like=None)

创建一个数组。

参数：

objectarray_like

一个数组，任何暴露数组接口的对象，一个其__array__方法返回数组的对象，或任何（嵌套的）序列。如果对象是标量，则返回一个包含对象的零维数组。

dtype数据类型，可选

数组的期望数据类型。如果未给出，则 NumPy 将尝试使用可以表示值的默认dtype（必要时应用提升规则）。

copybool，可选

如果为真（默认），则对象将被复制。否则，仅当__array__返回一个副本时，如果 obj 是一个嵌套序列，或者如果需要复制来满足任何其他要求（dtype，order等），才会进行复制。

order，可选

指定数组的内存布局。如果对象不是数组，则新创建的数组将按 C 顺序（行优先）排列，除非指定了‘F’，在这种情况下，它将按 Fortran 顺序（列优先）排列。如果对象是数组，则以下内容成立。

顺序	无复制	复制=True
‘K’	保持不变	保留 F 和 C 顺序，否则最相似的顺序
‘A’	保持不变	如果输入为 F 且不是 C，则按 F 顺序，否则按 C 顺序
‘C’	C 顺序	C 顺序
‘F’	F order	F order

当copy=False且由于其他原因进行复制时，结果与copy=True时相同，但对于‘A’有一些例外情况，请参阅注释部分。默认顺序为‘K’。

subokbool, optional

如果为 True，则子类将被传递，否则返回的数组将被强制为基类数组（默认）。

ndminint, optional

指定结果数组应具有的最小维数。将根据需要在形状前面添加 1 以满足此要求。

likearray_like, optional

引用对象，允许创建不是 NumPy 数组的数组。如果传入like的类似数组支持__array_function__协议，则结果将由它定义。在这种情况下，它确保创建一个与通过此参数传入的对象兼容的数组对象。

1.20.0 版本中的新功能。

outndarray

满足指定要求的数组对象。

另请参见

empty_like

返回一个形状和类型与输入相同的空数组。

ones_like

返回一个形状和类型与输入相同的全 1 数组。

zeros_like

返回一个形状和类型与输入相同的零数组。

full_like

返回一个形状与输入相同且填充有值的新数组。

empty

返回一个新的未初始化数组。

ones

返回一个将值设置为一的新数组。

zeros

返回一个将值设置为零的新数组。

full

返回一个给定形状、填充有值的新数组。

注意

当顺序为‘A’且object既不是‘C’顺序也不是‘F’顺序的数组，并且由于 dtype 的变化而强制进行复制时，结果的顺序不一定如预期的‘C’。这很可能是一个 bug。

示例

>>> np.array([1, 2, 3])
array([1, 2, 3])

向上转型：

>>> np.array([1, 2, 3.0])
array([ 1.,  2.,  3.])

多于一个维度：

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

最小维度为 2：

>>> np.array([1, 2, 3], ndmin=2)
array([[1, 2, 3]])

提供的类型：

>>> np.array([1, 2, 3], dtype=complex)
array([ 1.+0.j,  2.+0.j,  3.+0.j])

由多个元素组成的数据类型：

>>> x = np.array([(1,2),(3,4)],dtype=[('a','<i4'),('b','<i4')])
>>> x['a']
array([1, 3])

从子类创建数组：

>>> np.array(np.mat('1 2; 3 4'))
array([[1, 2],
 [3, 4]])

>>> np.array(np.mat('1 2; 3 4'), subok=True)
matrix([[1, 2],
 [3, 4]])

`numpy.asarray`

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

numpy.asarray(a, dtype=None, order=None, *, like=None)

将输入转换为数组。

参数：

aarray_like

输入数据，以任何可以转换为数组的形式。这包括列表，元组列表，元组，元组列表，列表元组和 ndarrays。

dtype数据类型，可选

默认情况下，数据类型是从输入数据中推断出来的。

order，可选

内存布局。‘A’和‘K’取决于输入数组 a 的顺序。‘C’行主要（C 风格），‘F’列主要（Fortran 风格）内存表示。‘A’（任意）意味着如果a是 Fortran 连续的，则为‘F’，否则为‘C’，‘K’（保持）保留输入顺序，默认为‘K’。

likearray_like，可选

参考对象，允许创建不是 NumPy 数组的数组。如果传递给like的类似数组支持__array_function__协议，则结果将由它定义。在这种情况下，它确保创建与通过此参数传递的对象兼容的数组对象。

版本 1.20.0 中的新功能。

outndarray

a的数组解释。如果输入已经是具有匹配 dtype 和顺序的 ndarray，则不执行复制。如果a是 ndarray 的子类，则返回基类 ndarray。

另请参阅

asanyarray

通过子类的类似函数。

ascontiguousarray

将输入转换为连续数组。

asfarray

将输入转换为浮点数 ndarray��

asfortranarray

将输入转换为具有列主内存顺序的 ndarray。

asarray_chkfinite

检查输入中是否存在 NaN 和 Infs 的类似函数。

fromiter

从迭代器创建数组。

fromfunction

通过在网格位置上执行函数来构造数组。

示例

将列表转换为数组：

>>> a = [1, 2]
>>> np.asarray(a)
array([1, 2])

现有数组不会被复制：

>>> a = np.array([1, 2])
>>> np.asarray(a) is a
True

如果设置了dtype，则仅在 dtype 不匹配时复制数组：

>>> a = np.array([1, 2], dtype=np.float32)
>>> np.asarray(a, dtype=np.float32) is a
True
>>> np.asarray(a, dtype=np.float64) is a
False

与asanyarray相反，ndarray 子类不会通过：

>>> issubclass(np.recarray, np.ndarray)
True
>>> a = np.array([(1.0, 2), (3.0, 4)], dtype='f4,i4').view(np.recarray)
>>> np.asarray(a) is a
False
>>> np.asanyarray(a) is a
True

`numpy.asanyarray`

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

numpy.asanyarray(a, dtype=None, order=None, *, like=None)

将输入转换为 ndarray，但通过 ndarray 子类。

参数：

a类似数组

输入数据，以任何可转换为数组的形式。这包括标量、列表、元组列表、元组、元组列表、列表的元组和 ndarrays。

dtype数据类型，可选

默认情况下，数据类型从输入数据中推断。

order，可选

内存布局。‘A’和‘K’取决于输入数组 a 的顺序。‘C’行主要（C 风格），‘F’列主要（Fortran 风格）内存表示。‘A’（任意）意味着如果a是 Fortran 连续的，则为‘F’，否则为‘C’，‘K’（保持）保留输入顺序，默认为‘C’。

like类似数组，可选

参考对象，允许创建不是 NumPy 数组的数组。如果传入like的类似数组支持__array_function__协议，则结果将由它定义。在这种情况下，它确保创建与通过此参数传入的对象兼容的数组对象。

新版本 1.20.0 中引入。

outndarray 或 ndarray 子类

a的数组解释。如果a是 ndarray 或 ndarray 的子类，则原样返回，不执行复制。

另请参见

类似的函数，始终返回 ndarrays。

将输入转换为连续数组。

将输入转换为浮点数 ndarray。

将输入转换为具有列主内存顺序的 ndarray。

asarray_chkfinite

类似的函数，用于检查输入是否为 NaN 和 Infs。

fromiter

从迭代器创建数组。

fromfunction

通过在网格位置上执行函数构造数组。

示例

将列表转换为数组：

>>> a = [1, 2]
>>> np.asanyarray(a)
array([1, 2])

ndarray子类的实例将按原样传递：

>>> a = np.array([(1.0, 2), (3.0, 4)], dtype='f4,i4').view(np.recarray)
>>> np.asanyarray(a) is a
True

`numpy.ascontiguousarray`

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

numpy.ascontiguousarray(a, dtype=None, *, like=None)

返回一个在内存中连续的数组（ndim >= 1）（C 顺序）。

参数：

a类似数组

输入数组。

dtypestr 或 dtype 对象，可选

返回数组的数据类型。

like类似数组，可选

引用对象，允许创建不是 NumPy 数组的数组。如果传入like的类似数组支持__array_function__协议，则结果将由其定义。在这种情况下，它确保创建一个与通过此参数传入的兼容的数组对象。

新版本 1.20.0 中添加。

outndarray

与 a 相同形状和内容的连续数组，如果指定了dtype类型。

另请参阅

asfortranarray

将输入转换为具有列主内存顺序的 ndarray。

require

返回满足要求的 ndarray。

ndarray.flags

数组的内存布局信息。

示例

从一个 Fortran 连续的数组开始：

>>> x = np.ones((2, 3), order='F')
>>> x.flags['F_CONTIGUOUS']
True

调用ascontiguousarray会生成一个 C 连续的副本：

>>> y = np.ascontiguousarray(x)
>>> y.flags['C_CONTIGUOUS']
True
>>> np.may_share_memory(x, y)
False

现在，从一个 C 连续的数组开始：

>>> x = np.ones((2, 3), order='C')
>>> x.flags['C_CONTIGUOUS']
True

然后，调用ascontiguousarray返回相同的对象：

>>> y = np.ascontiguousarray(x)
>>> x is y
True

注意：此函数返回至少一维（1-d）的数组，因此不会保留 0-d 数组。

`numpy.asmatrix`

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

numpy.asmatrix(data, dtype=None)

将输入解释为矩阵。

与matrix不同，如果输入已经是矩阵或 ndarray，则asmatrix不会复制。等同于matrix(data, copy=False)。

参数：

数据array_like

输入数据。

dtype数据类型

输出矩阵的数据类型。

mat矩阵

data 解释为矩阵。

示例

>>> x = np.array([[1, 2], [3, 4]])

>>> m = np.asmatrix(x)

>>> x[0,0] = 5

>>> m
matrix([[5, 2],
 [3, 4]])

`numpy.copy`

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

numpy.copy(a, order='K', subok=False)

返回给定对象的数组副本。

参数：

a类似数组

输入数据。

order, 可选

控制副本的内存布局。‘C’表示 C 顺序，‘F’表示 F 顺序，‘A’表示如果a是 Fortran 连续的则为‘F’，否则为‘C’。‘K’表示尽可能与a的布局匹配。（请注意，此函数和ndarray.copy非常相似，但对于其 order=参数具有不同的默认值。）

subokbool, 可选

如果为 True，则子类将被传递，否则返回的数组将被强制为基类数组（默认为 False）。

自版本 1.19.0 起新增。

arr ndarray

a的数组解释。

参见

ndarray.copy

创建数组副本的首选方法

注：

这等效于：

>>> np.array(a, copy=True)

示例

创建一个带有引用 y 和副本 z 的数组 x：

>>> x = np.array([1, 2, 3])
>>> y = x
>>> z = np.copy(x)

注意，当我们修改 x 时，y 会改变，但 z 不会变：

>>> x[0] = 10
>>> x[0] == y[0]
True
>>> x[0] == z[0]
False

请注意，np.copy 会清除以前设置的 WRITEABLE=False 标志。

>>> a = np.array([1, 2, 3])
>>> a.flags["WRITEABLE"] = False
>>> b = np.copy(a)
>>> b.flags["WRITEABLE"]
True
>>> b[0] = 3
>>> b
array([3, 2, 3])

请注意，np.copy 是浅复制，不会复制数组中的对象元素。这对包含 Python 对象的数组非常重要。新数组将包含相同的对象，如果该对象可以修改（是可变的），可能会导致意外结果：

>>> a = np.array([1, 'm', [2, 3, 4]], dtype=object)
>>> b = np.copy(a)
>>> b[2][0] = 10
>>> a
array([1, 'm', list([10, 3, 4])], dtype=object)

要确保复制object数组中的所有元素，请使用copy.deepcopy:

>>> import copy
>>> a = np.array([1, 'm', [2, 3, 4]], dtype=object)
>>> c = copy.deepcopy(a)
>>> c[2][0] = 10
>>> c
array([1, 'm', list([10, 3, 4])], dtype=object)
>>> a
array([1, 'm', list([2, 3, 4])], dtype=object)

`numpy.frombuffer`

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

numpy.frombuffer(buffer, dtype=float, count=-1, offset=0, *, like=None)

将缓冲区解释为一维数组。

参数：

buffer buffer_like

暴露缓冲区接口的对象。

dtype 数据类型，可选

返回数组的数据类型；默认值：float。

count int，可选

要读取的项目数。-1 表示缓冲区中的所有数据。

offset int，可选

从此偏移量（以字节为单位）开始读取缓冲区；默认值：0。

like array_like，可选

引用对象，允许创建不是 NumPy 数组的数组。如果传入 like 的类似数组支持 __array_function__ 协议，则结果将由它定义。在这种情况下，它确保创建与通过此参数传入的对象兼容的数组对象。

1.20.0 版新功能。

out ndarray

另请参阅

ndarray.tobytes

此操作的反操作，从数组中的原始数据字节构造 Python 字节。

注意事项

如果缓冲区中的数据不是机器字节顺序的，则应将其指定为数据类型的一部分，例如：

>>> dt = np.dtype(int)
>>> dt = dt.newbyteorder('>')
>>> np.frombuffer(buf, dtype=dt)

返回的数组的数据不会被字节交换，但将被正确地解释。

此函数创建对原始对象的视图。通常情况下，这应该是安全的，但当原始对象是可变的或不可信的时，复制结果可能是有意义的。

示例

>>> s = b'hello world'
>>> np.frombuffer(s, dtype='S1', count=5, offset=6)
array([b'w', b'o', b'r', b'l', b'd'], dtype='|S1')

>>> np.frombuffer(b'\x01\x02', dtype=np.uint8)
array([1, 2], dtype=uint8)
>>> np.frombuffer(b'\x01\x02\x03\x04\x05', dtype=np.uint8, count=3)
array([1, 2, 3], dtype=uint8)

`numpy.from_dlpack`

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

numpy.from_dlpack(x, /)

从实现了__dlpack__ 协议的对象创建一个 NumPy 数组。通常，返回的 NumPy 数组是输入对象的只读视图。详情请参阅[1] 和 [2]。

参数：

x对象

一个实现__dlpack__ 和 __dlpack_device__方法的 Python 对象。

outndarray

参考资料

[1]

数组 API 文档，data-apis.org/array-api/latest/design_topics/data_interchange.html#syntax-for-data-interchange-with-dlpack

[2]

DLPack 的 Python 规范，dmlc.github.io/dlpack/latest/python_spec.html

示例

>>> import torch
>>> x = torch.arange(10)
>>> # create a view of the torch tensor "x" in NumPy
>>> y = np.from_dlpack(x)

`numpy.fromfile`

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

numpy.fromfile(file, dtype=float, count=-1, sep='', offset=0, *, like=None)

从文本或二进制文件中的数据构造数组。

一种高效的读取已知数据类型的二进制数据以及解析简单格式文本文件的方法。使用tofile方法写入的数据可以使用这个函数读取。

参数：

filefile 或 str 或 Path

打开文件对象或文件名。

从版本 1.17.0 开始更改：现在接受pathlib.Path对象。

dtype数据类型

返回数组的数据类型。对于二进制文件，用于确定文件中项目的大小和字节顺序。支持大多数内置的数值类型和扩展类型可能也支持。

新功能（版本 1.18.0）：复杂的数据类型。

countint

要读取的项目数。-1表示所有项目（即完整文件）。

sepstr

如果文件是文本文件，则项之间的分隔符。空（“”）分隔符表示应将文件视为二进制文件。分隔符中的空格（” “）匹配零个或多个空格字符。只包含空格的分隔符必须匹配至少一个空格字符。

offsetint

文件当前位置的偏移量（以字节为单位）。默认为 0。仅允许用于二进制文件。

新功能（版本 1.17.0）。

likearray_like，可选

用于允许创建不是 NumPy 数组的数组的参考对象。如果like传入的类似数组支持__array_function__协议，则结果将由它定义。在这种情况下，它确保以此参数传入的对象兼容的数组对象的创建。

新功能（版本 1.20.0）。

另请参阅

load，save

ndarray.tofile

loadtxt

从文本文件加载数据的更灵活的方式。

注意

不要依赖于tofile和fromfile的组合进行数据存储，因为生成的二进制文件不是跨平台的。特别地，没有保存任何字节顺序或数据类型信息。数据可以使用save和load以跨平台独立的.npy格式进行存储。

示例

构造一个 ndarray：

>>> dt = np.dtype([('time', [('min', np.int64), ('sec', np.int64)]),
...                ('temp', float)])
>>> x = np.zeros((1,), dtype=dt)
>>> x['time']['min'] = 10; x['temp'] = 98.25
>>> x
array([((10, 0), 98.25)],
 dtype=[('time', [('min', '<i8'), ('sec', '<i8')]), ('temp', '<f8')])

将原始数据保存到磁盘：

>>> import tempfile
>>> fname = tempfile.mkstemp()[1]
>>> x.tofile(fname)

从磁盘读取原始数据：

>>> np.fromfile(fname, dtype=dt)
array([((10, 0), 98.25)],
 dtype=[('time', [('min', '<i8'), ('sec', '<i8')]), ('temp', '<f8')])

存储和加载数据的推荐方式：

>>> np.save(fname, x)
>>> np.load(fname + '.npy')
array([((10, 0), 98.25)],
 dtype=[('time', [('min', '<i8'), ('sec', '<i8')]), ('temp', '<f8')])

`numpy.fromfunction`

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

numpy.fromfunction(function, shape, *, dtype=<class 'float'>, like=None, **kwargs)

使用函数在每个坐标上执行以构建数组。

结果数组因此在坐标(x, y, z)处具有值fn(x, y, z)。

参数：

function可调用

该函数被调用时带有 N 个参数，其中 N 是shape的秩。每个参数表示数组沿特定轴变化的坐标。例如，如果shape为(2, 2)，那么参数将是array([[0, 0], [1, 1]])和array([[0, 1], [0, 1]])。

shape(N,)整数元组

输出数组的形状，也决定了传递给function的坐标数组的形状。

dtype数据类型，可选

传递给function的坐标数组的数据类型。默认情况下，dtype为 float。

likearray_like，可选

参考对象，允许创建不是 NumPy 数组的数组。如果传入like的类数组支持__array_function__协议，则结果将由其定义。在这种情况下，它确保创建与通过此参数传入的对象兼容的数组对象。

在 1.20.0 版本中新增。

fromfunctionany

对function的调用结果直接传回。因此，fromfunction的形状完全由function确定。如果function返回一个标量值，则fromfunction的形状将与shape参数不匹配。

另请参见

indices，meshgrid

注释

除了dtype和like之外的关键字都会传递给function。

示例

>>> np.fromfunction(lambda i, j: i, (2, 2), dtype=float)
array([[0., 0.],
 [1., 1.]])

>>> np.fromfunction(lambda i, j: j, (2, 2), dtype=float)
array([[0., 1.],
 [0., 1.]])

>>> np.fromfunction(lambda i, j: i == j, (3, 3), dtype=int)
array([[ True, False, False],
 [False,  True, False],
 [False, False,  True]])

>>> np.fromfunction(lambda i, j: i + j, (3, 3), dtype=int)
array([[0, 1, 2],
 [1, 2, 3],
 [2, 3, 4]])

`numpy.fromiter`

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

numpy.fromiter(iter, dtype, count=-1, *, like=None)

从可迭代对象创建新的一维数组。

参数：

iter可迭代对象

提供数组数据的可迭代对象。

dtype数据类型

返回的数组的数据类型。

在 1.23 版本中更改：现在支持对象和子数组数据类型（请注意最终结果对于子数组数据类型不是 1-D）。

countint，可选

从iterable中读取的项目数。默认值为-1，表示读取所有数据。

like类似于数组的可选对象

引用对象，允许创建非 NumPy 数组的数组。如果传递给like的类似数组支持__array_function__协议，结果将由其定义。在这种情况下，它确保了与通过此参数传递的对象兼容的数组对象的创建。

1.20.0 版中新增。

outndarray

输出数组。

注释

指定count以提高性能。它允许fromiter预分配输出数组，而不是按需调整其大小。

示例

>>> iterable = (x*x for x in range(5))
>>> np.fromiter(iterable, float)
array([  0.,   1.,   4.,   9.,  16.])

仔细构建的子数组数据类型将导致更高维度的结果：

>>> iterable = ((x+1, x+2) for x in range(5))
>>> np.fromiter(iterable, dtype=np.dtype((int, 2)))
array([[1, 2],
 [2, 3],
 [3, 4],
 [4, 5],
 [5, 6]])

`numpy.fromstring`

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

numpy.fromstring(string, dtype=float, count=-1, *, sep, like=None)

从字符串中的文本数据初始化的新 1-D 数组。

参数：

stringstr

包含数据的字符串。

dtype数据类型，可选

数组的数据类型；默认值：float。对于二进制输入数据，数据必须正好符合此格式。支持大多数内置的数值类型和可能会支持扩展类型。

新版本 1.18.0：复杂的数据类型。

countint，可选

从数据中读取此数量的dtype元素。如果为负（默认值），则计数将根据数据的长度确定。

sepstr，可选

数据中分隔数字的字符串；元素之间的额外空格也将被忽略。

自版本 1.14 弃用：由于传递sep=''，默认情况已弃用，因为它将触发此功能的已弃用二进制模式。该模式将string解释为二进制字节，而不是带有十进制数的 ASCII 文本，这样的操作最好使用frombuffer(string, dtype, count)。如果string包含 unicode 文本，fromstring的二进制模式将首先使用 utf-8 对其进行编码，这将不会产生合理的结果。

likearray_like，可选

引用对象，允许创建不是 NumPy 数组的数组。如果传入作为like的类似数组支持__array_function__协议，则结果将由它来定义。在这种情况下，它确保创建一个与通过此参数传入的数组兼容的数组对象。

新版本 1.20.0。

arrndarray

构建的数组。

引发：

ValueError

如果字符串大小不正确，则无法满足请求的dtype和count。

另请参阅

frombuffer, fromfile, fromiter

示例：

>>> np.fromstring('1 2', dtype=int, sep=' ')
array([1, 2])
>>> np.fromstring('1, 2', dtype=int, sep=',')
array([1, 2])

`numpy.loadtxt`

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

numpy.loadtxt(fname, dtype=<class 'float'>, comments='#', delimiter=None, converters=None, skiprows=0, usecols=None, unpack=False, ndmin=0, encoding='bytes', max_rows=None, *, quotechar=None, like=None)

从文本文件加载数据。

参数：

fnamefile, str, pathlib.Path, list of str, generator

要读取的文件、文件名、列表或生成器。如果文件扩展名为.gz或.bz2，则首先解压文件。注意，生成器必须返回字节或字符串。列表中的字符串或生成器产生的字符串将被视为行。

dtypedata-type, optional

结果数组的数据类型；默认值：float。如果这是一个结构化的数据类型，则结果数组将是一维的，每行将被解释为数组的一个元素。在这种情况下，使用的列数必须与数据类型中的字段数匹配。

commentsstr or sequence of str or None, optional

用于指示注释开始的字符或字符列表。无表示无注释。为了向后兼容，字节字符串将被解码为‘latin1’。默认为‘#’。

delimiterstr, optional

用于分隔值的字符。为了向后兼容，字节字符串将被解码为‘latin1’。默认为空白字符。

1.23.0 版更改：仅支持单字符分隔符。不能使用换行符作为分隔符。

convertersdict or callable, optional

自定义值解析的转换器函数。如果converters可调用，则该函数将应用于所有列，否则必须是一个将列号映射到解析器函数的字典。有关更多详细信息，请参见示例。默认值：None。

1.23.0 版更改：添加了传递单个可调用以应用于所有列的能力。

skiprowsint, optional

跳过第一个skiprows行，包括注释；默认值：0。

usecolsint or sequence, optional

要读取的列，其中 0 表示第一列。例如，usecols = (1,4,5)将提取第 2、第 5 和第 6 列。默认情况下，None 将导致读取所有列。

1.11.0 版更改：当需要读取单个列时，可以使用整数而不是元组。例如，usecols = 3与usecols = (3,)的效果相同。

unpackbool, optional

如果为 True，则返回的数组将被转置，因此可以使用x, y, z = loadtxt(...)来解包参数。当与结构化数据类型一起使用时，将为每个字段返回数组。默认为 False。

ndminint, optional

返回的数组将至少具有ndmin维。否则，将挤压单维轴。合法值：0（默认）、1 或 2。

1.6.0 版新增。

encodingstr, optional

用于解码输入文件的编码。不适用于输入流。特殊值'bytes'启用了向后兼容的工作方式，以确保在可能的情况下接收字节数组作为结果，并将'latin1'编码的字符串传递给转换器。覆盖此值以接收 Unicode 数组并将字符串作为输入传递给转换器。如果设置为 None，则使用系统默认值。默认值为'bytes'。

1.14.0 版本中新增。

max_rowsint，可选

在skiprows行后读取max_rows行内容。默认情况下为读取所有行。请注意，不包含数据的空行（如空行和注释行）不计入max_rows，但这些行在skiprows中计入。

1.16.0 版本中新增。

1.23.0 版本中的更改：不包含数据的行，包括注释行（例如，以'＃'开头的行或通过comments指定的行）不会计入max_rows。

quotecharunicode 字符或 None，可选

用于表示引用项的起始和结束的字符。在引用项中被引号或注释字符的出现将被忽略。默认值为quotechar=None，这意味着引号支持已禁用。

如果在带引号的字段中发现两个连续的quotechar实例，则第一个将被视为转义字符。请参见示例。

1.23.0 版本中新增。

likearray_like，可选

引用对象，允许创建不是 NumPy 数组的数组。如果传入like的类似数组支持__array_function__协议，则结果将由它定义。在这种情况下，它确保创建与通过此参数传入的数组兼容的数组对象。

1.20.0 版本中新增。

outndarray

从文本文件中读取的数据。

另请参阅

load, fromstring, fromregex

genfromtxt

以指定格式处理缺失值的数据加载。

scipy.io.loadmat

读取 MATLAB 数据文件

注意事项

此函数旨在成为简单格式文件的快速读取器。 genfromtxt 函数提供更复杂的处理功能，例如处理具有缺失值的行。

输入文本文件中的每一行必须具有相同数量的值，才能够读取所有的值。如果所有行的值的数量不相同，则可以通过usecols指定要读取的列的子集（n 为所有行中出现的最少值的数量）。

1.10.0 版本中新增。

由 Python float.hex 方法生成的字符串可用作浮点数的输入。

示例

>>> from io import StringIO   # StringIO behaves like a file object
>>> c = StringIO("0 1\n2 3")
>>> np.loadtxt(c)
array([[0., 1.],
 [2., 3.]])

>>> d = StringIO("M 21 72\nF 35 58")
>>> np.loadtxt(d, dtype={'names': ('gender', 'age', 'weight'),
...                      'formats': ('S1', 'i4', 'f4')})
array([(b'M', 21, 72.), (b'F', 35, 58.)],
 dtype=[('gender', 'S1'), ('age', '<i4'), ('weight', '<f4')])

>>> c = StringIO("1,0,2\n3,0,4")
>>> x, y = np.loadtxt(c, delimiter=',', usecols=(0, 2), unpack=True)
>>> x
array([1., 3.])
>>> y
array([2., 4.])

转换器参数用于指定在解析之前对文本进行预处理的函数。转换器可以是将预处理函数映射到每一列的字典：

>>> s = StringIO("1.618, 2.296\n3.141, 4.669\n")
>>> conv = {
...     0: lambda x: np.floor(float(x)),  # conversion fn for column 0
...     1: lambda x: np.ceil(float(x)),  # conversion fn for column 1
... }
>>> np.loadtxt(s, delimiter=",", converters=conv)
array([[1., 3.],
 [3., 5.]])

转换器可以是一个可调用对象，而不是一个字典，此时它将应用于所有列：

>>> s = StringIO("0xDE 0xAD\n0xC0 0xDE")
>>> import functools
>>> conv = functools.partial(int, base=16)
>>> np.loadtxt(s, converters=conv)
array([[222., 173.],
 [192., 222.]])

此示例显示了如何使用转换器将带有尾部减号的字段转换为负数。

>>> s = StringIO('10.01 31.25-\n19.22 64.31\n17.57- 63.94')
>>> def conv(fld):
...     return -float(fld[:-1]) if fld.endswith(b'-') else float(fld)
...
>>> np.loadtxt(s, converters=conv)
array([[ 10.01, -31.25],
 [ 19.22,  64.31],
 [-17.57,  63.94]])

将可调用对象用作转换器特别适用于处理具有不同格式的值，例如带有下划线的浮点数：

>>> s = StringIO("1 2.7 100_000")
>>> np.loadtxt(s, converters=float)
array([1.e+00, 2.7e+00, 1.e+05])

这个想法可以扩展到自动处理以许多不同格式指定的值：

>>> def conv(val):
...     try:
...         return float(val)
...     except ValueError:
...         return float.fromhex(val)
>>> s = StringIO("1, 2.5, 3_000, 0b4, 0x1.4000000000000p+2")
>>> np.loadtxt(s, delimiter=",", converters=conv, encoding=None)
array([1.0e+00, 2.5e+00, 3.0e+03, 1.8e+02, 5.0e+00])

请注意，默认encoding="bytes"时，转换器函数的输入是 latin-1 编码的字节字符串。要在转换之前取消隐式编码，请使用encoding=None。

>>> s = StringIO('10.01 31.25-\n19.22 64.31\n17.57- 63.94')
>>> conv = lambda x: -float(x[:-1]) if x.endswith('-') else float(x)
>>> np.loadtxt(s, converters=conv, encoding=None)
array([[ 10.01, -31.25],
 [ 19.22,  64.31],
 [-17.57,  63.94]])

通过quotechar参数启用了对引用字段的支持。当注释字符和分隔符字符出现在由quotechar界定的引用项内时，它们将被忽略：

>>> s = StringIO('"alpha, #42", 10.0\n"beta, #64", 2.0\n')
>>> dtype = np.dtype([("label", "U12"), ("value", float)])
>>> np.loadtxt(s, dtype=dtype, delimiter=",", quotechar='"')
array([('alpha, #42', 10.), ('beta, #64',  2.)],
 dtype=[('label', '<U12'), ('value', '<f8')])

引用字段可以通过多个空白字符分隔：

>>> s = StringIO('"alpha, #42"       10.0\n"beta, #64" 2.0\n')
>>> dtype = np.dtype([("label", "U12"), ("value", float)])
>>> np.loadtxt(s, dtype=dtype, delimiter=None, quotechar='"')
array([('alpha, #42', 10.), ('beta, #64',  2.)],
 dtype=[('label', '<U12'), ('value', '<f8')])

在引用字段中的两个连续引号字符被视为一个转义字符：

>>> s = StringIO('"Hello, my name is ""Monty""!"')
>>> np.loadtxt(s, dtype="U", delimiter=",", quotechar='"')
array('Hello, my name is "Monty"!', dtype='<U26')

当所有行不包含相等数量的值时，读取列的子集：

>>> d = StringIO("1 2\n2 4\n3 9 12\n4 16 20")
>>> np.loadtxt(d, usecols=(0, 1))
array([[ 1.,  2.],
 [ 2.,  4.],
 [ 3.,  9.],
 [ 4., 16.]])

`numpy.core.records.array`

原文：numpy.org/doc/1.26/reference/generated/numpy.core.records.array.html

core.records.array(obj, dtype=None, shape=None, offset=0, strides=None, formats=None, names=None, titles=None, aligned=False, byteorder=None, copy=True)

从各种对象构造记录数组。

一个通用的记录数组构造函数，根据输入调度到适当的recarray创建函数（请参阅注意事项）。

参数：

obj任意

输入对象。有关各种输入类型处理方式的详细信息，请参阅注意事项。

dtype数据类型，可选

数组的有效 dtype。

shape整数或整数元组，可选

每个数组的形状。

offset整数，可选

从文件或缓冲区开始读取的位置。

strides整数元组，可选

缓冲区 (buf) 根据这些步幅进行解释（步幅定义了内存中每个数组元素、行、列等所占用的字节数）。

formats, names, titles, aligned, byteorder

如果dtype为None，则将这些参数传递给numpy.format_parser以构造 dtype。有关详细文档，请参见该函数。

copy布尔值，可选

是否复制输入对象（True），还是使用引用。此选项仅适用于输入为 ndarray 或 recarray 时。默认为 True。

np.recarray

由指定对象创建的记录数组。

Notes

如果 obj 为 None，则调用 recarray 构造函数。如果 obj 是一个字符串，则调用 fromstring 构造函数。如果 obj 是一个列表或元组，则如果第一个对象是一个 ndarray，则调用 fromarrays，否则调用 fromrecords。如果 obj 是一个 recarray，则复制 recarray 中的数据（如果 copy=True），并使用新的格式、名称和标题。如果 obj 是一个文件，则调用 fromfile。最后，如果 obj 是一个 ndarray，则返回 obj.view(recarray)，如果 copy=True 则复制数据。

Examples

>>> a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
array([[1, 2, 3],
 [4, 5, 6],
 [7, 8, 9]])

>>> np.core.records.array(a)
rec.array([[1, 2, 3],
 [4, 5, 6],
 [7, 8, 9]],
 dtype=int32)

>>> b = [(1, 1), (2, 4), (3, 9)]
>>> c = np.core.records.array(b, formats = ['i2', 'f2'], names = ('x', 'y'))
>>> c
rec.array([(1, 1.0), (2, 4.0), (3, 9.0)],
 dtype=[('x', '<i2'), ('y', '<f2')])

>>> c.x
rec.array([1, 2, 3], dtype=int16)

>>> c.y
rec.array([ 1.0,  4.0,  9.0], dtype=float16)

>>> r = np.rec.array(['abc','def'], names=['col1','col2'])
>>> print(r.col1)
abc

>>> r.col1
array('abc', dtype='<U3')

>>> r.col2
array('def', dtype='<U3')

`numpy.core.records.fromarrays`

原文：numpy.org/doc/1.26/reference/generated/numpy.core.records.fromarrays.html

core.records.fromarrays(arrayList, dtype=None, shape=None, formats=None, names=None, titles=None, aligned=False, byteorder=None)

从（扁平的）数组列表创建记录数组

参数：

arrayList列表或元组

数组样式对象的列表（如列表、元组和 ndarrays）。

dtype数据类型，可选

所有数组的有效 dtype

shape整数或整数元组，可选

结果数组的形状。如果未提供，则从arrayList[0]推断。

formats, names, titles, aligned, byteorder

如果dtype为None，则将这些参数传递给numpy.format_parser以构造 dtype。有关详细文档，请参阅该函数。

np.recarray

由给定的 arrayList 列组成的记录数组。

示例

>>> x1=np.array([1,2,3,4])
>>> x2=np.array(['a','dd','xyz','12'])
>>> x3=np.array([1.1,2,3,4])
>>> r = np.core.records.fromarrays([x1,x2,x3],names='a,b,c')
>>> print(r[1])
(2, 'dd', 2.0) # may vary
>>> x1[1]=34
>>> r.a
array([1, 2, 3, 4])

>>> x1 = np.array([1, 2, 3, 4])
>>> x2 = np.array(['a', 'dd', 'xyz', '12'])
>>> x3 = np.array([1.1, 2, 3,4])
>>> r = np.core.records.fromarrays(
...     [x1, x2, x3],
...     dtype=np.dtype([('a', np.int32), ('b', 'S3'), ('c', np.float32)]))
>>> r
rec.array([(1, b'a', 1.1), (2, b'dd', 2\. ), (3, b'xyz', 3\. ),
 (4, b'12', 4\. )],
 dtype=[('a', '<i4'), ('b', 'S3'), ('c', '<f4')])

`numpy.core.records.fromrecords`

原文：numpy.org/doc/1.26/reference/generated/numpy.core.records.fromrecords.html

core.records.fromrecords(recList, dtype=None, shape=None, formats=None, names=None, titles=None, aligned=False, byteorder=None)

从文本形式的记录列表创建一个记录数组。

参数：

recList序列

相同字段中的数据可能是异构的-它们将被提升到最高的数据类型。

dtype数据类型，可选项

所有数组的有效 dtype

shape整数或整数元组，可选项

每个数组的形状。

formats, names, titles, aligned, byteorder

如果dtype为None，这些参数将传递给numpy.format_parser以构造数据类型。详细文档请参见该函数。

如果formats和dtype都为None，则这将自动检测格式。使用元组列表而不是列表列表可加快处理速度。

返回值：

np.recarray

由给定 recList 行组成的记录数组。

示例

>>> r=np.core.records.fromrecords([(456,'dbe',1.2),(2,'de',1.3)],
... names='col1,col2,col3')
>>> print(r[0])
(456, 'dbe', 1.2)
>>> r.col1
array([456,   2])
>>> r.col2
array(['dbe', 'de'], dtype='<U3')
>>> import pickle
>>> pickle.loads(pickle.dumps(r))
rec.array([(456, 'dbe', 1.2), (  2, 'de', 1.3)],
 dtype=[('col1', '<i8'), ('col2', '<U3'), ('col3', '<f8')])

`numpy.core.records.fromstring`

原文：numpy.org/doc/1.26/reference/generated/numpy.core.records.fromstring.html

core.records.fromstring(datastring, dtype=None, shape=None, offset=0, formats=None, names=None, titles=None, aligned=False, byteorder=None)

从二进制数据创建记录数组

请注意，尽管该函数的名称是如此，但它不接受str实例。

参数:

datastring类似 bytes 的数据

二进制数据的缓冲区

dtype数据类型，可选

所有数组的有效 dtype

shapeint 或 int 元组，可选

每个数组的形状。

offsetint，可选

从缓冲区开始读取的位置。

格式，名称，标题，对齐，字节顺序

如果dtype为None，则这些参数将传递给numpy.format_parser以构造 dtype。详细文档请参阅该函数。

np.recarray

数据字符串中数据的记录数组视图。如果datastring是只读的，这将是只读的。

另请参见

numpy.frombuffer

示例

>>> a = b'\x01\x02\x03abc'
>>> np.core.records.fromstring(a, dtype='u1,u1,u1,S3')
rec.array([(1, 2, 3, b'abc')],
 dtype=[('f0', 'u1'), ('f1', 'u1'), ('f2', 'u1'), ('f3', 'S3')])

>>> grades_dtype = [('Name', (np.str_, 10)), ('Marks', np.float64),
...                 ('GradeLevel', np.int32)]
>>> grades_array = np.array([('Sam', 33.3, 3), ('Mike', 44.4, 5),
...                         ('Aadi', 66.6, 6)], dtype=grades_dtype)
>>> np.core.records.fromstring(grades_array.tobytes(), dtype=grades_dtype)
rec.array([('Sam', 33.3, 3), ('Mike', 44.4, 5), ('Aadi', 66.6, 6)],
 dtype=[('Name', '<U10'), ('Marks', '<f8'), ('GradeLevel', '<i4')])

>>> s = '\x01\x02\x03abc'
>>> np.core.records.fromstring(s, dtype='u1,u1,u1,S3')
Traceback (most recent call last)
 ...
TypeError: a bytes-like object is required, not 'str'

`numpy.core.records.fromfile`

原文：numpy.org/doc/1.26/reference/generated/numpy.core.records.fromfile.html

core.records.fromfile(fd, dtype=None, shape=None, offset=0, formats=None, names=None, titles=None, aligned=False, byteorder=None)

从二进制文件数据创建数组

参数：

fdstr 或文件类型

如果文件是字符串或类似路径的对象，则打开该文件，否则假定为文件对象。文件对象必须支持随机访问（即必须具有 tell 和 seek 方法）。

dtype数据类型，可选

所有数组的有效 dtype

shapeint 或 int 元组，可选

每个数组的形状。

offsetint，可选

从文件中开始读取的位置。

formats, names, titles, aligned, byteorder

如果 dtype 为 None，则这些参数将传递给 numpy.format_parser 以构造 dtype。有关详细文档，请参阅该函数

np.recarray

包含在文件中的数据的记录数组。

示例

>>> from tempfile import TemporaryFile
>>> a = np.empty(10,dtype='f8,i4,a5')
>>> a[5] = (0.5,10,'abcde')
>>>
>>> fd=TemporaryFile()
>>> a = a.newbyteorder('<')
>>> a.tofile(fd)
>>>
>>> _ = fd.seek(0)
>>> r=np.core.records.fromfile(fd, formats='f8,i4,a5', shape=10,
... byteorder='<')
>>> print(r[5])
(0.5, 10, 'abcde')
>>> r.shape
(10,)

`numpy.core.defchararray.array`

原文：numpy.org/doc/1.26/reference/generated/numpy.core.defchararray.array.html

core.defchararray.array(obj, itemsize=None, copy=True, unicode=None, order=None)

创建一个 chararray。

注意

此类是为了与 numarray 向后兼容而提供的。不涉及 numarray 兼容性的新代码应使用类型为bytes_或str_的数组，并使用 numpy.char 中的自由函数进行快速矢量化字符串操作。

与常规的类型为 str 或 unicode 的 NumPy 数组相比，此类新增了以下功能：

索引时，值将自动删除末尾的空白

比较操作符在比较值时会自动删除末尾的空白

矢量化字符串操作以方法的形式提供（例如 str.endswith）和中缀运算符的方式提供（例如 +, *, %）

参数：

objstr 或类似 unicode 的数组

itemsizeint, 可选

itemsize 是结果数组中每个标量的字符数。如果 itemsize 为 None，并且 obj 为对象数组或 Python 列表，则 itemsize 将被自动确定。如果提供了 itemsize 并且 obj 的类型为 str 或 unicode，则 obj 字符串将被分成 itemsize 个部分。

copybool, 可选

如果为真（默认值），则复制对象。否则，仅当 array 返回复制，obj 为嵌套序列，或者需要复制以满足其他要求（itemsize，unicode，order等）时将进行复制。

unicodebool, 可选

当为真时，生成的 chararray 可以包含 Unicode 字符，当为假时只能包含 8 位字符。如果 unicode 为 None，且 obj 是以下之一：

一个 chararray

类型为 str 或 unicode 的数组

Python str 或 unicode 对象，

然后输出数组的 unicode 设置将自动确定。

order, 可选

指定数组的顺序。如果顺序为 'C'（默认），则数组将按 C 顺序排列（最后一个索引变化最快）。如果顺序为 'F'，则返回的数组将按 Fortran 顺序排列（第一个索引变化最快）。如果顺序为 'A'，则返回的数组可以是任何顺序（C-，Fortran- 连续，甚至不连续的顺序）。

`numpy.core.defchararray.asarray`

原文：numpy.org/doc/1.26/reference/generated/numpy.core.defchararray.asarray.html

core.defchararray.asarray(obj, itemsize=None, unicode=None, order=None)

将输入转换为chararray，只在必要时复制数据。

与普通的类型为str或unicode的 NumPy 数组相比，这个类增加了以下功能：

索引时，值会自动删除末尾的空格

比较运算符在比较值时会自动删除末尾的空格

向量化字符串操作作为方法提供（例如str.endswith）和中缀运算符（例如+，*，%）

参数：

objstr 或类似 unicode 的数组

itemsizeint，可选

itemsize是结果数组中每个标量的字符数。如果itemsize为 None，并且obj是对象数组或 Python 列表，则itemsize将自动确定。如果提供itemsize并且obj是 str 或 unicode 类型，则obj字符串将被分成itemsize片段。

unicodebool，可选

当为 True 时，生成的chararray可以包含 Unicode 字符，为 False 时只包含 8 位字符。如果 unicode 为 None，obj是以下之一：

一个chararray，

一个类型为str或‘unicode’的 ndarray，

Python 的 str 或 unicode 对象，

然后将自动确定输出数组的 unicode 设置。

order，可选

指定数组的顺序。如果 order 为‘C’（默认值），则数组将以 C 连续顺序排列（最后的指数变化最快）。如果 order 为‘F’，则返回的数组将以 Fortran 连续顺序排列（第一个指数变化最快）。

posted @ 2024-06-24 14:55 绝不原创的飞龙阅读(5) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

龙哥盟

掠夺·扩张·投机·博弈

NumPy-1-26-中文文档-七-

NumPy 1.26 中文文档（七）

常量

通用函数（ufunc）

ufunc

可选关键字参数

属性

方法

可用的 ufunc

数学运算

三角函数

位操作函数

比较函数

浮点函数

ufunc

可选关键字参数

属性

方法

属性

方法

可用的 ufuncs

数学运算

三角函数

位操作函数

比较函数

浮点函数

数学运算

三角函数

位操作函数

比较函数

浮点函数

numpy.ufunc

numpy.ufunc.nin

numpy.ufunc.nout

numpy.ufunc.nargs

numpy.ufunc.ntypes

numpy.ufunc.types

numpy.ufunc.identity

numpy.ufunc.signature

numpy.ufunc.reduce

numpy.ufunc.accumulate

numpy.ufunc.reduceat

numpy.ufunc.outer

numpy.ufunc.at

例程

数组创建例程

From shape or value

From existing data

创建记录数组 (numpy.rec)

数值范围

构建矩阵

矩阵类

来自形状或值

从现有数据

创建记录数组（numpy.rec）

创建字符数组（numpy.char）

数值范围

构建矩阵

矩阵类

numpy.empty

numpy.empty_like

numpy.eye

numpy.identity

numpy.ones

numpy.ones_like

numpy.zeros

numpy.zeros_like

numpy.full

numpy.full_like

numpy.array

numpy.asarray

numpy.asanyarray

numpy.ascontiguousarray

numpy.asmatrix

numpy.copy

numpy.frombuffer

numpy.from_dlpack

numpy.fromfile

`ufunc`

`ufunc`

`numpy.ufunc`

`numpy.ufunc.nin`

`numpy.ufunc.nout`

`numpy.ufunc.nargs`

`numpy.ufunc.ntypes`

`numpy.ufunc.types`

`numpy.ufunc.identity`

`numpy.ufunc.signature`

`numpy.ufunc.reduce`

`numpy.ufunc.accumulate`

`numpy.ufunc.reduceat`

`numpy.ufunc.outer`

`numpy.ufunc.at`

创建记录数组 (`numpy.rec`)

创建记录数组（`numpy.rec`）

创建字符数组（`numpy.char`）

`numpy.empty`

`numpy.empty_like`

`numpy.eye`

`numpy.identity`

`numpy.ones`

`numpy.ones_like`

`numpy.zeros`

`numpy.zeros_like`

`numpy.full`

`numpy.full_like`

`numpy.array`

`numpy.asarray`

`numpy.asanyarray`

`numpy.ascontiguousarray`

`numpy.asmatrix`

`numpy.copy`

`numpy.frombuffer`

`numpy.from_dlpack`

`numpy.fromfile`

`numpy.fromfunction`

`numpy.fromiter`

`numpy.fromstring`

`numpy.loadtxt`

`numpy.core.records.array`

`numpy.core.records.fromarrays`

`numpy.core.records.fromrecords`

`numpy.core.records.fromstring`

`numpy.core.records.fromfile`

`numpy.core.defchararray.array`

`numpy.core.defchararray.asarray`