After the better part of 20 years working with Python, it still managed to surprise me today. I’m so used to languages treating x += y et al. as pure sugar for x = x + y that it skipped my mind that some don’t. I’m not surprised that you can override them separately in some languages (e.g. I simply assume this to be the case in C++, and on checking it turns out to be true — but that seems fair enough given the scope of the language), but I really am so accustomed to them being only sugar in Ruby that I assumed the same would hold, at least in effect, in Python. Thus my surprise on some_list += x modifying some_list in place (unlike some_list = some_list + x), but once observed, I realised there’d be a separately-overridden operator function — namely __iadd__ — and so I figured it “had” to be that way. Or did it? I then found myself assuming it’s because these operators can’t actually reassign the receiver, but in fact they can and do: the return value is what’s assigned to the LHS. So it’s just a matter of convention.

Lobsters is a community-driven platform for sharing and discussing links to articles, tutorials, and projects related to technology and programming. Readers can learn about a wide range of topics, from software development and system administration to cybersecurity and artificial intelligence. With user submissions, comments, and voting, Lobsters provides a platform for collaborative learning and knowledge sharing among technology enthusiasts.

Lobsters

After nearly 20 years of working with Python, the author was surprised to learn that `some_list += x` modifies the list in place, unlike `some_list = some_list + x`. This led to a realization about the `__iadd__` operator function, which allows in-place modification as part of Python's operator overloading conventions.

Python still surprises