blocks|key|3146797|text|你可以简单地vectorize这个函数，然后在每次你需要它的时候将它直接应用于一个Numpy数组：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3146798|import+numpy+as+np

def+f(x):
++++return+x+*+x+%2B+3+*+x+-+2+if+x+>+0+else+x+*+5+%2B+8

f+=+np.vectorize(f)++#+or+use+a+different+name+if+you+want+to+keep+the+original+f

result_array+=+f(A)++#+if+A+is+your+Numpy+array|code-block|syntax|javascript|3146799|在向量化时，直接指定显式输出类型可能更好：|3146800|f+=+np.vectorize(f,+otypes=[np.float])|3146801|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.scipy.org/doc/numpy/reference/generated/numpy.vectorize.html^0|6|9|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|10|8|@]|9|@]|C|$G|H]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

You could just <a href="http://docs.scipy.org/doc/numpy/reference/generated/numpy.vectorize.html">vectorize</a> the function and then apply it directly to a Numpy array each time you need it:

<pre><code>import numpy as np

def f(x):
 return x * x + 3 * x - 2 if x &gt; 0 else x * 5 + 8

f = np.vectorize(f) # or use a different name if you want to keep the original f

result_array = f(A) # if A is your Numpy array
</code></pre>

It's probably better to specify an explicit output type directly when vectorizing:

<pre><code>f = np.vectorize(f, otypes=[np.float])
</code></pre>

blocks|key|3146865|text|一个类似的问题是：Mapping+a+NumPy+array+in+place。如果可以找到f()的输出，那么应该使用ufunc参数。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3146866|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/6824122/mapping-a-numpy-array-in-place|1|http://docs.scipy.org/doc/numpy/reference/ufuncs.html#available-ufuncs^0|9|U|0|1N|5|1|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]|$A|R|B|S|1|T]]|C|$]]|$1|D|3|-4|5|6|7|U|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]|L|$5|G|H|I|C|$J|M]]]]

A similar question is: <a href="https://stackoverflow.com/questions/6824122/mapping-a-numpy-array-in-place">Mapping a NumPy array in place</a>.
If you can find a <a href="http://docs.scipy.org/doc/numpy/reference/ufuncs.html#available-ufuncs" rel="nofollow noreferrer">ufunc</a> for your f(), then you should use the out parameter.

blocks|key|251274|text|如果您正在处理数字和f(A(i,j))+=+f(A(j,i))，则可以使用scipy.spatial.distance.cdist将f定义为A(i)和A(j)之间的距离。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|251275|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.scipy.org/doc/scipy/reference/generated/scipy.spatial.distance.cdist.html^0|A|L|1Y|4|23|4|11|S|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]|$9|Q|A|R|B|C]|$9|S|A|T|B|C]]|D|@$9|U|A|V|1|W]]|E|$]]|$1|F|3|-4|5|6|7|X|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]]]

If you are working with numbers and <code>f(A(i,j)) = f(A(j,i))</code>, you could use <a href="http://docs.scipy.org/doc/scipy/reference/generated/scipy.spatial.distance.cdist.html" rel="nofollow">scipy.spatial.distance.cdist</a> defining f as a distance between <code>A(i)</code> and <code>A(j)</code>.

