two - set difference python
Difference between a-= b and a=a-b in Python (2)
I have recently applied
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
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
[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)))
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,
work in a similar way. But mutable objects should mutate and return themselves when using
, while they should return a new object with
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 (
possible, when normal substraction (
x = x-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.