通用函数 (ufunc)

通用函数(或简称为ufunc)是一种以元素为单位对 ndarrays 进行操作的函数, 支持 数组广播类型转换 <ufuncs.casting>`和其他一些 标准特性。 也就是说,ufunc是一个函数的 “:term:`vectorized” 包装器,它接受固定数量的特定输 入并产生固定数量的特定输出。

在NumPy中,通用函数是 numpy.ufunc 类的实例。 许多内置函数都是在编译的C代码中实现的。 基本的ufuncs对标量进行操作,但也有一种通用类型,基本元素是子数组(向量,矩阵等), 广播是在其他维度上完成的。 也可以使用 frompyfunc 工厂函数生成自定义 ufunc 实例。

广播

每个通用函数接受数组输入并通过在输入上逐元素地执行核心函数来生成数组输出(其中 元素通常是标量,但可以是用于广义ufunc的向量或更高阶子数组)。应用标准广播规则, 以便仍然可以有效地操作不共享完全相同形状的输入。广播可以通过四个规则来理解:

  1. 所有输入数组的 ndim 小于最大输入数组的 ndim , 其形状都有1的前置值。
  2. 输出形状的每个维度中的大小是该维度中所有输入大小的最大值。
  3. 如果输入在特定维度中的大小与该维度中的输出大小匹配,或者其值正好为1,则可用于计算。
  4. 如果输入的维度大小为1,则该维度中的第一个数据输入将用于沿该维度进行的所有计算。 换句话说, ufunc 的步进机制不会沿着这个维度前进(对于这个维度,步幅是0)

整个NumPy都使用广播来决定如何处理不同形状的数组; 例如,所有算术运算 (+,``-, ``*, …) ndarrays 在操作前会在数组之间广播

如果上述规则产生有效的结果,即下列情况之一为真,则将一组数组称为“可广播的”,其形状相同:

  1. 这些数组都具有完全相同的形状。
  2. 数组都具有相同的维数,每个维度的长度是常用长度或1。
  3. 尺寸太小的数组可以使其形状前面加上长度为1的尺寸以满足属性2。

Example

如果 a.shape 是 (5,1), b.shape 是 (1,6), c.shape 是 (6,) d.shape 是 () 使得 d 是标量, 然后 a, b, c, 和 d 都可以广播到维度 (5,6)

  • a 的作用类似 (5,6) 数组,其中 a[:,0] 被广播到其他列
  • b 的作用类似 (5,6) 数组,其中 b[0,:] 被广播到其他列
  • c acts like a (1,6) array and therefore like a (5,6) array where c[:] is broadcast to every row, and finally, c 的作用类似 (1,6) 数组,因此像一个 (5,6) 数组,其中 c[:] 广播到每一行,最后,
  • d 的作用类似于(5, 6)数组,其中重复单个值

确定输出类型

如果所有输入参数都不是 ndarrays ,则ufunc(及其方法)的输出不一定是 ndarray 。 实际上,如果任何输入定义了一个 __array_ufunc__ 方法,那么控制将完全传递给该 函数,即ufunc被 覆写

如果没有任何输入覆盖ufunc,那么所有输出数组将被传递给输入的 __array_prepare____array_wrap__ 方法(除了 ndarrays 和scalars),它定义了它并具有最高的 __array_priority__ 通用函数的任何其他输入。 ndarray的默认 __array_priority__ 是0.0,子类型的默认 __array_priority__ 是1.0。矩阵的 __array_priority__ 等于10.0。

所有ufunc也可以获取输出参数。如有必要,输出将转换为提供的输出数组的数据类型。 如果输出使用带有 __array__ 方法的类,则结果将写入 __array__ 返回的对象。 然后,如果该类也有一个 __array_prepare__ 方法,则调用它,以便可以根据ufunc的上下 文确定元数据(由ufunc本身组成的上下文,传递给ufunc的参数和ufunc域) 。) 由 __array_prepare__ 返回的数组对象被传递给ufunc进行计算。最后,如果类也有 一个 __array_wrap__ 方法,返回的 ndarray 结果将在将控制权传递回调用者之前传递 给该方法。

使用内部缓冲区

在内部,缓冲区用于不对齐数据、交换数据和必须从一种数据类型转换到另一种数据类型的数据。 内部缓冲区的大小可以在每个线程的基础上设置。可以有最多2个指定大小的缓冲区