blocks|key|3146905|text|我相信我找到了一个更好的解决方案。将函数更改为python通用函数(请参阅documentation)的想法，它可以在幕后执行并行计算。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3146906|人们可以用C语言编写自己的定制ufunc，这肯定更高效，或者调用np.frompyfunc，这是内置的工厂方法。经过测试，这比np.vectorize更高效|style|CODE|3146907|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+f_arr(arr,+arr)+#+450ms|code-block|syntax|javascript|3146908|我还测试了更大的样本，改进是成比例的。有关其他方法的性能比较，请参阅this+post|3146909|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.scipy.org/doc/numpy/reference/ufuncs.html|1|https://stackoverflow.com/questions/35215161/most-efficient-way-to-map-function-over-numpy-array^0|11|D|0|0|F|5|W|D|1R|C|0|0|Y|9|1|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]]|C|$]]|$1|D|3|E|5|6|7|12|8|@$A|13|B|14|F|G]|$A|15|B|16|F|G]|$A|17|B|18|F|G]]|9|@]|C|$]]|$1|H|3|I|5|J|7|19|8|@]|9|@]|C|$K|L]]|$1|M|3|N|5|6|7|1A|8|@]|9|@$A|1B|B|1C|1|1D]]|C|$]]|$1|O|3|-4|5|6|7|1E|8|@]|9|@]|C|$]]]|P|$Q|$5|R|S|T|C|$U|V]]|W|$5|R|S|T|C|$U|X]]]]

I believe I have found a better solution. The idea to change the function to python universal function (see <a href="https://docs.scipy.org/doc/numpy/reference/ufuncs.html" rel="nofollow noreferrer">documentation</a>), which can exercise parallel computation under the hood.

One can write his own customised <code>ufunc</code> in C, which surely is more efficient, or by invoking <code>np.frompyfunc</code>, which is built-in factory method. After testing, this is more efficient 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 f_arr(arr, arr) # 450ms
</code></pre>

I have also tested larger samples, and the improvement is proportional. For comparison of performances of other methods, see <a href="https://stackoverflow.com/questions/35215161/most-efficient-way-to-map-function-over-numpy-array">this post</a>

blocks|key|251332|text|当2d数组(或nd数组)是C或F连续时，将函数映射到2d数组的任务实际上与将函数映射到1d数组的任务相同-我们只需以这种方式查看它，例如通过np.ravel(A,'K')。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|251333|已经讨论了一维阵列的可能的解决方案，例如here。|251334|然而，当2d数组的内存不连续时，情况就会稍微复杂一些，因为如果轴的处理顺序不正确，就会避免可能的缓存未命中。|251335|Numpy已经有了一台机器，可以以最好的顺序处理轴。使用这种机器的一种可能性是np.vectorize。然而，numpy在np.vectorize上的文档指出，它“主要是为了方便，而不是为了性能”-一个慢的python函数仍然是一个慢的python函数，并伴随着整个相关的开销！另一个问题是其巨大的内存消耗-例如，请参阅此SO-post。|251336|当一个人想要拥有C函数的性能，但又想使用numpy的机制时，一个好的解决方案是使用numba来创建ufuncs，例如：|251337|#+runtime+generated+C-function+as+ufunc
import+numba+as+nb
@nb.vectorize(target="cpu")
def+nb_vf(x):
++++return+x%2B2*x*x%2B4*x*x*x|code-block|syntax|javascript|251338|它很容易击败np.vectorize，但当同样的功能被执行为数值数组乘法/加法时，也是如此。|251339|#+numpy-functionality
def+f(x):
++++return+x%2B2*x*x%2B4*x*x*x

#+python-function+as+ufunc
import+numpy+as+np
vf=np.vectorize(f)
vf.__name__="vf"|251340|时间测量代码见本答案附录：|251341|​|251342|📷|atomic|251343|251344|Numba的版本(绿色)大约比python-function+(即np.vectorize)快100倍，这并不奇怪。但它也比numpy-functionality快10倍，因为numbas版本不需要中间数组，因此使用缓存的效率更高。|251345|251346|虽然numba的ufunc方法是可用性和性能之间的一个很好的折衷，但它仍然不是我们能做的最好的。然而，对于任何任务都没有最好的银弹或方法-人们必须了解限制是什么，以及如何减轻它们。|251347|例如，对于超越函数(例如exp、sin、cos)，numba不会提供任何优于numpy的np.exp的优势(没有创建临时数组-这是加速的主要来源)。然而，我的Anaconda安装使用了英特尔的VML+bigger+than+8192+-如果内存不是连续的，它就不能这样做。因此，为了能够使用Intel的VML，最好将元素复制到连续的内存中：|251348|import+numba+as+nb
@nb.vectorize(target="cpu")
def+nb_vexp(x):
++++return+np.exp(x)

