blocks|key|877195|text|嗯，他们是为不同的任务，真的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|877196|当您需要整数运算时，使用pow+(等效于带有两个参数的x+**+y+)。|offset|length|style|CODE|877197|如果这两个参数都是浮点数，并且需要浮点输出，则使用math.pow。|877198|有关pow和math.pow之间差异的讨论，请参阅此问题。|877199|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/q/10282674/674039^0|0|C|3|R|6|0|P|8|0|2|3|6|8|Q|2|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|U|8|@$D|V|E|W|F|G]|$D|X|E|Y|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|Z|8|@$D|10|E|11|F|G]]|9|@]|A|$]]|$1|J|3|K|5|6|7|12|8|@$D|13|E|14|F|G]|$D|15|E|16|F|G]]|9|@$D|17|E|18|1|19]]|A|$]]|$1|L|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]]|M|$N|$5|O|P|Q|A|$R|S]]]]

Well, they are for different tasks, really. 

Use <code>pow</code> (equivalent to <code>x ** y</code> with two arguments) when you want integer arithmetic. 

And use <code>math.pow</code> if either argument is float, and you want float output. 

For a discussion on the differences between <code>pow</code> and <code>math.pow</code>, see this <a href="https://stackoverflow.com/q/10282674/674039">question</a>.