2 (n_{\mathrm{inputs}} + n_{\mathrm{outputs}})

以处理ufunc的所有输入和输出的数据。缓冲区的默认大小为10,000个元素。每当需要基于 缓冲区的计算,但所有输入数组都小于缓冲区大小时,那些行为不当或类型不正确的数组将 在计算继续之前被复制。因此,调整缓冲区的大小可能会改变完成各种ufunc计算的速度。可 以使用以下函数访问用于设置此变量的简单接口

setbufsize(size) Set the size of the buffer used in ufuncs.

错误处理

通用函数可以跳过硬件中的特殊浮点状态寄存器(如被零除)。如果在您的平台上可用, 这些寄存器将在计算过程中定期检查。错误处理是在每个线程的基础上控制的,并且可 以使用以下函数进行配置

seterr([all, divide, over, under, invalid]) Set how floating-point errors are handled.
seterrcall(func) Set the floating-point error callback function or log object.

规则变换

注解

在NumPy 1.6.0中,创建了一个类型提升API来封装用于确定输出类型的机制。 有关详细信息,请参阅函数 result_type, promote_typesmin_scalar_type

每个ufunc的核心是一个一维的跨行循环,它实现特定类型组合的实际函数。 当创建一个ufunc时,会给它一个内部循环的静态列表和一个对应的类型签名列表, ufunc对此进行操作。ufunc机制使用此列表来确定对特定情况使用哪个内部循环。 您可以检查特定ufunc的 .types 属性,以查看哪些类型组合具有定义的内环, 以及它们产生的输出类型(为简洁起见,在所述输出中使用 字符代码)。

只要ufunc没有提供输入类型的核心循环实现,就必须对一个或多个输入进行转换。 如果找不到输入类型的实现,则该算法搜索具有类型签名的实现,所有输入都可以 “安全地”转换到该实现。在所有必要的类型转换之后,选择并执行在循环的内部列 表中找到的第一个类型。回想一下,在ufuns期间(甚至对于转换),内部副本被限制 为一个内部缓冲区的大小(这是用户可设置的)。

注解

NumPy中的通用函数足够灵活,可以具有混合类型签名。因此,例如,可以定义一个 通用函数来处理浮点值和整数值。见 ldexp 的例子。

通过上面的描述,转换规则本质上是由一个数据类型何时可以“安全地”转换为另一个数据类型 的问题来实现的。这个问题的答案可以在Python中通过函数调用来确定:can_cast(fromtype, totype)。 下图显示了作者64位系统上24种内部支持类型的调用结果。您可以使用表中给出的代码为您的系统生成此表。

Figure

代码段显示一个32位系统的“可以安全地转换”表

>>> def print_table(ntypes):
...     print 'X',
...     for char in ntypes: print char,
...     print
...     for row in ntypes:
...         print row,
...         for col in ntypes:
...             print int(np.can_cast(row, col)),
...         print
>>> print_table(np.typecodes['All'])
X ? b h i l q p B H I L Q P e f d g F D G S U V O M m
? 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
b 0 1 1 1 1 1 1 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 0 0
h 0 0 1 1 1 1 1 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 0 0
i 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 1 1 0 1 1 1 1 1 1 0 0
l 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 1 1 0 1 1 1 1 1 1 0 0
q 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 1 1 0 1 1 1 1 1 1 0 0
p 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 1 1 0 1 1 1 1 1 1 0 0
B 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0
H 0 0 0 1 1 1 1 0 1 1 1 1 1 0 1 1 1 1 1 1 1 1 1 1 0 0
I 0 0 0 0 1 1 1 0 0 1 1 1 1 0 0 1 1 0 1 1 1 1 1 1 0 0
L 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 1 1 0 1 1 1 1 1 1 0 0
Q 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 1 1 0 1 1 1 1 1 1 0 0
P 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 1 1 0 1 1 1 1 1 1 0 0
e 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 0 0
f 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 0 0
d 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 1 1 1 1 1 0 0
g 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 1 1 1 1 0 0
F 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 0 0
D 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0
G 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0
S 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0
U 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0
V 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0
O 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0
M 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0
m 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1

您应该注意到,虽然表中包含了“S”、“U”和“V”类型,但不能由ufuns对它们进行操作。 另外,请注意,在32位系统中,整数类型可能有不同的大小,导致表略有改变。

