blocks|key|4158787|text|使用timeit可以很容易地检查这种类型的查询。以下是使用Python2.7的结果。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4158788|root:/var#+python+-m+timeit+"f1+=+lambda+x:x;+f2+=+lambda+x:+x*2;+a=f1(2);+b=f2(a)"
1000000+loops,+best+of+3:+0.29+usec+per+loop
root:/var#+python+-m+timeit+"f1+=+lambda+x:x;+f2+=+lambda+x:+x*2;+b=f2(f1(2))"
1000000+loops,+best+of+3:+0.284+usec+per+loop
root:/var#+python+-m+timeit+"f1+=+lambda+x:x;+f2+=+lambda+x:+x*2;+a=f1(2);+b=f2(a)"
1000000+loops,+best+of+3:+0.285+usec+per+loop
root:/var#+python+-m+timeit+"f1+=+lambda+x:x;+f2+=+lambda+x:+x*2;+b=f2(f1(2))"
1000000+loops,+best+of+3:+0.283+usec+per+loop
root:/var#+python+-m+timeit+"f1+=+lambda+x:x;+f2+=+lambda+x:+x*2;+a=f1(2);+b=f2(a)"
1000000+loops,+best+of+3:+0.294+usec+per+loop
root:/var#+python+-m+timeit+"f1+=+lambda+x:x;+f2+=+lambda+x:+x*2;+b=f2(f1(2))"
1000000+loops,+best+of+3:+0.286+usec+per+loop|code-block|syntax|javascript|4158789|这显示了与其他描述dis模块用法的答案一致的结果。|4158790|entityMap^0|2|6|T|9|0|0|9|3|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|X|8|@]|D|@]|E|$]]]|N|$]]

Such type of queries could be easily checked with <code>timeit</code>. Here are the results with <code>Python2.7</code>.

<pre><code>root:/var# python -m timeit "f1 = lambda x:x; f2 = lambda x: x*2; a=f1(2); b=f2(a)"
1000000 loops, best of 3: 0.29 usec per loop
root:/var# python -m timeit "f1 = lambda x:x; f2 = lambda x: x*2; b=f2(f1(2))"
1000000 loops, best of 3: 0.284 usec per loop
root:/var# python -m timeit "f1 = lambda x:x; f2 = lambda x: x*2; a=f1(2); b=f2(a)"
1000000 loops, best of 3: 0.285 usec per loop
root:/var# python -m timeit "f1 = lambda x:x; f2 = lambda x: x*2; b=f2(f1(2))"
1000000 loops, best of 3: 0.283 usec per loop
root:/var# python -m timeit "f1 = lambda x:x; f2 = lambda x: x*2; a=f1(2); b=f2(a)"
1000000 loops, best of 3: 0.294 usec per loop
root:/var# python -m timeit "f1 = lambda x:x; f2 = lambda x: x*2; b=f2(f1(2))"
1000000 loops, best of 3: 0.286 usec per loop
</code></pre>

And this shows consistent results with other answers that describe the use the the awesome <code>dis</code> module.

blocks|key|4158443|text|因此，使用非常有趣的dis模块，我们可以查看从您提供的python代码生成的实际字节码。为了简单起见，我用内置函数(int和float)替换了func和func2。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4158444|所以我们的源看起来是这样的：|4158445|def+assign():
++++a+=+int()
++++b+=+float(a)|code-block|syntax|javascript|4158446|与简化版本相比：|4158447|def+simple():
++++b+=+float(int())|4158448|然后从cpython2.7解释器开始，我们可以看到从assign函数生成的字节码：|4158449|dis.dis(assign)
++2+++++++++++0+LOAD_GLOBAL++++++++++++++0+(int)
++++++++++++++3+CALL_FUNCTION++++++++++++0
++++++++++++++6+STORE_FAST+++++++++++++++0+(a)

++3+++++++++++9+LOAD_GLOBAL++++++++++++++1+(float)
+++++++++++++12+LOAD_FAST++++++++++++++++0+(a)
+++++++++++++15+CALL_FUNCTION++++++++++++1
+++++++++++++18+STORE_FAST+++++++++++++++1+(b)
+++++++++++++21+LOAD_CONST+++++++++++++++0+(None)
+++++++++++++24+RETURN_VALUE|4158450|正如您所看到的，没有进行窥视优化来删除不必要的中间变量，与简化的“简单方法”的字节码相比，这会导致额外的2条指令(STORE_FAST+a，LOAD_FAST+a)：|4158451|dis.dis(simple)
++2+++++++++++0+LOAD_GLOBAL++++++++++++++0+(float)
++++++++++++++3+LOAD_GLOBAL++++++++++++++1+(int)
++++++++++++++6+CALL_FUNCTION++++++++++++0
++++++++++++++9+CALL_FUNCTION++++++++++++1
+++++++++++++12+STORE_FAST+++++++++++++++0+(b)
+++++++++++++15+LOAD_CONST+++++++++++++++0+(None)
+++++++++++++18+RETURN_VALUE|4158452|这对于Python3.5的CPython解释器和Python2.7的pypy解释器是相同的。|4158453|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/3/library/dis.html^0|A|3|1M|3|1Q|5|1Z|4|24|5|A|3|0|0|0|0|0|0|Q|6|0|0|1L|C|1Y|B|0|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@$9|19|A|1A|B|C]|$9|1B|A|1C|B|C]|$9|1D|A|1E|B|C]|$9|1F|A|1G|B|C]|$9|1H|A|1I|B|C]]|D|@$9|1J|A|1K|1|1L]]|E|$]]|$1|F|3|G|5|6|7|1M|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|1N|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1O|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|1P|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|1Q|8|@$9|1R|A|1S|B|C]]|D|@]|E|$]]|$1|S|3|T|5|J|7|1T|8|@]|D|@]|E|$K|L]]|$1|U|3|V|5|6|7|1U|8|@$9|1V|A|1W|B|C]|$9|1X|A|1Y|B|C]]|D|@]|E|$]]|$1|W|3|X|5|J|7|1Z|8|@]|D|@]|E|$K|L]]|$1|Y|3|Z|5|6|7|20|8|@]|D|@]|E|$]]|$1|10|3|-4|5|6|7|21|8|@]|D|@]|E|$]]]|11|$12|$5|13|14|15|E|$16|17]]]]