def+np_copy_exp(x):
++++copy+=+np.ravel(x,+'K')
++++return+np.exp(copy).reshape(x.shape)+|251349|为了公平起见，我关闭了VML的并行化(参见附录中的代码)：|251350|251351|251352|251353|正如人们所看到的，一旦VML生效，复制的开销就会得到补偿。然而，一旦数据对于L3缓存来说变得太大，优势就变得微乎其微，因为任务再次变得受内存带宽限制。|251354|另一方面，numba也可以使用英特尔的SVML，正如this+post中所解释的那样|251355|from+llvmlite+import+binding
#+set+before+import
binding.set_option('SVML',+'-vector-library=SVML')

import+numba+as+nb

@nb.vectorize(target="cpu")
def+nb_vexp_svml(x):
++++return+np.exp(x)|251356|将VML与并行化结合使用会产生以下结果：|251357|251358|251359|251360|numba的版本有较少的开销，但对于某些大小，VML击败了SVML，尽管有额外的复制开销-这并不奇怪，因为numba的ufuncs没有并行化。|251361|251362|列表：|251363|A.多项式函数的比较：|251364|import+perfplot
perfplot.show(
++++setup=lambda+n:+np.random.rand(n,n)[::2,::2],
++++n_range=[2**k+for+k+in+range(0,12)],
++++kernels=[
++++++++f,
++++++++vf,+
++++++++nb_vf
++++++++],
++++logx=True,
++++logy=True,
++++xlabel='len(x)'
++++)+|251365|B.+exp的比较|251366|import+perfplot
import+numexpr+as+ne+#+using+ne+is+the+easiest+way+to+set+vml_num_threads
ne.set_vml_num_threads(1)
perfplot.show(
++++setup=lambda+n:+np.random.rand(n,n)[::2,::2],
++++n_range=[2**k+for+k+in+range(0,12)],
++++kernels=[
++++++++nb_vexp,+
++++++++np.exp,
++++++++np_copy_exp,
++++++++],
++++logx=True,
++++logy=True,
++++xlabel='len(x)',
++++)|251367|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.scipy.org/doc/numpy/reference/generated/numpy.ravel.html#numpy.ravel|1|https://stackoverflow.com/a/54312134/5769463|2|https://docs.scipy.org/doc/numpy/reference/generated/numpy.vectorize.html?highlight=vectorize#numpy.vectorize|3|https://stackoverflow.com/questions/57253839/why-vectorize-is-outperformed-by-frompyfunc|4|IMAGE|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/ed72d9b1dc9b8f5faa36e24c8d3e1653.png|imageAlt|5|https://github.com/ContinuumIO/anaconda-issues/issues/9129#issuecomment-380284038|6|https://ask.qcloudimg.com/http-save/yehe-900000/9c33c802e7080d2401c4053bb09f7a55.png|7|https://stackoverflow.com/a/56939240/5769463|8|https://ask.qcloudimg.com/http-save/yehe-900000/8ea23cc6b22eda37f282d9ce7d8fa343.png^0|1Y|F|1Y|F|0|0|K|4|1|0|0|13|C|1P|C|1P|C|2|4H|7|3|0|0|0|6|C|0|0|0|0|0|1|4|0|0|X|C|0|0|0|C|3|G|3|K|3|18|6|2S|G|5|0|0|0|0|0|1|6|0|0|0|Q|9|7|0|0|0|0|0|1|8|0|0|0|0|0|0|0|3|3|0|0^^$0|@$1|2|3|4|5|6|7|2Y|8|@$9|2Z|A|30|B|C]]|D|@$9|31|A|32|1|33]]|E|$]]|$1|F|3|G|5|6|7|34|8|@]|D|@$9|35|A|36|1|37]]|E|$]]|$1|H|3|I|5|6|7|38|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|39|8|@$9|3A|A|3B|B|C]|$9|3C|A|3D|B|C]]|D|@$9|3E|A|3F|1|3G]|$9|3H|A|3I|1|3J]]|E|$]]|$1|L|3|M|5|6|7|3K|8|@]|D|@]|E|$]]|$1|N|3|O|5|P|7|3L|8|@]|D|@]|E|$Q|R]]|$1|S|3|T|5|6|7|3M|8|@$9|3N|A|3O|B|C]]|D|@]|E|$]]|$1|U|3|V|5|P|7|3P|8|@]|D|@]|E|$Q|R]]|$1|W|3|X|5|6|7|3Q|8|@]|D|@]|E|$]]|$1|Y|3|Z|5|6|7|3R|8|@]|D|@]|E|$]]|$1|10|3|11|5|12|7|3S|8|@]|D|@$9|3T|A|3U|1|3V]]|E|$]]|$1|13|3|Z|5|6|7|3W|8|@]|D|@]|E|$]]|$1|14|3|15|5|6|7|3X|8|@$9|3Y|A|3Z|B|C]]|D|@]|E|$]]|$1|16|3|-4|5|6|7|40|8|@]|D|@]|E|$]]|$1|17|3|18|5|6|7|41|8|@]|D|@]|E|$]]|$1|19|3|1A|5|6|7|42|8|@$9|43|A|44|B|C]|$9|45|A|46|B|C]|$9|47|A|48|B|C]|$9|49|A|4A|B|C]]|D|@$9|4B|A|4C|1|4D]]|E|$]]|$1|1B|3|1C|5|P|7|4E|8|@]|D|@]|E|$Q|R]]|$1|1D|3|1E|5|6|7|4F|8|@]|D|@]|E|$]]|$1|1F|3|Z|5|6|7|4G|8|@]|D|@]|E|$]]|$1|1G|3|11|5|12|7|4H|8|@]|D|@$9|4I|A|4J|1|4K]]|E|$]]|$1|1H|3|Z|5|6|7|4L|8|@]|D|@]|E|$]]|$1|1I|3|1J|5|6|7|4M|8|@]|D|@]|E|$]]|$1|1K|3|1L|5|6|7|4N|8|@]|D|@$9|4O|A|4P|1|4Q]]|E|$]]|$1|1M|3|1N|5|P|7|4R|8|@]|D|@]|E|$Q|R]]|$1|1O|3|1P|5|6|7|4S|8|@]|D|@]|E|$]]|$1|1Q|3|Z|5|6|7|4T|8|@]|D|@]|E|$]]|$1|1R|3|11|5|12|7|4U|8|@]|D|@$9|4V|A|4W|1|4X]]|E|$]]|$1|1S|3|Z|5|6|7|4Y|8|@]|D|@]|E|$]]|$1|1T|3|1U|5|6|7|4Z|8|@]|D|@]|E|$]]|$1|1V|3|-4|5|6|7|50|8|@]|D|@]|E|$]]|$1|1W|3|1X|5|6|7|51|8|@]|D|@]|E|$]]|$1|1Y|3|1Z|5|6|7|52|8|@]|D|@]|E|$]]|$1|20|3|21|5|P|7|53|8|@]|D|@]|E|$Q|R]]|$1|22|3|23|5|6|7|54|8|@$9|55|A|56|B|C]]|D|@]|E|$]]|$1|24|3|25|5|P|7|57|8|@]|D|@]|E|$Q|R]]|$1|26|3|-4|5|6|7|58|8|@]|D|@]|E|$]]]|27|$28|$5|29|2A|2B|E|$2C|2D]]|2E|$5|29|2A|2B|E|$2C|2F]]|2G|$5|29|2A|2B|E|$2C|2H]]|2I|$5|29|2A|2B|E|$2C|2J]]|2K|$5|2L|2A|2M|E|$2N|2O|2P|-4]]|2Q|$5|29|2A|2B|E|$2C|2R]]|2S|$5|2L|2A|2M|E|$2N|2T|2P|-4]]|2U|$5|29|2A|2B|E|$2C|2V]]|2W|$5|2L|2A|2M|E|$2N|2X|2P|-4]]]]