混合标量数组操作使用一组不同的转换规则,以确保标量不能“向上转换”数组,除非标量 与数组具有根本不同的数据类型(即数据类型层次结构中的不同层次结构)。这条规则使您 可以在代码中使用标量常量(作为Python类型,在函数中相应地进行解释),而不必担心标 量常量的精度是否会导致大(小精度)数组的上行。

重写通用函数行为

类(包括ndarray子类)可以通过定义某些特殊方法来覆盖ufunc对它们的作用。 有关详细信息,请参阅 标准数组子类

ufunc

可选关键字参数

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

out

1.6 新版功能.

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

1.10 新版功能.

out 关键字参数应该是一个元组,每个输出有一个条目(对于由ufunc分配的数组,可以是 None )。 对于具有单个输出的函数,传递单个数组(而不是包含单个数组的元组)也是有效的。

out 关键字参数中的单个数组传递给具有多个输出的ufunc是不可取的,这将在numpy 1.10中 引发一个警告,并在未来的版本中引发一个错误。

如果 outNone (默认值),则创建未初始化的返回数组。然后,输出数组将在广播 ‘where’ 为True的 位置填充ufunc的结果。如果 ‘where’ 是标量True(默认值),那么它对应于正在填充的整个输出。注意, 未显式填充的输出保留未初始化值。

where

1.7 新版功能.

接受与操作数一起广播的布尔数组。True的值指示要计算该位置的ufunc,false的值指示要在输出中单独保留该值。 这个参数不能用在广义函数上,因为它们采用非标量输入.

注意,如果创建了未初始化的返回数组,则False值将保留未初始化的值。

axes

1.15 新版功能.

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

axis

1.15 新版功能.

一个广义的ufunc应该在其上运行的单轴。这是对运行在单个共享核心维度上的运行函数的一条捷径,相当于为每个 单核维度参数传递带有 (axis,) 条目的轴,而对于所有其他参数则传递 () 。例如,对于签名 (i),(i)->(),它等同 于传递 axes=[(axis,), (axis,), ()]

keepdims

1.15 新版功能.

如果将此设置为 True ,则将缩小的轴作为尺寸为1的维度留在结果中,以便对输入正确广播结果。 此选项只能用于对所有具有相同核心维数且输出没有核心维度的输入进行操作的ufuncs,即具 有 (i),(i)->()(m,m)->() 等签名的输出。如果使用,可以用 axesaxis 来 控制输出中尺寸的位置。

casting

1.6 新版功能.

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

提供允许何种类型的转换的策略。为了与以前版本的NumPy兼容,对于 numpy < 1.7 默认为 不安全 。在Numpy1.7中, 开始了向同一种类型的转换,在此过程中,函数生成了不安全规则下允许的调用而不是同一种规则下允许的调用 的 DeprosionationWarning。从numpy1.10到更高版本,缺省值是 same_kind

order

1.6 新版功能.

指定输出数组的计算迭代顺序/内存布局。默认值为 KC 意味着输出应该是C-连续的,F 意味着F-连续的, A 意味着F-连续的,如果输入是F-连续的,并且不是C-连续的,否则,C-连续的意思是 K 意味着尽可能紧密地 匹配输入的元素顺序。

dtype

1.6 新版功能.

重写计算和输出数组的dtype。类似于签名

subok

1.6 新版功能.

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

signature

数据类型、数据类型的元组或指示ufunc的输入和输出类型的特殊签名字符串。此参数允许您为 基础计算中使用的1-d循环提供特定的签名。如果为ufunc指定的循环不存在,则会引发TypeError。 通常,通过将输入类型与可用的类型进行比较,并搜索具有所有输入都可以安全转换到的数据类型的 循环,可以自动找到合适的循环。这个关键字参数允许您绕过搜索并选择一个特定的循环。ufunc对象 的type属性提供可用签名的列表。为了向后兼容,这个参数也可以作为sig提供,尽管长格式更受欢迎。 请注意,这不应与存储在ufunc对象的 签名 属性中的通用 ufunc签名相混淆。

extobj

长度为1,2或3的列表,指定ufunc缓冲区大小,错误模式整数和错误回调函数。通常,这些值在特定于线程 的字典中查找。将它们传递到此处会绕过查找并使用为错误模式提供的低级规范。这可能是有用的,作为在 循环中需要对小数组进行许多ufunc调用的计算的优化。

