Understanding Python’s += Operator and Mutable Tuples

Operators are a fundamental part of modern programming, and Python provides a rich set of them. Among these, the plus‑equals (+=) operator may look like a simple combination of addition and assignment, but it has several interesting characteristics worth exploring.

In Python, += can be seen as a shortcut for adding a value to a variable and reassigning the result. For example:

<code>x = 5
x += 5
print(x)  # 10</code>

While the choice of using the explicit form or the shorthand is a matter of personal preference, the shorthand often makes code more concise.

Python tuples are immutable, meaning the tuple object itself cannot be changed after creation. However, the objects stored inside a tuple can be mutable. For instance, a tuple may contain a list, and that list can be modified without altering the tuple structure:

<code>z = (5, 10, 15)
# Attempting to assign to a tuple element raises an error
# z[4] = 15  # TypeError
newnum = z[2]
newnum += 5
print(newnum)  # 20</code>

Consider a tuple that holds lists:

<code>letters = (["S", "T"], ["A", "D"])
letters[0] += "Q"
print(letters[0])  # ['S', 'T', 'Q']</code>

Even though the tuple itself is immutable, the mutable list inside it can be altered, demonstrating that Python distinguishes between the mutability of the container and the mutability of its contents.

The += operator works internally by calling the object's __iadd__ method. A simplified implementation might look like:

<code>def plusequals(num1, num2):
    total = num1.__iadd__(num2)
    num1 = total</code>

When used with more complex expressions, such as indexing into a list inside a tuple, the same principle applies, but attempting to assign the result back to a tuple element will still raise a type error because the tuple itself cannot be reassigned.