Why does x += 1 behave differently with integers vs lists in Python?

[Istituto-freudinttheprodev]

Body

Confusing behavior I discovered

I found something weird about += in Python that's breaking my understanding of how variables work:

With integers (behaves as expected):

def test_int():
    x = 5
    y = x
    x += 1
    print(f"x = {x}, y = {y}")  # x = 6, y = 5

test_int()  # Makes sense - y is unchanged

## With lists (unexpected behavior):
```python
def test_list():
    x = [1, 2, 3]
    y = x
    x += [4]
    print(f"x = {x}, y = {y}")  # x = [1, 2, 3, 4], y = [1, 2, 3, 4]

test_list()  # Wait... why did y change too?!

## Even weirder - this behaves differently:
```python
def test_list_concat():
    x = [1, 2, 3]
    y = x
    x = x + [4]  # Using + instead of +=
    print(f"x = {x}, y = {y}")  # x = [1, 2, 3, 4], y = [1, 2, 3]

test_list_concat()  # Now y is unchanged again

## My confusion:

- Why does x += [4] modify the original list that y points to?
- Why does x = x + [4] create a new list instead?
I thought += and = x + were the same thing!

This is really messing with my head. Can someone explain what's actually happening here?
I'm using Python 3.11 and this behavior is consistent across different environments.

### Guidelines

- [X] I have read and understood this category's [guidelines](https://github.com/orgs/community/discussions/51384) before making this post.

[MatteoMgr2008]

Excellent question! This is one of Python's most confusing concepts, and you've discovered the difference between mutable and immutable objects.

What's really happening:

The key insight: += calls different methods

# For integers (immutable):
x += 1  # Actually calls: x = x.__add__(1)  -> creates new object

# For lists (mutable):  
x += [4]  # Actually calls: x.__iadd__([4])  -> modifies existing object
Let's trace through your examples:
Example 1 - Integers:
pythonx = 5        # x points to integer object 5
y = x        # y also points to the same integer object 5
x += 1       # Creates NEW integer object 6, x now points to it
             # y still points to the original integer object 5
Example 2 - Lists with +=:
pythonx = [1, 2, 3]    # x points to list object
y = x            # y points to the SAME list object
x += [4]         # Modifies the existing list object (adds 4 to it)
                 # Both x and y still point to the same modified list
Example 3 - Lists with + (concatenation):
pythonx = [1, 2, 3]    # x points to list object  
y = x            # y points to the SAME list object
x = x + [4]      # Creates a NEW list object, x points to new list
                 # y still points to the original list
The rule:
python# Mutable objects (lists, dicts, sets):
x += something   # Modifies existing object (calls __iadd__)
x = x + something # Creates new object (calls __add__)

# Immutable objects (int, str, tuple):
x += something   # Always creates new object (no __iadd__ method)
x = x + something # Also creates new object
Proof with object IDs:
python# Lists
x = [1, 2, 3]
print(f"Original x id: {id(x)}")
x += [4]
print(f"After += x id: {id(x)}")    # Same ID!

x = [1, 2, 3]  
print(f"Reset x id: {id(x)}")
x = x + [4]
print(f"After + x id: {id(x)}")     # Different ID!

# Integers
x = 5
print(f"Original x id: {id(x)}")
x += 1
print(f"After += x id: {id(x)}")    # Different ID!
Practical implications:
python# This can cause bugs:
def add_item(my_list, item):
    my_list += [item]  # Modifies the original list!
    return my_list

original = [1, 2, 3]
result = add_item(original, 4)
print(original)  # [1, 2, 3, 4] - original was modified!

# Safer approach:
def add_item_safe(my_list, item):
    return my_list + [item]  # Returns new list

original = [1, 2, 3]  
result = add_item_safe(original, 4)
print(original)  # [1, 2, 3] - original unchanged
Memory tip:

Mutable objects: += modifies in place
Immutable objects: += creates new object
Both types: = x + always creates new object

This behavior exists because it's more efficient to modify lists in place rather than creating new ones every time, but it can definitely be confusing at first!
Your observation is spot-on - this trips up many Python developers, even experienced ones.

[Istituto-freudinttheprodev]

Thank you so much for the answer!