属性

通用函数具有一些信息属性。不能设置任何属性。

__doc__ 每个ufunc的文档字符串。 docstring的第一部分是根据输出数量, 名称和输入数量动态生成的。 docstring的第二部分在创建时提供并 与ufunc一起存储。
__name__ ufunc的名称
ufunc.nin The number of inputs.
ufunc.nout The number of outputs.
ufunc.nargs The number of arguments.
ufunc.ntypes The number of types.
ufunc.types Returns a list with types grouped input->output.
ufunc.identity The identity value.
ufunc.signature Definition of the core elements a generalized ufunc operates on.

方法

所有ufunc都有四种方法。但是,这些方法仅对采用两个输入参数并返回一个输出参数的标量ufunc有意义。 试图在其他ufunc上调用这些方法会导致 ValueError 。类似reduce的方法都采用 axis 关键字, dtype 关键字和 ou t关键字,并且数组必须都具有维 >= 1.轴关键字指定将在其上进行缩减的数组的轴(具有负数)值 倒计时)。通常,它是一个整数,但对于 ufunc.reduce ,它也可以是int的元组,一次减少多个轴,或者无,以减少 所有轴。dtype关键字允许您管理在天真地使用 ufunc.reduce 时出现的一个非常常见的问题。有时您可能拥有某种 数据类型的数组,并希望将其所有元素相加,但结果不适合数组的数据类型。如果您有一个单字节整数数组,通常会 发生这种情况。 dtype关键字允许您更改减少发生的数据类型(以及输出的类型)。因此,您可以确保输出是一种精 度足以处理输出的数据类型。改变减少类型的责任主要取决于你。有一个例外:如果没有为“add”或“multiply”操作 减少dtype,那么如果输入类型是整数(或布尔)数据类型且小于int_的大小数据类型,它将内部向上转换为 int_ (或 uint )数据类型。最后,out关键字允许您提供一个输出数组(对于单输出ufunc,这是当前唯一支持的; 对于将来的扩展,但是,可以传入一个带有单个参数的元组)。如果给出out,则忽略dtype参数。

Ufuncs还有第五种方法,允许使用花式索引来执行就地操作。在使用花式索引的维度上不使用缓冲,因此花式索引可以多次列 出项目,并且将对该项目的上一个操作的结果执行操作。

ufunc.reduce(a[, axis, dtype, out, keepdims]) Reduces a’s dimension by one, by applying ufunc along one axis.
ufunc.accumulate(array[, axis, dtype, out]) Accumulate the result of applying the operator to all elements.
ufunc.reduceat(a, indices[, axis, dtype, out]) Performs a (local) reduce with specified slices over a single axis.
ufunc.outer(A, B, **kwargs) Apply the ufunc op to all pairs (a, b) with a in A and b in B.
ufunc.at(a, indices[, b]) Performs unbuffered in place operation on operand ‘a’ for elements specified by ‘indices’.

警告

对数组类型进行类似reduce的操作,其数据类型的范围“太小”,无法处理结果, 将以静默方式进行换行。应该使用 dtype 来增加减少发生的数据类型的大小。

可用的通用函数列表

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

回想一下,每个ufunc都是逐个元素运行的。 因此,每个标量ufunc将被描述为如果作用 于一组标量输入以返回一组标量输出。

注解

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

数学运算

