two - set difference python

Difference between a-= b and a=a-b in Python (2)

I have recently applied this solution for averaging every N rows of matrix. Although the solution works in general I had problems when applied to a 7x1 array. I have noticed that the problem is when using the -= operator. To make a small example:

import numpy as np

a = np.array([1,2,3])
b = np.copy(a)

a[1:] -= a[:-1]
b[1:] = b[1:] - b[:-1]

print a
print b

which outputs:

[1 1 2]
[1 1 1]

So, in the case of an array a -= b produces a different result than a = a - b . I thought until now that these two ways are exactly the same. What is the difference?

How come the method I am mentioning for summing every N rows in a matrix is working e.g. for a 7x4 matrix but not for a 7x1 array?

Internally, the difference is that this:

a[1:] -= a[:-1]

is equivalent to this:

a[1:] = a[1:].__isub__(a[:-1])
a.__setitem__(slice(1, None, None), a.__getitem__(slice(1, None, None)).__isub__(a.__getitem__(slice(1, None, None)))

while this:

b[1:] = b[1:] - b[:-1]

maps to this:

b[1:] = b[1:].__sub__(b[:-1])
b.__setitem__(slice(1, None, None), b.__getitem__(slice(1, None, None)).__sub__(b.__getitem__(slice(1, None, None)))

In some cases, __sub__() and __isub__() work in a similar way. But mutable objects should mutate and return themselves when using __isub__() , while they should return a new object with __sub__() .

Applying slice operations on numpy objects creates views on them, so using them directly accesses the memory of the "original" object.

The docs say :

The idea behind augmented assignment in Python is that it isn't just an easier way to write the common practice of storing the result of a binary operation in its left-hand operand, but also a way for the left-hand operand in question to know that it should operate `on itself', rather than creating a modified copy of itself.

As a thumb rule, augmented substraction ( x-=y ) is x.__isub__(y) , for IN -place operation IF possible, when normal substraction ( x = x-y ) is x=x.__sub__(y) . On non mutable objects like integers it's equivalent. But for mutable ones like arrays or lists, as in your example, they can be very different things.