When the 2d-array (or nd-array) is C- or F-contiguous, then this task of mapping a function onto a 2d-array is practically the same as the task of mapping a function onto a 1d-array - we just have to view it that way, e.g. via <a href="https://docs.scipy.org/doc/numpy/reference/generated/numpy.ravel.html#numpy.ravel" rel="nofollow noreferrer"><code>np.ravel(A,'K')</code></a>.

Possible solution for 1d-array have been discussed for example <a href="https://stackoverflow.com/a/54312134/5769463">here</a>.

However, when the memory of the 2d-array isn't contiguous, then the situation a little bit more complicated, because one would like to avoid possible cache misses if axis are handled in wrong order.

Numpy has already a machinery in place to process axes in the best possible order. One possibility to use this machinery is <code>np.vectorize</code>. However, numpy's documentation on <a href="https://docs.scipy.org/doc/numpy/reference/generated/numpy.vectorize.html?highlight=vectorize#numpy.vectorize" rel="nofollow noreferrer"><code>np.vectorize</code></a> states that it is "provided primarily for convenience, not for performance" - a slow python function stays a slow python function with the whole associated overhead! Another issue is its huge memory-consumption - see for example this <a href="https://stackoverflow.com/questions/57253839/why-vectorize-is-outperformed-by-frompyfunc">SO-post</a>.

