blocks|key|4436317|text|正如在this+post中提到的，只需使用如下生成器表达式：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|4436318|numpy.fromiter((<some_func>(x)+for+x+in+<something>),<dtype>,<size+of+something>)|code-block|syntax|javascript|4436319|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/14372746/3117130^0|3|9|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

As mentioned in <a href="https://stackoverflow.com/a/14372746/3117130">this post</a>, just use generator expressions like so:

<pre><code>numpy.fromiter((&lt;some_func&gt;(x) for x in &lt;something&gt;),&lt;dtype&gt;,&lt;size of something&gt;)
</code></pre>

blocks|key|4436116|text|使用numpy.vectorize怎么样？|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4436117|import+numpy+as+np
x+=+np.array([1,+2,+3,+4,+5])
squarer+=+lambda+t:+t+**+2
vfunc+=+np.vectorize(squarer)
vfunc(x)
#+Output+:+array([+1,++4,++9,+16,+25])|code-block|syntax|javascript|4436118|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.scipy.org/doc/numpy/reference/generated/numpy.vectorize.html^0|2|F|2|F|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@$9|V|A|W|1|X]]|E|$]]|$1|F|3|G|5|H|7|Y|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|L|$M|$5|N|O|P|E|$Q|R]]]]

How about using <a href="https://docs.scipy.org/doc/numpy/reference/generated/numpy.vectorize.html" rel="noreferrer"><code>numpy.vectorize</code></a>.

<pre><code>import numpy as np
x = np.array([1, 2, 3, 4, 5])
squarer = lambda t: t ** 2
vfunc = np.vectorize(squarer)
vfunc(x)
# Output : array([ 1, 4, 9, 16, 25])
</code></pre>

blocks|key|4436371|text|squares+=+squarer(x)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|4436372|数组上的算术操作是以元素为单位自动应用的，具有高效的C级循环，避免了适用于Python级循环或理解的所有解释器开销。|unstyled|4436373|您希望应用于NumPy数组元素的大多数函数都将正常工作，尽管有些函数可能需要更改。例如，if不能以元素的方式工作。您可能希望将它们转换为使用像numpy.where这样的结构|offset|length|style|CODE|4436374|def+using_if(x):
++++if+x+<+5:
++++++++return+x
++++else:
++++++++return+x**2|4436375|变成了|4436376|def+using_where(x):
++++return+numpy.where(x+<+5,+x,+x**2)|4436377|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.scipy.org/doc/numpy-1.10.1/reference/generated/numpy.where.html^0|0|0|18|2|1Z|B|1Z|B|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|11|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|12|8|@$I|13|J|14|K|L]|$I|15|J|16|K|L]]|9|@$I|17|J|18|1|19]]|A|$]]|$1|M|3|N|5|6|7|1A|8|@]|9|@]|A|$B|C]]|$1|O|3|P|5|F|7|1B|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1C|8|@]|9|@]|A|$B|C]]|$1|S|3|-4|5|F|7|1D|8|@]|9|@]|A|$]]]|T|$U|$5|V|W|X|A|$Y|Z]]]]

<pre><code>squares = squarer(x)
</code></pre>

Arithmetic operations on arrays are automatically applied elementwise, with efficient C-level loops that avoid all the interpreter overhead that would apply to a Python-level loop or comprehension.

Most of the functions you'd want to apply to a NumPy array elementwise will just work, though some may need changes. For example, <code>if</code> doesn't work elementwise. You'd want to convert those to use constructs like <a href="http://docs.scipy.org/doc/numpy-1.10.1/reference/generated/numpy.where.html" rel="noreferrer"><code>numpy.where</code></a>:

<pre><code>def using_if(x):
 if x &lt; 5:
 return x
 else:
 return x**2
</code></pre>

becomes

<pre><code>def using_where(x):
 return numpy.where(x &lt; 5, x, x**2)
</code></pre>