blocks|key|877215|text|使用power运算符，**将更快，因为它不会有函数调用的开销。如果反汇编Python代码，您可以看到这一点：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|877216|>>>+dis.dis('7.+**+i')
++1+++++++++++0+LOAD_CONST+++++++++++++++0+(7.0)+
++++++++++++++3+LOAD_NAME++++++++++++++++0+(i)+
++++++++++++++6+BINARY_POWER+++++++++
++++++++++++++7+RETURN_VALUE+++++++++
>>>+dis.dis('pow(7.,+i)')
++1+++++++++++0+LOAD_NAME++++++++++++++++0+(pow)+
++++++++++++++3+LOAD_CONST+++++++++++++++0+(7.0)+
++++++++++++++6+LOAD_NAME++++++++++++++++1+(i)+
++++++++++++++9+CALL_FUNCTION++++++++++++2+(2+positional,+0+keyword+pair)+
+++++++++++++12+RETURN_VALUE+++++++++
>>>+dis.dis('math.pow(7,+i)')
++1+++++++++++0+LOAD_NAME++++++++++++++++0+(math)+
++++++++++++++3+LOAD_ATTR++++++++++++++++1+(pow)+
++++++++++++++6+LOAD_CONST+++++++++++++++0+(7)+
++++++++++++++9+LOAD_NAME++++++++++++++++2+(i)+
+++++++++++++12+CALL_FUNCTION++++++++++++2+(2+positional,+0+keyword+pair)+
+++++++++++++15+RETURN_VALUE+++++++++|code-block|syntax|javascript|877217|注意，这里我使用变量i作为指数，因为像7.+**+5这样的常量表达式实际上是在编译时计算的。|877218|现在，在实践中，这种差异并不重要，正如您在计时时所看到的那样：|877219|>>>+from+timeit+import+timeit
>>>+timeit('7.+**+i',+setup='i+=+5')
0.2894785532627111
>>>+timeit('pow(7.,+i)',+setup='i+=+5')
0.41218495570683444
>>>+timeit('math.pow(7,+i)',+setup='import+math;+i+=+5')
0.5655053168791255|877220|因此，虽然pow和math.pow的速度是原来的两倍，但它们仍然足够快，以至于不太在意。除非你真的能将指数表示为瓶颈，否则如果清晰度下降，就没有理由选择一种方法而另一种方法。这一点尤其适用，因为pow提供了一个集成的模块化操作。|877221|Alfe在上面的评论中提出了一个很好的问题：|877222|timeit显示，在所有情况下，math.pow都比**慢。math.pow()有什么好处？有谁知道它在哪里有什么好处吗？|blockquote|877223|math.pow与内置pow和power操作符**的最大区别在于它总是使用浮点语义。因此，如果您出于某种原因希望确保返回一个浮点数，那么math.pow将确保此属性。|877224|让我们举个例子:我们有两个数字，i和j，但是不知道它们是浮点数还是整数。但是我们希望有一个i%5Ej的浮动结果。那我们有什么选择呢？|877225|我们可以将至少一个参数转换为浮点数，然后执行i+**+j。|unordered-list-item|877226|我们可以执行i+**+j并将结果转换为浮点数(当i或j浮动时会自动使用浮点数指数，因此结果是相同的)。|877227|我们可以使用math.pow。|877228|那么，让我们来测试一下：|877229|>>>+timeit('float(i)+**+j',+setup='i,+j+=+7,+5')
0.7610865891750791
>>>+timeit('i+**+float(j)',+setup='i,+j+=+7,+5')
0.7930400942188385
>>>+timeit('float(i+**+j)',+setup='i,+j+=+7,+5')
0.8946636625872202
>>>+timeit('math.pow(i,+j)',+setup='import+math;+i,+j+=+7,+5')
0.5699394063529439|877230|正如您所看到的，math.pow实际上更快！如果你想一想，函数调用的开销现在也消失了，因为在所有其他选择中，我们必须调用float()。|877231|此外，值得注意的是，可以通过为自定义类型实现特殊的**+(和__rpow__)方法来覆盖pow和__pow__的行为。因此，如果您不想那样做(无论出于什么原因)，那么使用math.pow不会做到这一点。|877232|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.python.org/3/library/functions.html#pow^0|B|2|0|0|A|1|J|7|0|0|0|5|3|9|8|2P|3|2P|3|0|0|0|0|6|G|8|Q|2|U|A|0|0|8|B|3|N|2|1W|8|0|G|1|I|1|19|3|0|M|6|0|6|6|O|1|Q|1|0|6|8|0|0|0|8|8|1O|7|0|P|2|U|8|18|3|1C|7|2D|8|0^^$0|@$1|2|3|4|5|6|7|1O|8|@$9|1P|A|1Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|1R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1S|8|@$9|1T|A|1U|B|C]|$9|1V|A|1W|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|1X|8|@]|D|@]|E|$]]|$1|O|3|P|5|H|7|1Y|8|@]|D|@]|E|$I|J]]|$1|Q|3|R|5|6|7|1Z|8|@$9|20|A|21|B|C]|$9|22|A|23|B|C]|$9|24|A|25|B|C]]|D|@$9|26|A|27|1|28]]|E|$]]|$1|S|3|T|5|6|7|29|8|@]|D|@]|E|$]]|$1|U|3|V|5|W|7|2A|8|@$9|2B|A|2C|B|C]|$9|2D|A|2E|B|C]|$9|2F|A|2G|B|C]|$9|2H|A|2I|B|C]]|D|@]|E|$]]|$1|X|3|Y|5|6|7|2J|8|@$9|2K|A|2L|B|C]|$9|2M|A|2N|B|C]|$9|2O|A|2P|B|C]|$9|2Q|A|2R|B|C]]|D|@]|E|$]]|$1|Z|3|10|5|6|7|2S|8|@$9|2T|A|2U|B|C]|$9|2V|A|2W|B|C]|$9|2X|A|2Y|B|C]]|D|@]|E|$]]|$1|11|3|12|5|13|7|2Z|8|@$9|30|A|31|B|C]]|D|@]|E|$]]|$1|14|3|15|5|13|7|32|8|@$9|33|A|34|B|C]|$9|35|A|36|B|C]|$9|37|A|38|B|C]]|D|@]|E|$]]|$1|16|3|17|5|13|7|39|8|@$9|3A|A|3B|B|C]]|D|@]|E|$]]|$1|18|3|19|5|6|7|3C|8|@]|D|@]|E|$]]|$1|1A|3|1B|5|H|7|3D|8|@]|D|@]|E|$I|J]]|$1|1C|3|1D|5|6|7|3E|8|@$9|3F|A|3G|B|C]|$9|3H|A|3I|B|C]]|D|@]|E|$]]|$1|1E|3|1F|5|6|7|3J|8|@$9|3K|A|3L|B|C]|$9|3M|A|3N|B|C]|$9|3O|A|3P|B|C]|$9|3Q|A|3R|B|C]|$9|3S|A|3T|B|C]]|D|@]|E|$]]|$1|1G|3|-4|5|6|7|3U|8|@]|D|@]|E|$]]]|1H|$1I|$5|1J|1K|1L|E|$1M|1N]]]]