When one wants to have a performance of a C-function but to use numpy's machinery, a good solution is to use numba for creation of ufuncs, for example:

<pre><code># runtime generated C-function as ufunc
import numba as nb
@nb.vectorize(target="cpu")
def nb_vf(x):
 return x+2*x*x+4*x*x*x
</code></pre>

It easily beats <code>np.vectorize</code> but also when the same function would be performed as numpy-array multiplication/addition, i.e.

<pre><code># numpy-functionality
def f(x):
 return x+2*x*x+4*x*x*x

# python-function as ufunc
import numpy as np
vf=np.vectorize(f)
vf.__name__="vf"
</code></pre>

See appendix of this answer for time-measurement-code:

<a href="https://i.stack.imgur.com/M32DI.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/M32DI.png" alt="enter image description here"></a>

Numba's version (green) is about 100 times faster than the python-function (i.e. <code>np.vectorize</code>), which is not surprising. But it is also about 10 times faster than the numpy-functionality, because numbas version doesn't need intermediate arrays and thus uses cache more efficiently.

<hr>

While numba's ufunc approach is a good trade-off between usability and performance, it is still not the best we can do. Yet there is no silver bullet or an approach best for any task - one has to understand what are the limitation and how they can be mitigated.

For example, for transcendental functions (e.g. <code>exp</code>, <code>sin</code>, <code>cos</code>) numba doesn't provide any advantages over numpy's <code>np.exp</code> (there are no temporary arrays created - the main source of the speed-up). However, my Anaconda installation utilizes Intel's VML for vectors <a href="https://github.com/ContinuumIO/anaconda-issues/issues/9129#issuecomment-380284038" rel="nofollow noreferrer">bigger than 8192</a> - it just cannot do it if memory is not contiguous. So it might be better to copy the elements to a contiguous memory in order to be able to use Intel's VML:

<pre><code>import numba as nb
@nb.vectorize(target="cpu")
def nb_vexp(x):
 return np.exp(x)

def np_copy_exp(x):
 copy = np.ravel(x, 'K')
 return np.exp(copy).reshape(x.shape) 
</code></pre>

For the fairness of the comparison, I have switched off VML's parallelization (see code in the appendix):

