Python augmented assignment issue
arrays, complex-numbers, numbers, numpy, python
Solution
For the `+` operator, Python defines three "special" methods that an object may implement:
- `__add__`: adds two items (`+` operator). When you do `a + b`, the `__add__` method of `a` is called with `b` as an argument.
- `__radd__`: reflected add; for `a + b`, the `__radd__` method of `b` is called with `a` as an instance. This is only used when `a` doesn't know how to do the add and the two objects are different types.
- `__iadd__`: in-place add; used for `a += b` where the result is assigned back to the left variable. This is provided separately because it might be possible to implement it in a more efficient way. For example, if `a` is a list, then `a += b` is the same as `a.extend(b)`. However, in the case of `c = a + b` you have to make a copy of `a` before you extend it since `a` is not to be modified in this case. Note that if you don't implement `__iadd__` then Python will just call `__add__` instead.
So since these different operations are implemented with separate methods, it is possible (but generally bad practice) to implement them so they do totally different things, or perhaps in this case, only slightly different things.
Others have deduced that you're using NumPy and explained its behavior. However, you asked about the underlying implementation. Hopefully you now see why it is sometimes the case that `a += b` is not the same as `a = a + b`. By the way, a similar trio of methods may also be implemented for other operations. See this page for a list of all the supported in-place methods.
Problem
i ran into something interesting about the python augmented assignment `+=` it seems to be automatic data type conversion is not always done for `a += b` if a is a 'simpler' data type, while `a = a + b` seems to work always cases where the conversion is done ``` a = 1 b = 1j a = 1 b = 0.5 ``` case where the conversion is not done ``` from numpy import array a = array([0, 0 ,0]) b = array([0, 0, 1j]) ``` after `a += b`, `a` remains as integer matrix, instead of complex matrix i used to think `a += b` is the same as `a = a + b`, what is the difference of them in the underlying implementation?