One related area where Python is not consistent is operators like +=.

In pretty much all other languages that have them, the expected behavior of A+=B is exactly the same as A=A+B, except that A is only evaluated once. Now lets look at lists in Python:

   xs = [1, 2]
   ys = xs
   ys = ys + [3]
   print(xs, ys)

This prints [1, 2] [1, 2, 3], because the third line created a new list, and made ys reference that. On the other hand, this:

   xs = [1, 2]
   ys = xs
   ys += [3]
   print(xs, ys)

prints [1, 2, 3] [1, 2, 3], because += changes the list itself, and both xs and ys refer to that same list.

(Note that this is not the same as C++, because in the latter, the variables store values directly, while in Python, all variables are references to values.)

The worst part of it is that Python isn't even self-consistent here. If you only define __add__ in your custom class, you can use both + and += with its instances, with the latter behaving normally. But if you define __iadd__, as list does, then you can do whatever you want - and the idiomatic behavior is to modify the instance!

For comparison, C# lets you overload + but not +=, and automatically synthesizes the latter from the former to enforce the correct behavior.