<a href="https://i.stack.imgur.com/CxNNv.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/CxNNv.png" alt="enter image description here"></a>

As one can see, once VML kicks in, the overhead of copying is more than compensated. Yet once data becomes too big for L3 cache, the advantage is minimal as task becomes once again memory-bandwidth-bound.

On the other hand, numba could use Intel's SVML as well, as explained in <a href="https://stackoverflow.com/a/56939240/5769463">this post</a>:

<pre><code>from llvmlite import binding
# set before import
binding.set_option('SVML', '-vector-library=SVML')

import numba as nb

@nb.vectorize(target="cpu")
def nb_vexp_svml(x):
 return np.exp(x)
</code></pre>

and using VML with parallelization yields:

<a href="https://i.stack.imgur.com/VaxWB.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/VaxWB.png" alt="enter image description here"></a>

numba's version has less overhead, but for some sizes VML beats SVML even despite of the additional copying overhead - which isn't a bit surprise as numba's ufuncs aren't parallelized.

<hr>

Listings:

A. comparison of polynomial function:

<pre><code>import perfplot
perfplot.show(
 setup=lambda n: np.random.rand(n,n)[::2,::2],
 n_range=[2**k for k in range(0,12)],
 kernels=[
 f,
 vf, 
 nb_vf
 ],
 logx=True,
 logy=True,
 xlabel='len(x)'
 ) 
</code></pre>

B. comparison of <code>exp</code>:

<pre><code>import perfplot
import numexpr as ne # using ne is the easiest way to set vml_num_threads
ne.set_vml_num_threads(1)
perfplot.show(
 setup=lambda n: np.random.rand(n,n)[::2,::2],
 n_range=[2**k for k in range(0,12)],
 kernels=[
 nb_vexp, 
 np.exp,
 np_copy_exp,
 ],
 logx=True,
 logy=True,
 xlabel='len(x)',
 )
</code></pre>

blocks|key|253336|text|以上所有答案都比较好，但如果您需要使用自定义函数进行映射，并且您有numpy.ndarray，并且您需要保留数组的形状。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|253337|我只比较了两个，但它将保留ndarray的形状。我使用了包含100万个条目的数组进行比较。这里我使用的是平方函数。我介绍的是n维数组的一般情况。对于二维，只需将iter用于2D。|253338|import+numpy,+time

def+A(e):
++++return+e+*+e

def+timeit():
++++y+=+numpy.arange(1000000)
++++now+=+time.time()
++++numpy.array([A(x)+for+x+in+y.reshape(-1)]).reshape(y.shape)++++++++
++++print(time.time()+-+now)
++++now+=+time.time()
++++numpy.fromiter((A(x)+for+x+in+y.reshape(-1)),+y.dtype).reshape(y.shape)
++++print(time.time()+-+now)
++++now+=+time.time()
++++numpy.square(y)++
++++print(time.time()+-+now)|code-block|syntax|javascript|253339|输出|BOLD|253340|>>>+timeit()
1.162431240081787++++#+list+comprehension+and+then+building+numpy+array
1.0775556564331055+++#+from+numpy.fromiter
0.002948284149169922+#+using+inbuilt+function|253341|在这里你可以清楚地看到numpy.fromiter用户方函数，使用任何你选择的。如果你的函数依赖于i,+j，也就是数组的索引，像for+ind+in+range(arr.size)一样迭代数组的大小，使用numpy.unravel_index根据你的一维索引和数组numpy.unravel_index的形状来获得i,+j,+..|253342|此答案的灵感来自于我在其他问题here上的回答|253343|entityMap|0|LINK|mutability|MUTABLE|url|https://numpy.org/doc/stable/reference/generated/numpy.unravel_index.html?highlight=unravel%2520index#numpy.unravel_index|1|https://stackoverflow.com/a/61134821/8630792^0|X|D|0|D|7|28|4|0|0|0|2|0|0|B|E|1D|4|1S|Q|2U|J|4D|8|3O|J|0|0|F|4|1|0^^$0|@$1|2|3|4|5|6|7|15|8|@$9|16|A|17|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|18|8|@$9|19|A|1A|B|C]|$9|1B|A|1C|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|1D|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1E|8|@$9|1F|A|1G|B|O]]|D|@]|E|$]]|$1|P|3|Q|5|J|7|1H|8|@]|D|@]|E|$K|L]]|$1|R|3|S|5|6|7|1I|8|@$9|1J|A|1K|B|C]|$9|1L|A|1M|B|C]|$9|1N|A|1O|B|C]|$9|1P|A|1Q|B|C]|$9|1R|A|1S|B|C]]|D|@$9|1T|A|1U|1|1V]]|E|$]]|$1|T|3|U|5|6|7|1W|8|@]|D|@$9|1X|A|1Y|1|1Z]]|E|$]]|$1|V|3|-4|5|6|7|20|8|@]|D|@]|E|$]]]|W|$X|$5|Y|Z|10|E|$11|12]]|13|$5|Y|Z|10|E|$11|14]]]]

