这篇“Python中的numpy.ufunc函数怎么使用”文章的知识点大部分人都不太理解，所以小编给大家总结了以下内容，内容详细，步骤清晰，具有一定的借鉴价值，希望大家阅读完这篇文章能有所收获，下面我们一起来看看这篇“Python中的numpy.ufunc函数怎么使用”文章吧。
一、说明
numpy.ufunc是什么函数？答曰：就是numpy的函数，因为numpy针对的是数组张量，因此，几乎每一个函数都是ufunc。
二、numpy.ufunc函数概念
2.1 numpy.ufunc简介
在整个数组上逐个元素地操作的函数。因此，ufunc是个泛指，这些函数为数众多。
通用函数（或简称 ufunc）是一种以逐个元素的方式对 ndarrays 进行操作的函数，支持数组广播、类型转换和其他一些标准功能。也就是说，ufunc 是函数的“矢量化”包装器，它采用固定数量的特定输入并产生固定数量的特定输出。有关通用函数的详细信息，请参阅通用函数 (ufunc) 基础知识。
在NumPy中，通函数是
numpy.ufunc类的实例 。 许多内置函数都是在编译的C代码中实现的。 基本的ufuncs对标量进行操作，但也有一种通用类型，基本元素是子数组（向量，矩阵等）， 广播是在其他维度上完成的。也可以
ufunc使用frompyfuncopen in new window工厂函数生成自定义实例。
2.2 numpy.ufunc.nin和numpy.ufunc.nout
该函数表述出对应ufun函数的输入参数数量，如下列ufunc时对应的输入参数个数。
np.add.nin 2 np.multiply.nin 2 np.power.nin 2 np.exp.nin 2
该函数表述出对应ufun函数的输出参数数量，如下列ufunc时对应的输入参数个数。
np.add.nout 1 np.multiply.nout 1 np.power.nout 1 np.exp.nout 1
2.3 numpy.ufunc.nargs
numpy.ufunc对应参数的个数，
np.add.nargs 3 np.multiply.nargs 3 np.power.nargs 3 np.exp.nargs 2
如np.add函数有三个参数，两个输入，一个输出，如下：
a = np.array([2,4,5,6]) b = np.array([2,2,3,3]) c = np.zeros((4,)) np.add( a,b,c ) print( c )
2.4 numpy.ufunc.ntypes
表明一个ufunc的输入数据类型格式：ufunc 可以操作的数字 NumPy 类型的数量——总共有 18 种。
np.add.ntypes 18 np.multiply.ntypes 18 np.power.ntypes 17 np.exp.ntypes 7 np.remainder.ntypes 14
2.5 numpy.ufunc.type
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']
2.6 维度ndim和shape
表明维度的参数有两个，array.ndim 和 array.shape,其中ndim是指张量共几个维度，shape是指每个维度下的向量长度。比如下例：
x = np.array([1, 2, 3]) print(x.ndim) print(x.shape) y = np.zeros((2, 3, 4)) print(y.ndim) print(y.shape)
结果：
1
(3,)
3
(2, 3, 4)
三、ufunc的广播特性
每个通函数接受数组输入并通过在输入上逐元素地执行核心功能来生成数组输出（其中元素通常是标量，但可以是用于广义ufunc的向量或更高阶子数组）。 应用标准广播规则，以便仍然可以有效地操作不共享完全相同形状的输入。 广播可以通过四个规则来理解：
所有输入数组都ndimopen in new window小于最大的输入数组，ndimopen in new window其形状前面有1个。
输出形状的每个维度的大小是该维度中所有输入大小的最大值。
如果输入在特定维度中的大小与该维度中的输出大小匹配，或者其值正好为1，则可以在计算中使用该输入。
如果输入的形状尺寸为1，则该维度中的第一个数据条目将用于沿该维度的所有计算。换句话说，ufuncopen in new window的步进机械 将不会沿着该维度步进（对于该维度，步幅将为0）。
整个NumPy使用广播来决定如何处理不同形状的数组; 例如，所有算术运算（
+，
-，
*之间，...）ndarraysopen in new window的数组操作之前广播。
如果上述规则产生有效结果，则将一组数组称为“可广播”到相同的形状， 即 满足下列条件之一：
数组都具有完全相同的形状。
数组都具有相同的维数，每个维度的长度是公共长度或1。
尺寸太小的数组可以使其形状前置为长度为1的尺寸以满足属性2。
如果
a.shape是 (5,1)，
b.shape是 (1,6)，
c.shape是 (6，)并且
d.shape是 () 使得 d 是标量，则 a ， b ， c 和 d 都可以广播到维度 (5, 6); 和：
a 的作用类似于（5,6）数组，其中 [:, 0] 广播到其他列，
b 的作用类似于（5,6）数组，其中 b[0, :] 广播到其他行，
c 就像一个（1,6）数组，因此像一个（5,6）数组，其中 c[:] 广播到每一行，最后，
d 的作用类似于（5,6）数组，其中重复单个值。
四、函数格式
可以在通用函数 (ufunc) 的文档中找到有关 ufunc 的详细说明。
调用ufuncs格式:
op( *x[, out], where=True, **kwargs)
将 op 应用于参数 *x elementwise，广播参数。
广播规则是：
长度为 1 的维度可以添加到任一数组之前。
数组可以沿长度为 1 的维度重复。
参数：
*xarray_like
outndarray，None，或 ndarray 和 None 的元组，可选
用于放置结果的备用数组对象；如果提供，它必须具有输入广播的形状。数组元组（可能仅作为关键字参数）的长度必须等于输出的数量；对 ufunc 分配的未初始化输出使用 None。
wherearray_like，可选
此条件通过输入广播。在条件为 True 的位置，out 数组将设置为 ufunc 结果。在其他地方，out 数组将保留其原始值。请注意，如果通过默认 out=None 创建未初始化的 out 数组，则其中条件为 False 的位置将保持未初始化状态。
五、示例详解
5.1 用输出参数
a = np.array([2,4,5,6]) b = np.array([2,2,3,3]) c = np.zeros((4,)) np.add( a,b,c ) print( c )
5.2 行数组和列数组
a = np.arange(3) b = np.arange(3)[:, np.newaxis] print(a) print(b)
输出：
[0 1 2]
[[0]
[1]
[2]]
5.3 广播规则示例
a = np.arange(3) b = np.arange(3)[:, np.newaxis] print(a) print(b) s = a + b print(s)
六、ufunc后的数列运算
6.1 数列运算
在执行ufunc运算后，常常伴随数列运算，它们如下
__call__(*args, **kwargs) | Call self as a function. |
accumulate(array[, axis, dtype, out]) | Accumulate the result of applying the operator to all elements. |
at(a, indices[, b]) | Performs unbuffered in place operation on operand 'a' for elements specified by 'indices'. |
outer(A, B, /, **kwargs) | Apply the ufunc op to all pairs (a, b) with a in A and b in B. |
reduce(array[, axis, dtype, out, keepdims, ...]) | Reduces array's dimension by one, by applying ufunc along one axis. |
reduceat(array, indices[, axis, dtype, out]) | Performs a (local) reduce with specified slices over a single axis. |
resolve_dtypes(dtypes, *[, signature, ...]) | Find the dtypes NumPy will use for the operation. |
6.2 累计模式
累计模式不可以单独使用，而是与add以及multiply搭配使用：
np.add.accumulate([2, 3, 5]) array([ 2, 5, 10]) np.multiply.accumulate([2, 3, 5]) array([ 2, 6, 30])
np.add.accumulate(I, 0) array([[1., 0.], [1., 1.]]) np.add.accumulate(I) # no axis specified = axis zero array([[1., 0.], [1., 1.]])
6.3 对数组中某个index的元素进行局部处理
1) 将项目 0 和 1 设置为负值：
a = np.array([1, 2, 3, 4]) np.negative.at(a, [0, 1]) print( a ) array([-1, -2, 3, 4])
2) 递增项目 0 和 1，递增项目 2 两次：
a = np.array([1, 2, 3, 4]) np.add.at(a, [0, 1, 2, 2], 1) print( a ) array([2, 3, 5, 4])
3) 将第一个数组中的项 0 和 1 添加到第二个数组，并将结果存储在第一个数组中：
a = np.array([1, 2, 3, 4]) b = np.array([1, 2]) np.add.at(a, [0, 1], b) print(a) array([2, 4, 3, 4])
6.4 outer外积
简单数组外积
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]]]])
6.5 reduce方法
a = np.multiply.reduce([2,3,5]) print( a) 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 关键字参数以不同的值初始化缩减，以及在何处选择要包含的特定元素：
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
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):