So verwenden Sie die Funktion numpy.ufunc in Python

1. Erklärung

                                                Welche Funktion hat numpy.ufunc? Antwort: Es handelt sich um eine Numpy-Funktion, da Numpy auf Array-Tensoren abzielt, sodass fast jede Funktion eine Ufunc ist. Y 2. Numpy.ufunc-Funktionskonzept

2.1 numpy.ufunc-Profil

Die Funktion, die von Elementen im gesamten Array betrieben wird. Daher ist ufunc ein allgemeiner Begriff und es gibt viele dieser Funktionen.

                                                                                                                                         Eine universelle Funktion (oder kurz ufunc) ist eine Funktion, die elementweise auf ndarrays arbeitet und Array-Broadcasting, Typkonvertierung und einige andere Standardfunktionen unterstützt. Ufunc ist ein Wrapper, der eine Funktion „vektorisiert“, indem er eine feste Anzahl spezifischer Eingaben entgegennimmt und eine feste Anzahl spezifischer Ausgaben erzeugt. Weitere Informationen zur zugrunde liegenden universellen Funktion (ufunc) finden Sie hier.

In NumPy sind allgemeine Funktionen Instanzen der Klasse numpy.ufunc. Viele integrierte Funktionen werden in kompiliertem C-Code implementiert. Grundlegende Ufuncs arbeiten mit Skalaren, es gibt aber auch einen generischen Typ, bei dem die Grundelemente Subarrays (Vektoren, Matrizen usw.) sind und die Übertragung in anderen Dimensionen erfolgt. Sie können auch ufunc die Factory-Funktion „frompyfuncopen in new window“ verwenden, um eine benutzerdefinierte Instanz zu generieren.

2.2 numpy.ufunc.nin und numpy.ufunc.noutnumpy.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的向量或更高阶子数组）。按照标准广播规则进行操作，以确保即使输入不具有完全相同的形状，仍能有效进行操作。 广播可以通过四个规则来理解：

1. 所有输入数组都ndimopen in new window小于最大的输入数组，ndimopen in new window其形状前面有1个。

2. 输出形状的每个维度的大小是该维度中所有输入大小的最大值。

3. 如果输入在特定维度中的大小与该维度中的输出大小匹配，或者其值正好为1，则可以在计算中使用该输入。

4. 当形状尺寸为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

Diese Funktion drückt die Anzahl der Eingabeparameter aus, die der ufun-Funktion entsprechen, wie unten gezeigt.

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 )

• Diese Funktion drückt die Anzahl der Ausgabeparameter aus, die der ufun-Funktion entsprechen, beispielsweise die entsprechende Anzahl von Eingabeparametern für die folgende ufunc. 2.3 numpy.ufunc.nargs .ufunc.ntypes                                                                                                        Gibt das Eingabedatentypformat eines ufunc an: die Anzahl der numerischen NumPy-Typen, die ufunc verarbeiten kann – insgesamt 18. 2.5 numpy.ufunc.type bezieht sich auf jede Dimension. Die Länge des Vektors in Dimensionen. Zum Beispiel das folgende Beispiel:

  a = np.arange(3)
  b = np.arange(3)[:, np.newaxis]
   
  print(a)
  print(b)

  Ergebnis:

1
(3,)
3
(2, 3, 4)

3. Übertragung von ufunc-Funktionen: Jede allgemeine Funktion akzeptiert die Array-Eingabe und generiert die Array-Ausgabe, indem sie die Kernfunktionen an der Eingabe ausführt (wobei das Element normalerweise der Skalar ist, es sich jedoch im Allgemeinen um einen Vektor oder ein höheres Unterarray für UFUNC handeln kann). Befolgen Sie die Standardübertragungsregeln, um sicherzustellen, dass der Vorgang auch dann effizient funktioniert, wenn die Eingaben nicht genau die gleiche Form haben. Broadcasting kann durch vier Regeln verstanden werden: 🎜
🎜🎜Alle Eingabearrays sind kleiner als das größte Eingabearray, ndimopen in new window, dessen Form 1 vorangestellt ist. 🎜🎜🎜🎜Die Größe jeder Dimension der Ausgabeform ist das Maximum aller Eingabegrößen in dieser Dimension. 🎜🎜🎜🎜Wenn die Größe der Eingabe in einer bestimmten Dimension mit der Größe der Ausgabe in dieser Dimension übereinstimmt oder ihr Wert genau 1 ist, kann die Eingabe in der Berechnung verwendet werden. 🎜🎜🎜🎜Wenn die Formdimension 1 ist, wird der erste Dateneintrag in dieser Dimension für alle Berechnungen entlang dieser Dimension verwendet. Mit anderen Worten, die Schrittmaschine von ufuncopen in neuem Fenster wird diese Dimension nicht schrittweise durchlaufen (die Schrittweite beträgt für diese Dimension 0). 🎜🎜
🎜 Broadcasting wird in NumPy verwendet, um zu entscheiden, wie mit Arrays unterschiedlicher Form umgegangen wird; zum Beispiel mit allen arithmetischen Operationen (+, -, ). *</ code>, ...) ndarrays werden vor Array-Operationen in einem neuen Fenster gesendet. 🎜🎜          Eine Reihe von Arrays gilt als „broadcastbar“ in die gleiche Form, wenn die oben genannten Regeln gültige Ergebnisse liefern, das heißt, eine der folgenden Bedingungen ist erfüllt: 🎜🎜🎜🎜Die Arrays haben alle genau die gleiche Form. 🎜🎜🎜🎜Arrays haben alle die gleiche Anzahl an Dimensionen und die Länge jeder Dimension ist die gemeinsame Länge oder 1. 🎜🎜🎜🎜Die Form eines Arrays mit zu kleinen Abmessungen kann einer Dimension der Länge 1 vorangestellt werden, um Attribut 2 zu erfüllen. 🎜🎜</ul>🎜 Wenn <code>a.shape (5,1) ist, ist b.shape (1,6), c.shape</ code> code> ist (6,) und <code>d.shape ist (), so dass d ein Skalar ist, dann können a , b , c und d alle in die Dimensionen (5, 6) übertragen werden; und: 🎜🎜🎜 🎜a verhält sich wie ein (5,6)-Array, wobei [:, 0] an andere Spalten sendet, 🎜🎜🎜🎜b verhält sich wie ein (5,6)-Array, wobei b[0, :] Übertragungen an andere Kolumnen OK, 🎜

• 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 时，ufunc 的结果将被赋值给 out 数组。在其他地方，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):

Das obige ist der detaillierte Inhalt vonSo verwenden Sie die Funktion numpy.ufunc in Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!