add(x1, x2, /[, out, where, casting, order, …]) Add arguments element-wise.
subtract(x1, x2, /[, out, where, casting, …]) Subtract arguments, element-wise.
multiply(x1, x2, /[, out, where, casting, …]) Multiply arguments element-wise.
divide(x1, x2, /[, out, where, casting, …]) Divide arguments element-wise.
logaddexp(x1, x2, /[, out, where, casting, …]) Logarithm of the sum of exponentiations of the inputs.
logaddexp2(x1, x2, /[, out, where, casting, …]) Logarithm of the sum of exponentiations of the inputs in base-2.
true_divide(x1, x2, /[, out, where, …]) Returns a true division of the inputs, element-wise.
floor_divide(x1, x2, /[, out, where, …]) Return the largest integer smaller or equal to the division of the inputs.
negative(x, /[, out, where, casting, order, …]) Numerical negative, element-wise.
positive(x, /[, out, where, casting, order, …]) Numerical positive, element-wise.
power(x1, x2, /[, out, where, casting, …]) First array elements raised to powers from second array, element-wise.
remainder(x1, x2, /[, out, where, casting, …]) Return element-wise remainder of division.
mod(x1, x2, /[, out, where, casting, order, …]) Return element-wise remainder of division.
fmod(x1, x2, /[, out, where, casting, …]) Return the element-wise remainder of division.
divmod(x1, x2[, out1, out2], / [[, out, …]) Return element-wise quotient and remainder simultaneously.
absolute(x, /[, out, where, casting, order, …]) Calculate the absolute value element-wise.
fabs(x, /[, out, where, casting, order, …]) Compute the absolute values element-wise.
rint(x, /[, out, where, casting, order, …]) Round elements of the array to the nearest integer.
sign(x, /[, out, where, casting, order, …]) Returns an element-wise indication of the sign of a number.
heaviside(x1, x2, /[, out, where, casting, …]) Compute the Heaviside step function.
conj(x, /[, out, where, casting, order, …]) Return the complex conjugate, element-wise.
exp(x, /[, out, where, casting, order, …]) Calculate the exponential of all elements in the input array.
exp2(x, /[, out, where, casting, order, …]) Calculate 2**p for all p in the input array.
log(x, /[, out, where, casting, order, …]) Natural logarithm, element-wise.
log2(x, /[, out, where, casting, order, …]) Base-2 logarithm of x.
log10(x, /[, out, where, casting, order, …]) Return the base 10 logarithm of the input array, element-wise.
expm1(x, /[, out, where, casting, order, …]) Calculate exp(x) - 1 for all elements in the array.
log1p(x, /[, out, where, casting, order, …]) Return the natural logarithm of one plus the input array, element-wise.
sqrt(x, /[, out, where, casting, order, …]) Return the non-negative square-root of an array, element-wise.
square(x, /[, out, where, casting, order, …]) Return the element-wise square of the input.
cbrt(x, /[, out, where, casting, order, …]) Return the cube-root of an array, element-wise.
reciprocal(x, /[, out, where, casting, …]) Return the reciprocal of the argument, element-wise.
gcd(x1, x2, /[, out, where, casting, order, …]) Returns the greatest common divisor of |x1| and |x2|
lcm(x1, x2, /[, out, where, casting, order, …]) Returns the lowest common multiple of |x1| and |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, …]) Trigonometric sine, element-wise.
cos(x, /[, out, where, casting, order, …]) Cosine element-wise.
tan(x, /[, out, where, casting, order, …]) Compute tangent element-wise.
arcsin(x, /[, out, where, casting, order, …]) Inverse sine, element-wise.
arccos(x, /[, out, where, casting, order, …]) Trigonometric inverse cosine, element-wise.
arctan(x, /[, out, where, casting, order, …]) Trigonometric inverse tangent, element-wise.
arctan2(x1, x2, /[, out, where, casting, …]) Element-wise arc tangent of x1/x2 choosing the quadrant correctly.
hypot(x1, x2, /[, out, where, casting, …]) Given the “legs” of a right triangle, return its hypotenuse.
sinh(x, /[, out, where, casting, order, …]) Hyperbolic sine, element-wise.
cosh(x, /[, out, where, casting, order, …]) Hyperbolic cosine, element-wise.
tanh(x, /[, out, where, casting, order, …]) Compute hyperbolic tangent element-wise.
arcsinh(x, /[, out, where, casting, order, …]) Inverse hyperbolic sine element-wise.
arccosh(x, /[, out, where, casting, order, …]) Inverse hyperbolic cosine, element-wise.
arctanh(x, /[, out, where, casting, order, …]) Inverse hyperbolic tangent element-wise.
deg2rad(x, /[, out, where, casting, order, …]) Convert angles from degrees to radians.
rad2deg(x, /[, out, where, casting, order, …]) Convert angles from radians to degrees.

比特函数

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