Using the power operator <code>**</code> will be faster as it won’t have the overhead of a function call. You can see this if you disassemble the Python code:

<pre><code>&gt;&gt;&gt; dis.dis('7. ** i')
 1 0 LOAD_CONST 0 (7.0) 
 3 LOAD_NAME 0 (i) 
 6 BINARY_POWER 
 7 RETURN_VALUE 
&gt;&gt;&gt; dis.dis('pow(7., i)')
 1 0 LOAD_NAME 0 (pow) 
 3 LOAD_CONST 0 (7.0) 
 6 LOAD_NAME 1 (i) 
 9 CALL_FUNCTION 2 (2 positional, 0 keyword pair) 
 12 RETURN_VALUE 
&gt;&gt;&gt; dis.dis('math.pow(7, i)')
 1 0 LOAD_NAME 0 (math) 
 3 LOAD_ATTR 1 (pow) 
 6 LOAD_CONST 0 (7) 
 9 LOAD_NAME 2 (i) 
 12 CALL_FUNCTION 2 (2 positional, 0 keyword pair) 
 15 RETURN_VALUE 
</code></pre>

Note that I’m using a variable <code>i</code> as the exponent here because constant expressions like <code>7. ** 5</code> are actually evaluated at compile time.

Now, in practice, this difference does not matter that much, as you can see when timing it:

<pre><code>&gt;&gt;&gt; from timeit import timeit
&gt;&gt;&gt; timeit('7. ** i', setup='i = 5')
0.2894785532627111
&gt;&gt;&gt; timeit('pow(7., i)', setup='i = 5')
0.41218495570683444
&gt;&gt;&gt; timeit('math.pow(7, i)', setup='import math; i = 5')
0.5655053168791255
</code></pre>

So, while <code>pow</code> and <code>math.pow</code> are about twice as slow, they are still fast enough to not care much. Unless you can actually identify the exponentiation as a bottleneck, there won’t be a reason to choose one method over the other if clarity decreases. This especially applies since <a href="http://docs.python.org/3/library/functions.html#pow" rel="noreferrer"><code>pow</code></a> offers an integrated modulo operation for example.

<hr>

Alfe asked a good question in the comments above:

<blockquote>
 <code>timeit</code> shows that <code>math.pow</code> is slower than <code>**</code> in all cases. What is <code>math.pow()</code> good for anyway? Has anybody an idea where it can be of any advantage then?
</blockquote>

The big difference of <code>math.pow</code> to both the builtin <code>pow</code> and the power operator <code>**</code> is that it always uses float semantics. So if you, for some reason, want to make sure you get a float as a result back, then <code>math.pow</code> will ensure this property.

Let’s think of an example: We have two numbers, <code>i</code> and <code>j</code>, and have no idea if they are floats or integers. But we want to have a float result of <code>i^j</code>. So what options do we have?

<ul>
<li>We can convert at least one of the arguments to a float and then do <code>i ** j</code>.</li>
<li>We can do <code>i ** j</code> and convert the result to a float (float exponentation is automatically used when either <code>i</code> or <code>j</code> are floats, so the result is the same).</li>
<li>We can use <code>math.pow</code>.</li>
</ul>