All above answers compares well, but if you need to use custom function for mapping, and you have <code>numpy.ndarray</code>, and you need to retain the shape of array.

I have compare just two, but it will retain the shape of <code>ndarray</code>. I have used the array with 1 million entries for comparison. Here I use square function. I am presenting the general case for n dimensional array. For two dimensional just make <code>iter</code> for 2D.

<pre class="lang-py prettyprint-override"><code>import numpy, time

def A(e):
 return e * e

def timeit():
 y = numpy.arange(1000000)
 now = time.time()
 numpy.array([A(x) for x in y.reshape(-1)]).reshape(y.shape) 
 print(time.time() - now)
 now = time.time()
 numpy.fromiter((A(x) for x in y.reshape(-1)), y.dtype).reshape(y.shape)
 print(time.time() - now)
 now = time.time()
 numpy.square(y) 
 print(time.time() - now)
</code></pre>

Output

<pre><code>&gt;&gt;&gt; timeit()
1.162431240081787 # list comprehension and then building numpy array
1.0775556564331055 # from numpy.fromiter
0.002948284149169922 # using inbuilt function
</code></pre>

here you can clearly see <code>numpy.fromiter</code> user square function, use any of your choice. If you function is dependent on <code>i, j</code> that is indices of array, iterate on size of array like <code>for ind in range(arr.size)</code>, use <code>numpy.unravel_index</code> to get <code>i, j, ..</code> based on your 1D index and shape of array <a href="https://numpy.org/doc/stable/reference/generated/numpy.unravel_index.html?highlight=unravel%20index#numpy.unravel_index" rel="nofollow noreferrer">numpy.unravel_index</a> 

This answers is inspired by my answer on other question <a href="https://stackoverflow.com/a/61134821/8630792">here</a>

Given a <a href="http://en.wikipedia.org/wiki/NumPy" rel="noreferrer">NumPy</a> array A, what is the fastest/most efficient way to apply the same function, f, to every cell?

<ol>
<li>Suppose that we will assign to A(i,j) the f(A(i,j)).</li>
<li>The function, f, doesn't have a binary output, thus the mask(ing) operations won't help.</li>
</ol>

Is the "obvious" double loop iteration (through every cell) the optimal solution?

Efficient evaluation of a function at every cell of a NumPy array

给定一个数组A，将相同的函数f应用于每个单元的最快/最有效的方法是什么？假设我们将f(A(i，j) )赋值给A(i，j)。函数f没有二进制输出，因此掩码(Ing)操作将不起作用。“显而易见”的双循环迭代(通过每个单元)是最优解决方案吗？

问在NumPy数组的每个单元上高效地计算函数
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在NumPy数组的每个单元上高效地计算函数EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在NumPy数组的每个单元上高效地计算函数
EN