blocks|key|4436398|text|TL;DR|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4436399|正如@user2357112所指出的，应用函数的“直接”方法始终是在Numpy数组上映射函数的最快、最简单的方法：|offset|length|4436400|import+numpy+as+np
x+=+np.array([1,+2,+3,+4,+5])
f+=+lambda+x:+x+**+2
squares+=+f(x)|code-block|syntax|javascript|4436401|通常避免使用np.vectorize，因为它的性能不是很好，并且有(或曾经)了许多issues。如果您正在处理其他数据类型，则可能需要研究如下所示的其他方法。|style|CODE|4436402|方法的比较|4436403|这里有一些简单的测试来比较三种映射函数的方法，本例使用Python3.6和NumPy+1.15.4。首先，用于测试的设置函数：|4436404|import+timeit
import+numpy+as+np

f+=+lambda+x:+x+**+2
vf+=+np.vectorize(f)

def+test_array(x,+n):
++++t+=+timeit.timeit(
++++++++'np.array([f(xi)+for+xi+in+x])',
++++++++'from+__main__+import+np,+x,+f',+number=n)
++++print('array:+{0:.3f}'.format(t))

def+test_fromiter(x,+n):
++++t+=+timeit.timeit(
++++++++'np.fromiter((f(xi)+for+xi+in+x),+x.dtype,+count=len(x))',
++++++++'from+__main__+import+np,+x,+f',+number=n)
++++print('fromiter:+{0:.3f}'.format(t))

def+test_direct(x,+n):
++++t+=+timeit.timeit(
++++++++'f(x)',
++++++++'from+__main__+import+x,+f',+number=n)
++++print('direct:+{0:.3f}'.format(t))

def+test_vectorized(x,+n):
++++t+=+timeit.timeit(
++++++++'vf(x)',
++++++++'from+__main__+import+x,+vf',+number=n)
++++print('vectorized:+{0:.3f}'.format(t))|4436405|使用五个元素进行测试(从快到慢排序)：|4436406|x+=+np.array([1,+2,+3,+4,+5])
n+=+100000
test_direct(x,+n)++++++#+0.265
test_fromiter(x,+n)++++#+0.479
test_array(x,+n)+++++++#+0.865
test_vectorized(x,+n)++#+2.906|4436407|有100个元素：|4436408|x+=+np.arange(100)
n+=+10000
test_direct(x,+n)++++++#+0.030
test_array(x,+n)+++++++#+0.501
test_vectorized(x,+n)++#+0.670
test_fromiter(x,+n)++++#+0.883|4436409|并且具有上千个或更多的阵列元素：|4436410|x+=+np.arange(1000)
n+=+1000
test_direct(x,+n)++++++#+0.007
test_fromiter(x,+n)++++#+0.479
test_array(x,+n)+++++++#+0.516
test_vectorized(x,+n)++#+0.945|4436411|不同版本的Python/NumPy和编译器优化会有不同的结果，所以针对您的环境进行类似的测试。|4436412|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/users/2357112|1|https://github.com/numpy/numpy/search?q=vectorize&type=Issues^0|0|2|C|0|0|0|6|C|15|6|1|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1I|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1J|8|@]|9|@$D|1K|E|1L|1|1M]]|A|$]]|$1|F|3|G|5|H|7|1N|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|1O|8|@$D|1P|E|1Q|M|N]]|9|@$D|1R|E|1S|1|1T]]|A|$]]|$1|O|3|P|5|6|7|1U|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1V|8|@]|9|@]|A|$]]|$1|S|3|T|5|H|7|1W|8|@]|9|@]|A|$I|J]]|$1|U|3|V|5|6|7|1X|8|@]|9|@]|A|$]]|$1|W|3|X|5|H|7|1Y|8|@]|9|@]|A|$I|J]]|$1|Y|3|Z|5|6|7|1Z|8|@]|9|@]|A|$]]|$1|10|3|11|5|H|7|20|8|@]|9|@]|A|$I|J]]|$1|12|3|13|5|6|7|21|8|@]|9|@]|A|$]]|$1|14|3|15|5|H|7|22|8|@]|9|@]|A|$I|J]]|$1|16|3|17|5|6|7|23|8|@]|9|@]|A|$]]|$1|18|3|-4|5|6|7|24|8|@]|9|@]|A|$]]]|19|$1A|$5|1B|1C|1D|A|$1E|1F]]|1G|$5|1B|1C|1D|A|$1E|1H]]]]