So, let’s test this:

<pre><code>&gt;&gt;&gt; timeit('float(i) ** j', setup='i, j = 7, 5')
0.7610865891750791
&gt;&gt;&gt; timeit('i ** float(j)', setup='i, j = 7, 5')
0.7930400942188385
&gt;&gt;&gt; timeit('float(i ** j)', setup='i, j = 7, 5')
0.8946636625872202
&gt;&gt;&gt; timeit('math.pow(i, j)', setup='import math; i, j = 7, 5')
0.5699394063529439
</code></pre>

As you can see, <code>math.pow</code> is actually faster! And if you think about it, the overhead from the function call is also gone now, because in all the other alternatives we have to call <code>float()</code>.

<hr>

In addition, it might be worth to note that the behavior of <code>**</code> and <code>pow</code> can be overridden by implementing the special <code>__pow__</code> (and <code>__rpow__</code>) method for custom types. So if you don’t want that (for whatever reason), using <code>math.pow</code> won’t do that.

blocks|key|877259|text|对于协议：**操作符等价于函数的两个参数版本，如果前两个参数是整数，则pow函数接受一个可选的第三个参数(模数)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|877260|所以，如果你想用幂来计算余数，就使用内置函数。对于合理大小的参数，math.pow会给出错误的结果：|877261|import+math

base+=+13
exp+=+100
mod+=+2
print+math.pow(base,+exp)+%25+mod
print+pow(base,+exp,+mod)|code-block|syntax|javascript|877262|当我运行这个程序时，我得到了第一种情况下的0.0，这显然是不正确的，因为13是奇数(因此它都是整数)。math.pow版本使用了IEEE-754双精度(52位尾数，略小于小数点16位)的有限精度，这会导致这里的错误。|877263|为了公平起见，我们必须说，math.pow也可以更快：|877264|>>>+import+timeit
>>>+min(timeit.repeat("pow(1.1,+9.9)",+number=2000000,+repeat=5))
0.3063715160001266
>>>+min(timeit.repeat("math.pow(1.1,+9.9)",+setup="import+math",+number=2000000,+repeat=5))
0.2647279420000359|877265|math.pow函数在工程应用中已经(而且仍然有)强大，但是对于数值理论应用程序，您应该使用内置的pow函数。|877266|一些在线例子|877267|http://ideone.com/qaDWRd+(math.pow的错误余数)|unordered-list-item|877268|http://ideone.com/g7J9Un+(在int值上使用pow降低性能)|877269|http://ideone.com/KnEtXj+(在浮点值上使用pow的性能稍低)|877270|更新(不可避免的更正)：|BOLD|877271|我删除了math.pow(2,100)和pow(2,100)的时序比较，因为math.pow给出了一个错误的结果，而例如，pow(2,50)和math.pow(2,50)之间的比较是公平的(尽管这不是math-module函数的实际使用)。我添加了一个更好的，也增加了导致math.pow限制的细节。|877272|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/2/library/functions.html#pow|1|https://en.wikipedia.org/wiki/IEEE_754|2|http://ideone.com/qaDWRd|3|http://ideone.com/g7J9Un|4|http://ideone.com/KnEtXj^0|5|2|Z|3|D|2|0|0|X|8|0|0|L|3|1F|8|1S|8|1|0|D|8|0|0|0|8|1D|3|0|0|Q|8|0|O|2|0|Y|3|0|O|3|0|X|3|0|O|4|0|0|C|0|4|F|K|A|12|8|1P|9|1Z|E|2S|4|3S|8|0^^$0|@$1|2|3|4|5|6|7|1O|8|@$9|1P|A|1Q|B|C]|$9|1R|A|1S|B|C]]|D|@$9|1T|A|1U|1|1V]]|E|$]]|$1|F|3|G|5|6|7|1W|8|@$9|1X|A|1Y|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|1Z|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|20|8|@$9|21|A|22|B|C]|$9|23|A|24|B|C]]|D|@$9|25|A|26|1|27]]|E|$]]|$1|O|3|P|5|6|7|28|8|@$9|29|A|2A|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|J|7|2B|8|@]|D|@]|E|$K|L]]|$1|S|3|T|5|6|7|2C|8|@$9|2D|A|2E|B|C]|$9|2F|A|2G|B|C]]|D|@]|E|$]]|$1|U|3|V|5|6|7|2H|8|@]|D|@]|E|$]]|$1|W|3|X|5|Y|7|2I|8|@$9|2J|A|2K|B|C]]|D|@$9|2L|A|2M|1|2N]]|E|$]]|$1|Z|3|10|5|Y|7|2O|8|@$9|2P|A|2Q|B|C]]|D|@$9|2R|A|2S|1|2T]]|E|$]]|$1|11|3|12|5|Y|7|2U|8|@$9|2V|A|2W|B|C]]|D|@$9|2X|A|2Y|1|2Z]]|E|$]]|$1|13|3|14|5|6|7|30|8|@$9|31|A|32|B|15]]|D|@]|E|$]]|$1|16|3|17|5|6|7|33|8|@$9|34|A|35|B|C]|$9|36|A|37|B|C]|$9|38|A|39|B|C]|$9|3A|A|3B|B|C]|$9|3C|A|3D|B|C]|$9|3E|A|3F|B|C]|$9|3G|A|3H|B|C]]|D|@]|E|$]]|$1|18|3|-4|5|6|7|3I|8|@]|D|@]|E|$]]]|19|$1A|$5|1B|1C|1D|E|$1E|1F]]|1G|$5|1B|1C|1D|E|$1E|1H]]|1I|$5|1B|1C|1D|E|$1E|1J]]|1K|$5|1B|1C|1D|E|$1E|1L]]|1M|$5|1B|1C|1D|E|$1E|1N]]]]

