Immutable, Mutable, and Identity

Lists and Mutability

In Python, lists are data structures that can be modified after they are created. Let's understand how lists behave when we perform certain operations.

When you create a list and store it in a variable, Python doesn't copy the contents of that list. Instead, the variable stores a reference or memory address where the list is located. Think of it like a house address, the variable only stores the address, not the house itself.

# Creating list and providing referencelist1 = [0, 1, 2]list2 = ['a', list1, True]print(list2)  # ['a', [0, 1, 2], True]# Changing elements in list1list1[1] = [3, 4, 5]print(list2)  # ['a', [0, [3, 4, 5], 2], True]

Notice how changes to list1 also affect list2. This happens because list2 doesn't store a copy of list1, but rather a reference to the same list object in memory.

Slice Operations Create New Copies

Unlike regular assignment, slice operations on lists will create a new list object in memory. You can prove this by using the id() function which returns the memory address of an object.

# Slice operations create new listslist1 = [0, 1, 2]list2 = list1[:]  # Taking all elements with sliceprint(id(list1))  # Example: 3104print(id(list2))  # Example: 8864 (different from list1)# Changing elements in list2 doesn't affect list1list2[0] = 'x'print(list1)  # [0, 1, 2] (unchanged)print(list2)  # ['x', 1, 2]

Object Identity, Type, and Value

Every object in Python has three important characteristics that distinguish it from other objects.

Object Identity

Identity is the unique memory address where an object is stored. Python provides the id() function to view an object's identity and the is operator to compare the identity of two objects.

a = 300print(a)          # 300print(type(a))    # <class 'int'>print(id(a))      # 10120b = a  # b references the same object as aprint(id(b))      # 10120 (same as a)a = a + 1  # Creates new objectprint(id(a))      # 10492 (different from before)

Identity and Value Comparison

Python has special optimization for small integers (usually $-5$ to $256$). Integers in this range use the same object in memory to save space.

# Large integers may use different objectsa = 300b = 300print(a is b)      # May be True or False (implementation dependent)print(a == b)      # True (same value)# Integers in range -5 to 256 usually samea = 100b = 100print(a is b)      # True (optimization for small integers)print(a == b)      # True (same value)

Mutable and Immutable Objects

Python classifies objects based on their ability to be changed after creation.

Immutable Objects

Immutable objects cannot be changed after creation. Any operation that appears to change the object actually creates a new object.

# Integer is immutablea = 300print(id(a))  # 10120a = a + 1     # Creates new objectprint(id(a))  # 10492 (different)# String is also immutablestr_var = 'hello'print(id(str_var))  # 75568# Trying to change string will result in error# str_var[1] = 'a'  # TypeError

Immutable data types in Python include:

• bool (boolean)
• int (integer)
• float (floating point)
• complex (complex numbers)
• str (string)
• tuple (tuple)

Mutable Objects

Mutable objects can be changed after creation without creating a new object. The object's identity remains the same even though its value changes.

# List is mutablelist_var = [0, 1, 2]print(id(list_var))  # 15296# Changing elements doesn't change object identitylist_var = [0, 0, 0]print(id(list_var))  # 60960 (new object due to assignment)# In-place modification maintains identitylist_var[:] = ['a', 'b', 'c']print(id(list_var))  # 60960 (same)

Mutable data types in Python include:

• list (list)
• dict (dictionary)
• set (set)

Assignment vs Modification Behavior

It's important to distinguish between assignment (giving new value) and in-place modification.

list1 = [0, 1, 2]list2 = list1  # Both variables reference the same objectprint(id(list1))     # 700print(id(list2))     # 700 (same)# In-place modification affects both variableslist1[1] = 'x'print(list1)         # [0, 'x', 2]print(list2)         # [0, 'x', 2] (also changed)# Assignment creates new referencelist1 = [1, 2, 3]print(list1)         # [1, 2, 3]print(list2)         # [0, 'x', 2] (unchanged)

Understanding mutability is very important in Python programming. Immutable objects are safer to use in multi-threading contexts because they cannot be changed, while mutable objects provide flexibility to modify data efficiently without creating new objects every time.