blocks|key|4578518|text|最快的方法是使用a*a、a**2或np.square(a)，而np.power(a,+2)则要慢得多。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4578519|如果您传递的不是2，而是另一个指数数组，那么np.power()允许您为每个元素使用不同的指数。从@GarethRees的评论中，我了解到这个函数将给你不同于a**2或a*a的结果，这在你的容差很小的情况下变得很重要。|4578520|我使用NumPy+1.9.0MKL+64位对一些示例进行了计时，结果如下所示：|4578521|In+[29]:+a+=+np.random.random((1000,+1000))

In+[30]:+timeit+a*a
100+loops,+best+of+3:+2.78+ms+per+loop

In+[31]:+timeit+a**2
100+loops,+best+of+3:+2.77+ms+per+loop

In+[32]:+timeit+np.power(a,+2)
10+loops,+best+of+3:+71.3+ms+per+loop|code-block|syntax|javascript|4578522|entityMap^0|8|3|C|4|H|C|V|E|0|8|1|M|A|27|4|2C|3|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Z|8|@$9|10|A|11|B|C]|$9|12|A|13|B|C]|$9|14|A|15|B|C]|$9|16|A|17|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|18|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|19|8|@]|D|@]|E|$M|N]]|$1|O|3|-4|5|6|7|1A|8|@]|D|@]|E|$]]]|P|$]]

<p>The fastest way is to do <code>a*a</code> or <code>a**2</code> or <code>np.square(a)</code> whereas <code>np.power(a, 2)</code> showed to be considerably slower.</p>

<p><code>np.power()</code> allows you to use different exponents for each element if instead of <code>2</code> you pass another array of exponents. From the comments of @GarethRees I just learned that this function will give you different results than <code>a**2</code> or <code>a*a</code>, which become important in cases where you have small tolerances.</p>

<p>I've timed some examples using NumPy 1.9.0 MKL 64 bit, and the results are shown below:</p>

<pre><code>In [29]: a = np.random.random((1000, 1000))

In [30]: timeit a*a
100 loops, best of 3: 2.78 ms per loop

In [31]: timeit a**2
100 loops, best of 3: 2.77 ms per loop

In [32]: timeit np.power(a, 2)
10 loops, best of 3: 71.3 ms per loop
</code></pre>


blocks|key|72182|text|>>>+import+numpy
>>>+print+numpy.power.__doc__

power(x1,+x2[,+out])

First+array+elements+raised+to+powers+from+second+array,+element-wise.

Raise+each+base+in+`x1`+to+the+positionally-corresponding+power+in
`x2`.++`x1`+and+`x2`+must+be+broadcastable+to+the+same+shape.

Parameters
----------
x1+:+array_like
++++The+bases.
x2+:+array_like
++++The+exponents.

Returns
-------
y+:+ndarray
++++The+bases+in+`x1`+raised+to+the+exponents+in+`x2`.

Examples
--------
Cube+each+element+in+a+list.

>>>+x1+=+range(6)
>>>+x1
[0,+1,+2,+3,+4,+5]
>>>+np.power(x1,+3)
array([++0,+++1,+++8,++27,++64,+125])

Raise+the+bases+to+different+exponents.

>>>+x2+=+[1.0,+2.0,+3.0,+3.0,+2.0,+1.0]
>>>+np.power(x1,+x2)
array([++0.,+++1.,+++8.,++27.,++16.,+++5.])

The+effect+of+broadcasting.

>>>+x2+=+np.array([[1,+2,+3,+3,+2,+1],+[1,+2,+3,+3,+2,+1]])
>>>+x2
array([[1,+2,+3,+3,+2,+1],
+++++++[1,+2,+3,+3,+2,+1]])
>>>+np.power(x1,+x2)
array([[+0,++1,++8,+27,+16,++5],
+++++++[+0,++1,++8,+27,+16,++5]])
>>>|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|72183|精度|unstyled|72184|根据@GarethRees在评论中的反对意见，关于数值精度的讨论：|72185|>>>+a+=+numpy.ones(+(3,3),+dtype+=+numpy.float96+)+#+yields+exact+output
>>>+a[0,0]+=+0.46002700024131926
>>>+a
array([[+0.460027,++1.0,++1.0],
+++++++[+1.0,++1.0,++1.0],
+++++++[+1.0,++1.0,++1.0]],+dtype=float96)
>>>+b+=+numpy.power(+a,+2+)
>>>+b
array([[+0.21162484,++1.0,++1.0],
+++++++[+1.0,++1.0,++1.0],
+++++++[+1.0,++1.0,++1.0]],+dtype=float96)

>>>+a.dtype
dtype('float96')
>>>+a[0,0]
0.46002700024131926
>>>+b[0,0]
0.21162484095102677

>>>+print+b[0,0]
0.211624840951
>>>+print+a[0,0]
0.460027000241|72186|性能|72187|>>>+c++++=+numpy.random.random(+(+1000,+1000+)+).astype(+numpy.float96+)

>>>+import+zmq
>>>+aClk+=+zmq.Stopwatch()

>>>+aClk.start(),+c**2,+aClk.stop()
(None,+array([[+...]],+dtype=float96),+5663L)++++++++++++++++#+++5+663+[usec]

>>>+aClk.start(),+c*c,+aClk.stop()
(None,+array([[+...]],+dtype=float96),+6395L)++++++++++++++++#+++6+395+[usec]

>>>+aClk.start(),+c[:,:]*c[:,:],+aClk.stop()
(None,+array([[+...]],+dtype=float96),+6930L)++++++++++++++++#+++6+930+[usec]