<h1>TL;DR</h1>

As noted by <a href="https://stackoverflow.com/users/2357112">@user2357112</a>, a "direct" method of applying the function is always the fastest and simplest way to map a function over Numpy arrays:

<pre><code>import numpy as np
x = np.array([1, 2, 3, 4, 5])
f = lambda x: x ** 2
squares = f(x)
</code></pre>

Generally avoid <code>np.vectorize</code>, as it does not perform well, and has (or had) a number of <a href="https://github.com/numpy/numpy/search?q=vectorize&amp;type=Issues" rel="noreferrer">issues</a>. If you are handling other data types, you may want to investigate the other methods shown below.

<h1>Comparison of methods</h1>

Here are some simple tests to compare three methods to map a function, this example using with Python 3.6 and NumPy 1.15.4. First, the set-up functions for testing:

<pre><code>import timeit
import numpy as np

f = lambda x: x ** 2
vf = np.vectorize(f)

def test_array(x, n):
 t = timeit.timeit(
 'np.array([f(xi) for xi in x])',
 'from __main__ import np, x, f', number=n)
 print('array: {0:.3f}'.format(t))

def test_fromiter(x, n):
 t = timeit.timeit(
 'np.fromiter((f(xi) for xi in x), x.dtype, count=len(x))',
 'from __main__ import np, x, f', number=n)
 print('fromiter: {0:.3f}'.format(t))

def test_direct(x, n):
 t = timeit.timeit(
 'f(x)',
 'from __main__ import x, f', number=n)
 print('direct: {0:.3f}'.format(t))

def test_vectorized(x, n):
 t = timeit.timeit(
 'vf(x)',
 'from __main__ import x, vf', number=n)
 print('vectorized: {0:.3f}'.format(t))
</code></pre>

Testing with five elements (sorted from fastest to slowest):

<pre><code>x = np.array([1, 2, 3, 4, 5])
n = 100000
test_direct(x, n) # 0.265
test_fromiter(x, n) # 0.479
test_array(x, n) # 0.865
test_vectorized(x, n) # 2.906
</code></pre>

With 100s of elements:

<pre><code>x = np.arange(100)
n = 10000
test_direct(x, n) # 0.030
test_array(x, n) # 0.501
test_vectorized(x, n) # 0.670
test_fromiter(x, n) # 0.883
</code></pre>

And with 1000s of array elements or more:

<pre><code>x = np.arange(1000)
n = 1000
test_direct(x, n) # 0.007
test_fromiter(x, n) # 0.479
test_array(x, n) # 0.516
test_vectorized(x, n) # 0.945
</code></pre>

Different versions of Python/NumPy and compiler optimization will have different results, so do a similar test for your environment.

blocks|key|4436460|text|我相信在更新版本(我使用1.13)的numpy中，您可以通过将numpy数组传递给您为标量类型编写的函数来简单地调用函数，它会自动将函数调用应用于numpy数组中的每个元素，并返回另一个numpy数组|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4436461|>>>+import+numpy+as+np
>>>+squarer+=+lambda+t:+t+**+2
>>>+x+=+np.array([1,+2,+3,+4,+5])
>>>+squarer(x)
array([+1,++4,++9,+16,+25])|code-block|syntax|javascript|4436462|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I believe in newer version( I use 1.13) of numpy you can simply call the function by passing the numpy array to the fuction that you wrote for scalar type, it will automatically apply the function call to each element over the numpy array and return you another numpy array

<pre><code>&gt;&gt;&gt; import numpy as np
&gt;&gt;&gt; squarer = lambda t: t ** 2
&gt;&gt;&gt; x = np.array([1, 2, 3, 4, 5])
&gt;&gt;&gt; squarer(x)
array([ 1, 4, 9, 16, 25])
</code></pre>

