python - 使用 numpy ufuncs 与内置运算符

Question

我很好奇使用 numpy 的好处和权衡 ufuncs vs. 内置运算符 vs. 内置运算符的“函数”版本。

我对所有 ufunc 都很好奇。也许有些时候有些比其他更有用。但是，我将使用 <我的例子只是为了简单起见。

有几种方法可以通过单个数字“过滤”numpy 数组以获得 bool 数组。每种形式都给出相同的结果，但是是否有使用一种比另一种更喜欢的时间/地点？在这个例子中，我将一个数组与一个数字进行比较，所以这 3 个都可以。

考虑使用以下数组的所有示例:

>>> x = numpy.arange(0, 10000)
>>> x
array([   0,    1,    2, ..., 9997, 9998, 9999])

'<'运算符

>>> x < 5000
array([ True,  True,  True, ..., False, False, False], dtype=bool)
>>> %timeit x < 5000
100000 loops, best of 3: 15.3 us per loop

operator.lt

>>> import operator
>>> operator.lt(x, 5000)
array([ True,  True,  True, ..., False, False, False], dtype=bool)
>>> %timeit operator.lt(x, 5000)
100000 loops, best of 3: 15.3 us per loop

numpy.less

>>> numpy.less(x, 5000)
array([ True,  True,  True, ..., False, False, False], dtype=bool)
>>> %timeit numpy.less(x, 5000)
100000 loops, best of 3: 15 us per loop

请注意，它们都实现了几乎相同的性能和完全相同的结果。我猜自 < 以来，所有这些调用实际上都以相同的函数结束。和 operator.lt都映射到 __lt__在一个 numpy 数组上，这可能是使用 numpy.less 实现的或等价物？

那么，哪个更“惯用”和“首选”？

Answer 1

一般来说，考虑到“可读性很重要”的格言，实际的运算符(operator)应该始终是您的首选。使用 operator versions 有一个地方，当你可以替换 lambda a, b: a < b更紧凑的 operator.lt ，但除此之外并不多。而且你真的不应该使用对相应 ufunc 的显式调用，除非你想使用 out将计算值直接存储在现有数组中的参数。

也就是说，如果您担心的是性能，则应该进行公平比较，因为正如您所说，您所有的调用最终都由 numpy 的 less 处理。 ufunc.

如果您的数据已经在一个 numpy 数组中，那么您已经证明它们的性能都相似，所以请使用 <运营商为了清楚起见。

如果您的数据在 python 对象中怎么办，比如说一个列表？好吧，这里有一些时间供您思考:

In [13]: x = range(10**5)

In [19]: %timeit [j < 5000 for j in x]
100 loops, best of 3: 5.32 ms per loop

In [20]: %timeit np.less(x, 5000)
100 loops, best of 3: 11.3 ms per loop

In [21]: %timeit [operator.lt(j, 5000) for j in x]
100 loops, best of 3: 16.2 ms per loop

不知道为什么 operator.lt这么慢，但你显然想远离它。如果您想从 Python 对象输入中获取一个 numpy 数组作为输出，那么这可能是最快的:

In [22]: %timeit np.fromiter((j < 5000 for j in x), dtype=bool, count=10**5)
100 loops, best of 3: 7.91 ms per loop

请注意，在 numpy 数组上运行的 ufunc 比上述任何一种都快很多:

In [24]: y = np.array(x)

In [25]: %timeit y < 5000
10000 loops, best of 3: 82.8 us per loop