Just for the protocol: The <code>**</code> operator is equivalent to the two-argument version of the <a href="https://docs.python.org/2/library/functions.html#pow" rel="nofollow noreferrer">built-in <code>pow</code> function</a>, the <code>pow</code> function accepts an optional third argument (modulus) if the first two arguments are integers.
So, if you intend to calculate remainders from powers, use the built-in function. The <code>math.pow</code> will give you false results for arguments of reasonable size:
<pre><code>import math

base = 13
exp = 100
mod = 2
print math.pow(base, exp) % mod
print pow(base, exp, mod)
</code></pre>
When I ran this, I got <code>0.0</code> in the first case which obviously cannot be true, because 13 is odd (and therefore all of it's integral powers). The <code>math.pow</code> version uses the limited accuracy of the <a href="https://en.wikipedia.org/wiki/IEEE_754" rel="nofollow noreferrer">IEEE-754</a> Double precision (52 bits mantissa, slightly less than 16 decimal places) which causes an error here.
For sake of fairness, we must say, <code>math.pow</code> can also be faster:
<pre class="lang-py prettyprint-override"><code>&gt;&gt;&gt; import timeit
&gt;&gt;&gt; min(timeit.repeat(&quot;pow(1.1, 9.9)&quot;, number=2000000, repeat=5))
0.3063715160001266
&gt;&gt;&gt; min(timeit.repeat(&quot;math.pow(1.1, 9.9)&quot;, setup=&quot;import math&quot;, number=2000000, repeat=5))
0.2647279420000359
</code></pre>
The <code>math.pow</code> function had (and still has) its strength in engineering applications, but for number theoretical applications, you should use the built-in <code>pow</code> function.
<hr />
Some online examples
<ul>
<li><a href="http://ideone.com/qaDWRd" rel="nofollow noreferrer">http://ideone.com/qaDWRd</a> (wrong remainder with <code>math.pow</code>)</li>
<li><a href="http://ideone.com/g7J9Un" rel="nofollow noreferrer">http://ideone.com/g7J9Un</a> (lower performance with <code>pow</code> on int values)</li>
<li><a href="http://ideone.com/KnEtXj" rel="nofollow noreferrer">http://ideone.com/KnEtXj</a> (slightly lower performance with <code>pow</code> on float values)</li>
</ul>
<hr />
Update (inevitable correction): 
I removed the timing comparison of <code>math.pow(2,100)</code> and <code>pow(2,100)</code> since <code>math.pow</code> gives a wrong result whereas, for example, the comparison between <code>pow(2,50)</code> and <code>math.pow(2,50)</code> would have been fair (although not a realistic use of the <code>math</code>-module function). I added a better one and also the details that cause the limitation of <code>math.pow</code>.

blocks|key|877985|text|**确实比math.pow()更快，但是如果您想要一个简单的二次函数，就像在您的示例中一样，使用产品会更快。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|877986|10.*10.|code-block|syntax|javascript|877987|就会更快|877988|10.**2|877989|对于一个操作(使用timeit)，这种差异并不大，也不明显，但是对于大量的操作，差异可能是显著的。|877990|entityMap^0|0|2|5|A|0|0|0|0|9|6|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|13|8|@]|D|@]|E|$]]]|R|$]]

