为什么加法赋值比赋值慢很多？

Question

I'm quite new to improving python efficiency. So i've made some tests like;

Example 1:

num = 0
num = 2*2
# time: 13.8 ns ± 0.158 ns per loop

Example 2:

num = 0
num += 2*2
# time: 23.8 ns ± 0.232 ns per loop

I am wondering why using addition assignment is much slower, is it because it has addition?

Answer 1

It will become clearer if you use the dis module and wrap everything in a function:

    import dis
    def change_link():
        num = 0
        num = 2*2
    def add():
        num = 0 
        num += 2*2

    dis.dis(change_link)
    dis.dis(add)

You will see that change_link() function has fewer steps:

0 LOAD_CONST               1 (0)
2 STORE_FAST               0 (num)
4 LOAD_CONST               2 (4)
6 STORE_FAST               0 (num)
8 LOAD_CONST               0 (None)
10 RETURN_VALUE

instead of add() function:

0 LOAD_CONST               1 (0)
2 STORE_FAST               0 (num)
4 LOAD_FAST                0 (num)
6 LOAD_CONST               2 (4)
8 INPLACE_ADD
10 STORE_FAST               0 (num)
12 LOAD_CONST               0 (None)
14 RETURN_VALUE

Simply put, there is much easier to change link to value, than correct (ex. add or multiply) the value.

Answer 2

is it because it has addition?

Yes, addition assignment requires the value to be read from memory before writing the new value, whereas a simple assignment does not require this reading step and can just write the value, making it faster.

Answer 3

Well, in one case you have 2 operations: 1 multiplication 2*2 (assuming that it is not already done at parse time. I don't really know the internal of the interpreter. It probably is), and 1 assignment num=4 .

In the other 3: 1 multiplication 2*2 , 1 addition num+4 , and one assignment num=4

Note that the ratio is certainly less than 3/2 in time. Because anyway, those are probably not the heaviest part of the computation. Accessing memory for example takes longer that an addition. Plus, there is the measurement time. If you measure

for i in range(100000000):
   x=2*2

a good part of what you'll measure is the for loop.

So, there is a big common part in timings. And only a small part is about the difference between the 2 operations. The 3/2 (more realisticly 2/1, since I am pretty sure, without knowing anything about it, that python replace 2*2 by 4 at parsing time. Even my own simple pedagogical interpreters do so. That's a basic feature, and python interpreters are generally not basic), so that 3/2 or 2/1 ratio applies only on a fraction of the computation time.

But, well, it is quite normal that x+=2*2 is more expansive than x=2*2 , even if only slightly so.