[Python-ideas] Reverse assignment operators (=+, =-, =*, =/, =//, =**, =%)

[Thomas Nyberg]

On 11/14/2016 03:42 PM, Mikhail V wrote:
> On 14 November 2016 at 19:57, Nick Timkovich <prometheus235 at gmail.com> wrote:
>
> I can understand you good. But imagine, if Numpy would allow you to
> simply write:
> A = A + 1
> Which would bring you directly to same internal procedure as A += 1.
> So it does not currently, why?
> I've tested now A += 99 against A = A + 99 and there is indeed a 30% speed
> difference. So it functions different.
>
> Would you then still want to write += ?
> I never would. Also I think to implement this syntax would be almost
> trivial, it should
> just take the A = A part and do the rest as usual.
>
> And this for equally sized arrays:
> A = A + B
>
> Should just add B values to A values in-place. Now it gives me also
> ~30% speed difference
> compared to A += B.
>

If you take this file:

test.py
----------------------------------------------
a = a + 1
a += 1
----------------------------------------------

And you look at the bytecode it produces you get the following:

----------------------------------------------
$ python -m dis test.py
   1           0 LOAD_NAME                0 (a)
               3 LOAD_CONST               0 (1)
               6 BINARY_ADD
               7 STORE_NAME               0 (a)

   2          10 LOAD_NAME                0 (a)
              13 LOAD_CONST               0 (1)
              16 INPLACE_ADD
              17 STORE_NAME               0 (a)
              20 LOAD_CONST               1 (None)
              23 RETURN_VALUE
----------------------------------------------

That shows that the first and second lines are compiled _differently_. 
The point is that in the first line, numpy does not have the information 
necessary to know that "a + 1" will be assigned back to a. In the second 
case it does. This is presumably why they couldn't do the optimization 
you desire without large changes in cpython.

On the second point, personally I prefer writing "a += 1" to "a = a + 
1". I think it's clearer and would keep using it even if the two were 
equally efficient. But we are all allowed our opinions...

Cheers,
Thomas