<code>**</code> is indeed faster then <code>math.pow()</code>, but if you want a simple quadratic function like in your example it is even faster to use a product.

<pre><code>10.*10.
</code></pre>

will be faster then 

<pre><code>10.**2
</code></pre>

The difference is not big and not noticable with one operation (using <code>timeit</code>), but with a large number of operations it can be significant.

blocks|key|2596989|text|pow()函数将允许您将第三个参数添加为模数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2596990|例如:最近我在执行以下操作时遇到内存错误|2596991|2**23375247598357347582+%25+23375247598357347583|blockquote|2596992|相反，我做到了：|2596993|pow(2,+23375247598357347582,+23375247598357347583)|offset|length|style|CODE|2596994|这仅以毫秒为单位返回，而不是普通指数所需的大量时间和内存。因此，当处理大数和平行模时，pow()是更有效的，而当处理没有模的较小数时，**则更有效。|2596995|entityMap^0|0|0|0|0|0|1E|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|V|8|@]|9|@]|A|$]]|$1|I|3|J|5|F|7|W|8|@$K|X|L|Y|M|N]]|9|@]|A|$]]|$1|O|3|P|5|6|7|Z|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|10|8|@]|9|@]|A|$]]]|R|$]]

The pow() function will allow you to add a third argument as a modulus. 

For example: I was recently faced with a memory error when doing 

<blockquote>
 2**23375247598357347582 % 23375247598357347583 
</blockquote>

Instead I did:

<blockquote>
 <code>pow(2, 23375247598357347582, 23375247598357347583)</code>
</blockquote>

This returns in mere milliseconds instead of the massive amount of time and memory that the plain exponent takes. So, when dealing with large numbers and parallel modulus, pow() is more efficient, however when dealing with smaller numbers without modulus, ** is more efficient.

Which one is more efficient using <code>math.pow</code> or the <code>**</code> operator? When should I use one over the other?
So far I know that <code>x**y</code> can return an <code>int</code> or a <code>float</code> if you use a decimal
the function <code>pow</code> will return a float
<pre><code>import math

print( math.pow(10, 2) )

print( 10. ** 2 )
</code></pre>

Exponentials in python: x**y vs math.pow(x, y)

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

使用math.pow或**运算符哪个更有效？我什么时候应该用一个而另一个呢？到目前为止，我知道x**y可以返回int或float，如果使用十进制函数，则pow函数将返回浮点数。import mathprint( math.pow(10, 2) )print( 10. ** 2 )

问python中的指数: x**y与math.pow(x，y)
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问python中的指数: x**y与math.pow(x，y)EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问python中的指数: x**y与math.pow(x，y)
EN