>>>+aClk.start(),+c[:,:]**2,+aClk.stop()
(None,+array([[+...]],+dtype=float96),+6285L)++++++++++++++++#+++6+285+[usec]

>>>+aClk.start(),+numpy.power(+c,+2+),+aClk.stop()
(None,+array([[+...+]],+dtype=float96),+384515L)+++++++++++++#+384+515+[usec]|72188|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|R|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$B|C]]|$1|K|3|L|5|F|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$B|C]]|$1|O|3|-4|5|F|7|W|8|@]|9|@]|A|$]]]|P|$]]

<pre><code>&gt;&gt;&gt; import numpy
&gt;&gt;&gt; print numpy.power.__doc__

power(x1, x2[, out])

First array elements raised to powers from second array, element-wise.

Raise each base in `x1` to the positionally-corresponding power in
`x2`.  `x1` and `x2` must be broadcastable to the same shape.

Parameters
----------
x1 : array_like
    The bases.
x2 : array_like
    The exponents.

Returns
-------
y : ndarray
    The bases in `x1` raised to the exponents in `x2`.

Examples
--------
Cube each element in a list.

&gt;&gt;&gt; x1 = range(6)
&gt;&gt;&gt; x1
[0, 1, 2, 3, 4, 5]
&gt;&gt;&gt; np.power(x1, 3)
array([  0,   1,   8,  27,  64, 125])

Raise the bases to different exponents.

&gt;&gt;&gt; x2 = [1.0, 2.0, 3.0, 3.0, 2.0, 1.0]
&gt;&gt;&gt; np.power(x1, x2)
array([  0.,   1.,   8.,  27.,  16.,   5.])

The effect of broadcasting.

&gt;&gt;&gt; x2 = np.array([[1, 2, 3, 3, 2, 1], [1, 2, 3, 3, 2, 1]])
&gt;&gt;&gt; x2
array([[1, 2, 3, 3, 2, 1],
       [1, 2, 3, 3, 2, 1]])
&gt;&gt;&gt; np.power(x1, x2)
array([[ 0,  1,  8, 27, 16,  5],
       [ 0,  1,  8, 27, 16,  5]])
&gt;&gt;&gt;
</code></pre>

<h2>Precision</h2>

<p>As per the discussed observation on numerical precision as per @GarethRees objection in comments:</p>

<pre><code>&gt;&gt;&gt; a = numpy.ones( (3,3), dtype = numpy.float96 ) # yields exact output
&gt;&gt;&gt; a[0,0] = 0.46002700024131926
&gt;&gt;&gt; a
array([[ 0.460027,  1.0,  1.0],
       [ 1.0,  1.0,  1.0],
       [ 1.0,  1.0,  1.0]], dtype=float96)
&gt;&gt;&gt; b = numpy.power( a, 2 )
&gt;&gt;&gt; b
array([[ 0.21162484,  1.0,  1.0],
       [ 1.0,  1.0,  1.0],
       [ 1.0,  1.0,  1.0]], dtype=float96)

&gt;&gt;&gt; a.dtype
dtype('float96')
&gt;&gt;&gt; a[0,0]
0.46002700024131926
&gt;&gt;&gt; b[0,0]
0.21162484095102677

&gt;&gt;&gt; print b[0,0]
0.211624840951
&gt;&gt;&gt; print a[0,0]
0.460027000241
</code></pre>

<h2>Performance</h2>

<pre><code>&gt;&gt;&gt; c    = numpy.random.random( ( 1000, 1000 ) ).astype( numpy.float96 )

&gt;&gt;&gt; import zmq
&gt;&gt;&gt; aClk = zmq.Stopwatch()

&gt;&gt;&gt; aClk.start(), c**2, aClk.stop()
(None, array([[ ...]], dtype=float96), 5663L)                #   5 663 [usec]

&gt;&gt;&gt; aClk.start(), c*c, aClk.stop()
(None, array([[ ...]], dtype=float96), 6395L)                #   6 395 [usec]

&gt;&gt;&gt; aClk.start(), c[:,:]*c[:,:], aClk.stop()
(None, array([[ ...]], dtype=float96), 6930L)                #   6 930 [usec]

&gt;&gt;&gt; aClk.start(), c[:,:]**2, aClk.stop()
(None, array([[ ...]], dtype=float96), 6285L)                #   6 285 [usec]

&gt;&gt;&gt; aClk.start(), numpy.power( c, 2 ), aClk.stop()
(None, array([[ ... ]], dtype=float96), 384515L)             # 384 515 [usec]
</code></pre>


<p>I need to square a 2D numpy array (elementwise) and I have tried the following code:</p>

<pre><code>import numpy as np
a = np.arange(4).reshape(2, 2)
print a^2, '\n'
print a*a
</code></pre>

<p>that yields:</p>

<pre><code>[[2 3]
[0 1]]

[[0 1]
[4 9]]
</code></pre>

<p>Clearly, the notation <code>a*a</code> gives me the result I want and not <code>a^2</code>. </p>

<p>I would like to know if another notation exists to raise a numpy array to the power of 2 or N? Instead of <code>a*a*a*..*a</code>.</p>


How to square or raise to a power (elementwise) a 2D numpy array?

我需要对2Dnumpy数组进行平方(元素级)，并且我已经尝试了以下代码：import numpy as npa = np.arange(4).reshape(2, 2)print a^2, '\n'print a*a这就产生了：[[2 3][0 1]][[0 1][4 9]]显然，不是a^2，而是a*a给出了我想要的结...

问如何平方或升幂(元素)的二维numpy数组？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何平方或升幂(元素)的二维numpy数组？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何平方或升幂(元素)的二维numpy数组？
EN