mirror of
https://github.com/apachecn/ailearning.git
synced 2026-02-08 04:46:15 +08:00
317 lines
4.0 KiB
Markdown
317 lines
4.0 KiB
Markdown
# ufunc 对象
|
||
|
||
**Numpy** 有两种基本对象：`ndarray (N-dimensional array object)` 和 `ufunc (universal function object)`。`ndarray` 是存储单一数据类型的多维数组，而 `ufunc` 则是能够对数组进行处理的函数。
|
||
|
||
例如，我们之前所接触到的二元操作符对应的 **Numpy** 函数，如 `add`，就是一种 `ufunc` 对象，它可以作用于数组的每个元素。
|
||
|
||
In [1]:
|
||
|
||
```py
|
||
import numpy as np
|
||
|
||
```
|
||
|
||
In [2]:
|
||
|
||
```py
|
||
a = np.array([0,1,2])
|
||
b = np.array([2,3,4])
|
||
|
||
np.add(a, b)
|
||
|
||
```
|
||
|
||
Out[2]:
|
||
|
||
```py
|
||
array([2, 4, 6])
|
||
```
|
||
|
||
查看支持的方法：
|
||
|
||
In [3]:
|
||
|
||
```py
|
||
dir(np.add)
|
||
|
||
```
|
||
|
||
Out[3]:
|
||
|
||
```py
|
||
['__call__',
|
||
'__class__',
|
||
'__delattr__',
|
||
'__doc__',
|
||
'__format__',
|
||
'__getattribute__',
|
||
'__hash__',
|
||
'__init__',
|
||
'__name__',
|
||
'__new__',
|
||
'__reduce__',
|
||
'__reduce_ex__',
|
||
'__repr__',
|
||
'__setattr__',
|
||
'__sizeof__',
|
||
'__str__',
|
||
'__subclasshook__',
|
||
'accumulate',
|
||
'at',
|
||
'identity',
|
||
'nargs',
|
||
'nin',
|
||
'nout',
|
||
'ntypes',
|
||
'outer',
|
||
'reduce',
|
||
'reduceat',
|
||
'signature',
|
||
'types']
|
||
```
|
||
|
||
除此之外，大部分能够作用于数组的数学函数如三角函数等，都是 `ufunc` 对象。
|
||
|
||
特别地，对于二元操作符所对应的 `ufunc` 对象，支持以下方法：
|
||
|
||
## reduce 方法
|
||
|
||
```py
|
||
op.reduce(a)
|
||
```
|
||
|
||
将`op`沿着某个轴应用，使得数组 `a` 的维数降低一维。
|
||
|
||
add 作用到一维数组上相当于求和：
|
||
|
||
$$ \begin{align} y & = add.recuce(a) \\ & = a[0] + a[1] + ... + a[N-1] \\ & = \sum_{n=0}^{N-1} a[n] \end{align} $$In [4]:
|
||
|
||
```py
|
||
a = np.array([1,2,3,4])
|
||
|
||
np.add.reduce(a)
|
||
|
||
```
|
||
|
||
Out[4]:
|
||
|
||
```py
|
||
10
|
||
```
|
||
|
||
多维数组默认只按照第一维进行运算：
|
||
|
||
In [5]:
|
||
|
||
```py
|
||
a = np.array([[1,2,3],[4,5,6]])
|
||
|
||
np.add.reduce(a)
|
||
|
||
```
|
||
|
||
Out[5]:
|
||
|
||
```py
|
||
array([5, 7, 9])
|
||
```
|
||
|
||
指定维度：
|
||
|
||
In [6]:
|
||
|
||
```py
|
||
np.add.reduce(a, 1)
|
||
|
||
```
|
||
|
||
Out[6]:
|
||
|
||
```py
|
||
array([ 6, 15])
|
||
```
|
||
|
||
作用于字符串：
|
||
|
||
In [7]:
|
||
|
||
```py
|
||
a = np.array(['ab', 'cd', 'ef'], np.object)
|
||
|
||
np.add.reduce(a)
|
||
|
||
```
|
||
|
||
Out[7]:
|
||
|
||
```py
|
||
'abcdef'
|
||
```
|
||
|
||
逻辑运算：
|
||
|
||
In [8]:
|
||
|
||
```py
|
||
a = np.array([1,1,0,1])
|
||
|
||
np.logical_and.reduce(a)
|
||
|
||
```
|
||
|
||
Out[8]:
|
||
|
||
```py
|
||
False
|
||
```
|
||
|
||
In [9]:
|
||
|
||
```py
|
||
np.logical_or.reduce(a)
|
||
|
||
```
|
||
|
||
Out[9]:
|
||
|
||
```py
|
||
True
|
||
```
|
||
|
||
## accumulate 方法
|
||
|
||
```py
|
||
op.accumulate(a)
|
||
```
|
||
|
||
`accumulate` 可以看成保存 `reduce` 每一步的结果所形成的数组。
|
||
|
||
$$ \begin{align} y & = add.accumulate(a) \\ & = \left[\sum_{n=0}^{0} a[n], \sum_{n=0}^{1} a[n], ..., \sum_{n=0}^{N-1} a[n]\right] \end{align} $$
|
||
|
||
与之前类似：
|
||
|
||
In [10]:
|
||
|
||
```py
|
||
a = np.array([1,2,3,4])
|
||
|
||
np.add.accumulate(a)
|
||
|
||
```
|
||
|
||
Out[10]:
|
||
|
||
```py
|
||
array([ 1, 3, 6, 10])
|
||
```
|
||
|
||
In [11]:
|
||
|
||
```py
|
||
a = np.array(['ab', 'cd', 'ef'], np.object)
|
||
|
||
np.add.accumulate(a)
|
||
|
||
```
|
||
|
||
Out[11]:
|
||
|
||
```py
|
||
array(['ab', 'abcd', 'abcdef'], dtype=object)
|
||
```
|
||
|
||
In [12]:
|
||
|
||
```py
|
||
a = np.array([1,1,0,1])
|
||
|
||
np.logical_and.accumulate(a)
|
||
|
||
```
|
||
|
||
Out[12]:
|
||
|
||
```py
|
||
array([ True, True, False, False], dtype=bool)
|
||
```
|
||
|
||
In [13]:
|
||
|
||
```py
|
||
np.logical_or.accumulate(a)
|
||
|
||
```
|
||
|
||
Out[13]:
|
||
|
||
```py
|
||
array([ True, True, True, True], dtype=bool)
|
||
```
|
||
|
||
## reduceat 方法
|
||
|
||
```py
|
||
op.reduceat(a, indices)
|
||
```
|
||
|
||
`reduceat` 方法将操作符运用到指定的下标上，返回一个与 `indices` 大小相同的数组：
|
||
|
||
$$ \begin{align} y & = add.reduceat(a, indices) \\ & = \left[\sum_{n=indice[0]}^{indice[1]-1} a[n], \sum_{n=indice[1]}^{indice[2]-1} a[n], ..., \sum_{n=indice[-1]}^{N-1} a[n]\right] \end{align} $$In [14]:
|
||
|
||
```py
|
||
a = np.array([0, 10, 20, 30, 40, 50])
|
||
indices = np.array([1,4])
|
||
|
||
np.add.reduceat(a, indices)
|
||
|
||
```
|
||
|
||
Out[14]:
|
||
|
||
```py
|
||
array([60, 90])
|
||
```
|
||
|
||
这里，`indices` 为 `[1, 4]`，所以 `60` 表示从下标1（包括）加到下标4（不包括）的结果，`90` 表示从下标4（包括）加到结尾的结果。
|
||
|
||
## outer 方法
|
||
|
||
```py
|
||
op.outer(a, b)
|
||
```
|
||
|
||
对于 `a` 中每个元素，将 `op` 运用到它和 `b` 的每一个元素上所得到的结果：
|
||
|
||
In [15]:
|
||
|
||
```py
|
||
a = np.array([0,1])
|
||
b = np.array([1,2,3])
|
||
|
||
np.add.outer(a, b)
|
||
|
||
```
|
||
|
||
Out[15]:
|
||
|
||
```py
|
||
array([[1, 2, 3],
|
||
[2, 3, 4]])
|
||
```
|
||
|
||
注意有顺序的区别：
|
||
|
||
In [16]:
|
||
|
||
```py
|
||
np.add.outer(b, a)
|
||
|
||
```
|
||
|
||
Out[16]:
|
||
|
||
```py
|
||
array([[1, 2],
|
||
[2, 3],
|
||
[3, 4]])
|
||
``` |