bitwise_and(x1, x2, /[, out, where, …]) Compute the bit-wise AND of two arrays element-wise.
bitwise_or(x1, x2, /[, out, where, casting, …]) Compute the bit-wise OR of two arrays element-wise.
bitwise_xor(x1, x2, /[, out, where, …]) Compute the bit-wise XOR of two arrays element-wise.
invert(x, /[, out, where, casting, order, …]) Compute bit-wise inversion, or bit-wise NOT, element-wise.
left_shift(x1, x2, /[, out, where, casting, …]) Shift the bits of an integer to the left.
right_shift(x1, x2, /[, out, where, …]) Shift the bits of an integer to the right.

比较函数

greater(x1, x2, /[, out, where, casting, …]) Return the truth value of (x1 > x2) element-wise.
greater_equal(x1, x2, /[, out, where, …]) Return the truth value of (x1 >= x2) element-wise.
less(x1, x2, /[, out, where, casting, …]) Return the truth value of (x1 < x2) element-wise.
less_equal(x1, x2, /[, out, where, casting, …]) Return the truth value of (x1 =< x2) element-wise.
not_equal(x1, x2, /[, out, where, casting, …]) Return (x1 != x2) element-wise.
equal(x1, x2, /[, out, where, casting, …]) Return (x1 == x2) element-wise.

警告

不要使用Python关键字 andor 组合逻辑数组表达式。这些关键字将测试整个数组的 真值(而不是您可能预期的逐个元素)。使用位运算符 &|

logical_and(x1, x2, /[, out, where, …]) Compute the truth value of x1 AND x2 element-wise.
logical_or(x1, x2, /[, out, where, casting, …]) Compute the truth value of x1 OR x2 element-wise.
logical_xor(x1, x2, /[, out, where, …]) Compute the truth value of x1 XOR x2, element-wise.
logical_not(x, /[, out, where, casting, …]) Compute the truth value of NOT x element-wise.

警告

位运算符 &| 是执行逐元素数组比较的正确方法。确保您理解操作符优先级: (a > 2) & (a < 5) 是正确的语法,因为 a > 2 & a < 5 将导致错误,因为首先计算 2 & a

maximum(x1, x2, /[, out, where, casting, …]) Element-wise maximum of array elements.

小技巧

Python函数 max() 将会在一维数组中找到最大值,但是它会使用较慢的序列接口来完成。 最大的ufunc的减少方法要快得多。另外,max() 方法不会给出您可能期望的大于一维的 数组的答案。最小值方法还允许您计算一个数组的总最小值。

minimum(x1, x2, /[, out, where, casting, …]) Element-wise minimum of array elements.

警告

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

fmax(x1, x2, /[, out, where, casting, …]) Element-wise maximum of array elements.
fmin(x1, x2, /[, out, where, casting, …]) Element-wise minimum of array elements.

浮点数函数

回想一下,所有这些函数都在数组上逐个工作,返回数组输出。描述只详细说明了一个操作。

isfinite(x, /[, out, where, casting, order, …]) Test element-wise for finiteness (not infinity or not Not a Number).
isinf(x, /[, out, where, casting, order, …]) Test element-wise for positive or negative infinity.
isnan(x, /[, out, where, casting, order, …]) Test element-wise for NaN and return result as a boolean array.
isnat(x, /[, out, where, casting, order, …]) Test element-wise for NaT (not a time) and return result as a boolean array.
fabs(x, /[, out, where, casting, order, …]) Compute the absolute values element-wise.
signbit(x, /[, out, where, casting, order, …]) Returns element-wise True where signbit is set (less than zero).
copysign(x1, x2, /[, out, where, casting, …]) Change the sign of x1 to that of x2, element-wise.
nextafter(x1, x2, /[, out, where, casting, …]) Return the next floating-point value after x1 towards x2, element-wise.
spacing(x, /[, out, where, casting, order, …]) Return the distance between x and the nearest adjacent number.
modf(x[, out1, out2], / [[, out, where, …]) Return the fractional and integral parts of an array, element-wise.
ldexp(x1, x2, /[, out, where, casting, …]) Returns x1 * 2**x2, element-wise.
frexp(x[, out1, out2], / [[, out, where, …]) Decompose the elements of x into mantissa and twos exponent.
fmod(x1, x2, /[, out, where, casting, …]) Return the element-wise remainder of division.
floor(x, /[, out, where, casting, order, …]) Return the floor of the input, element-wise.
ceil(x, /[, out, where, casting, order, …]) Return the ceiling of the input, element-wise.
trunc(x, /[, out, where, casting, order, …]) Return the truncated value of the input, element-wise.