So using the very fun <a href="https://docs.python.org/3/library/dis.html" rel="noreferrer"><code>dis</code></a> module we can look into the actual bytecode that is generated from the python code you provided. To keep things simple I have replaced <code>func</code> and <code>func2</code> with builtin functions (<code>int</code> and <code>float</code>).

So our source looks like this:

<pre><code>def assign():
 a = int()
 b = float(a)
</code></pre>

Versus a simplified version:

<pre><code>def simple():
 b = float(int())
</code></pre>

And then starting with the cpython 2.7 interpretter, we can see the bytecodes generated from the <code>assign</code> function:

<pre><code>dis.dis(assign)
 2 0 LOAD_GLOBAL 0 (int)
 3 CALL_FUNCTION 0
 6 STORE_FAST 0 (a)

 3 9 LOAD_GLOBAL 1 (float)
 12 LOAD_FAST 0 (a)
 15 CALL_FUNCTION 1
 18 STORE_FAST 1 (b)
 21 LOAD_CONST 0 (None)
 24 RETURN_VALUE
</code></pre>

As you can see there is no peephole optimization to remove the unnecessary intermediate variable, which results in an additional 2 instructions (<code>STORE_FAST a</code>, <code>LOAD_FAST a</code>) when compared against the bytecodes for the simplified `simple method: 

<pre><code>dis.dis(simple)
 2 0 LOAD_GLOBAL 0 (float)
 3 LOAD_GLOBAL 1 (int)
 6 CALL_FUNCTION 0
 9 CALL_FUNCTION 1
 12 STORE_FAST 0 (b)
 15 LOAD_CONST 0 (None)
 18 RETURN_VALUE
</code></pre>

This is the same for the CPython interpreter for Python 3.5, and for the pypy interpreter for Python 2.7.

blocks|key|4158479|text|实际时间将取决于func()和func2()所做的函数。这不是最好的例子，但下面给出了一个快速(和肮脏)的测试代码：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4158480|import+time

def+func(x):
++++return+5

def+func2(a):
++++return+10

t0+=+time.time()
x+=+10
for+i+in+range(1,10000):
++++a+=+func(x)
++++b+=+func2(a)
t1+=+time.time()

print("Time+1:+",+t1-t0)

t2+=+time.time()
x+=+10
for+i+in+range(1,10000):
++++b+=+func2(func(x))
t3+=+time.time()

print("Time+2:+",+t3-t2)|code-block|syntax|javascript|4158481|上述代码的输出为：|4158482|Time+1:++0.0029211044311523438
Time+2:++0.002785921096801758|4158483|所以，是的，在Pyhton+3中，我们避免了a赋值的实现稍微快了一点。|4158484|entityMap^0|8|6|F|7|0|0|0|0|M|1|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|$]]

The actual time will depend on the functions <code>func()</code> and <code>func2()</code> do. Not the best example, but a quick (and dirty) test code is given below:

<pre><code>import time

def func(x):
 return 5

def func2(a):
 return 10

t0 = time.time()
x = 10
for i in range(1,10000):
 a = func(x)
 b = func2(a)
t1 = time.time()

print("Time 1: ", t1-t0)

t2 = time.time()
x = 10
for i in range(1,10000):
 b = func2(func(x))
t3 = time.time()

print("Time 2: ", t3-t2)
</code></pre>

The output of the above code is:

<pre><code>Time 1: 0.0029211044311523438
Time 2: 0.002785921096801758
</code></pre>

So yes, the implementation where we avoid the assignment of <code>a</code> is marginally faster in Pyhton 3.

Suppose I have the following in a really tight loop:

<pre><code>a = func(x)
b = func2(a)
</code></pre>

The variable <code>a</code> is not used anywhere else.

Does Python automatically compile away the assignment to <code>a</code>, or does it take the time to do the variable assignment every time? In other words, is this code identical, or is it marginally faster due to the lack of assigning to <code>a</code>?

<pre><code>b = func2(func(x))
</code></pre>

Is the behavior the same for Python2.7 vs Python3?

Time to assign a variable in Python

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

假设我在一个非常紧凑的循环中有以下内容：a = func(x)b = func2(a)变量a不会在其他任何地方使用。Python会自动将赋值编译为a，还是每次都要花时间进行变量赋值？换句话说，这段代码是相同的，还是由于没有赋值给a而稍微快了一点b = func2(func(x))Python2.7和Python3的行为...

问在Python中赋值变量的时间
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Python中赋值变量的时间EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Python中赋值变量的时间
EN