blocks|key|4436274|text|似乎还没有人提到在numpy包中生产ufunc的内置工厂方法：np.frompyfunc，我已经对np.vectorize进行了测试，并且比它高出大约20%25到30%25。当然，它的性能不如规定的C代码甚至numba(我还没有测试过)，但它可以是一个比np.vectorize更好的选择|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4436275|f+=+lambda+x,+y:+x+*+y
f_arr+=+np.frompyfunc(f,+2,+1)
vf+=+np.vectorize(f)
arr+=+np.linspace(0,+1,+10000)

%25timeit+f_arr(arr,+arr)+#+307ms
%25timeit+vf(arr,+arr)+#+450ms|code-block|syntax|javascript|4436276|我还测试了更大的样本，改进是成比例的。另请参阅文档here|4436277|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.scipy.org/doc/numpy/reference/generated/numpy.frompyfunc.html#numpy.frompyfunc^0|I|5|V|D|1D|C|2S|5|3F|C|0|0|P|4|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]|$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|15|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|16|8|@]|D|@$9|17|A|18|1|19]]|E|$]]|$1|M|3|-4|5|6|7|1A|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]]]

It seems that no one has mentioned a built-in factory method of producing <code>ufunc</code> in numpy package: <code>np.frompyfunc</code>, which I have tested against <code>np.vectorize</code>, and have outperformed it by about 20~30%. Of course it will not perform as well prescribed C code or even <code>numba</code>(which I have not tested), but it can a better alternative than <code>np.vectorize</code>
<pre class="lang-py prettyprint-override"><code>f = lambda x, y: x * y
f_arr = np.frompyfunc(f, 2, 1)
vf = np.vectorize(f)
arr = np.linspace(0, 1, 10000)

%timeit f_arr(arr, arr) # 307ms
%timeit vf(arr, arr) # 450ms
</code></pre>
I have also tested larger samples, and the improvement is proportional. See the documentation also <a href="https://docs.scipy.org/doc/numpy/reference/generated/numpy.frompyfunc.html#numpy.frompyfunc" rel="nofollow noreferrer">here</a>

blocks|key|4436287|text|使用numpy.fromfunction(function,+shape,+**kwargs)|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4436288|参见"https://docs.scipy.org/doc/numpy/reference/generated/numpy.fromfunction.html“|4436289|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.scipy.org/doc/numpy/reference/generated/numpy.fromfunction.html^0|2|19|0|3|24|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@$9|Q|A|R|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|S|8|@]|D|@$9|T|A|U|1|V]]|E|$]]|$1|H|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|I|$J|$5|K|L|M|E|$N|O]]]]

Use <code>numpy.fromfunction(function, shape, **kwargs)</code>

See "<a href="https://docs.scipy.org/doc/numpy/reference/generated/numpy.fromfunction.html" rel="nofollow noreferrer">https://docs.scipy.org/doc/numpy/reference/generated/numpy.fromfunction.html</a>"

What is the most efficient way to map a function over a numpy array? The way I've been doing it in my current project is as follows:

<pre><code>import numpy as np 

x = np.array([1, 2, 3, 4, 5])

# Obtain array of square of each element in x
squarer = lambda t: t ** 2
squares = np.array([squarer(xi) for xi in x])
</code></pre>

However, this seems like it is probably very inefficient, since I am using a list comprehension to construct the new array as a Python list before converting it back to a numpy array.

Can we do better?

Most efficient way to map function over numpy array

编译器

解释器

Python

在numpy数组上映射函数的最有效方法是什么？在我目前的项目中，我一直在这样做：import numpy as np x = np.array([1, 2, 3, 4, 5])# Obtain array of square of each element in xsquarer = lambda t: t ** 2s...

问在numpy数组上映射函数的最有效方法
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在numpy数组上映射函数的最有效方法EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在numpy数组上映射函数的最有效方法
EN