What is this operator *= -1
Question: I'm going through some Python activities and was given example code with this
operator: `y *= -1`

I had a look through the [relevant Python
docs](http://docs.python.org/3/library/stdtypes.html#boolean-operations-and-
or-not), to no avail.

I know `y += 1`, for example, is short for `y = y + 1`. So is this `y = y *
-1` y equals y times -1 maybe?

Closest thing in Python docs I could find is this: `x * y`: _product of x and
y_

Is this it?


Answer: In the vast majority of the cases

    
    
    y *= <expr>
    

is the same as

    
    
    y = y * <expr>
    

but in the general case, it is interpreted as:

    
    
    y = imul(y, <expr>)
    

which is then equivalent to:

    
    
    y = y.__imul__(<expr>)
    

if `y`'s type overrides
[`__imul__`](http://docs.python.org/2/library/operator.html#operator.__imul__).

This means that if `y`'s type overrides the _inplace_ multiplication operator,
`y*=<expr>` is performed _inplace_ , while `y=y*<expr>` is not.

* * *

**EDIT**

It might not be immediately clear why the assignment is needed, i.e. why it is
intrepreted as `y = imul(y, <expr>)`, and not just `imul(y, <expr>)`.

The reason is that it makes a lot of sense for the following two scenarios to
give the same result:

    
    
    c = a * b
    

and

    
    
    c = a
    c *= b
    

Now, this of course works if `a` and `b` are of the same type (e.g. floats,
numpy arrays, etc.), but if they aren't, it is possible for the result of the
operation to have the type of `b`, in which case the operation cannot be an
inplace operation of `a`, thus the result needs to be assigned to `a`, in
order to achieve the correct behavior.

For example, this works, thanks to the assignment:

    
    
    from numpy import arange
    a = 2
    a *= arange(3)
    a
    => array([0, 2, 4])
    

Whereas if the assignment is dropped, `a` remains unchanged:

    
    
    a = 2
    imul(a, arange(3))
    => array([0, 2, 4])
    a
    => 2
    

