Understanding Mutable and Immutable Objects in Python

Sure! Here’s a simplified explanation of mutable and immutable objects in Python:

Understanding Mutable and Immutable Objects in Python#

In Python, objects can be either mutable or immutable. This means some objects can change their values after creation, while others cannot.

Mutable Objects#

Mutable objects can be changed after they are created. Examples include lists, dictionaries, and sets.

Immutable Objects#

Immutable objects cannot be changed once they are created. Examples include strings, integers, and tuples.

How Assignments Work#

When you assign a value to a variable, Python stores that value in memory, and the variable points to that memory location.

rtr_addr = "10.1.1.1"

If you assign another variable to the same value, both variables point to the same memory location.

gate_way = rtr_addr

Identifying Objects with id()#

You can use the id() function to get the unique identifier of an object in memory.

id(rtr_addr)  # Example output: 1513552872240
id(gate_way)  # Example output: 1513552872240

Immutable Objects in Action#

When you change the value of an immutable object, Python creates a new object in memory.

ssh_timeout = 20
id(ssh_timeout)  # Example output: 1513546842960

ssh_timeout = 10
id(ssh_timeout)  # Example output: 1513546842640

Even when you increment an immutable object, a new object is created.

ssh_timeout += 1
id(ssh_timeout)  # Example output: 1513546842672

Types of Immutable Objects#

  • None

  • Booleans (True and False)

  • Strings

  • Integers

  • Floats

Understanding these concepts helps you write better Python code and avoid unexpected behavior.

Sure! Here’s a simplified explanation of mutable objects in Python, focusing on lists:

Mutable Objects in Python#

In Python, mutable objects can change their values after they are created. Let’s look at lists as an example.

What Are Mutable Objects?#

Mutable objects allow their values to be modified after creation. Examples include lists, dictionaries, and sets. We’ll focus on lists here.

Working with Lists#

Let’s create a list called data_center with some elements.

data_center = ["sf", "la", "den", "dal"]
id(data_center)

The id() function gives the unique identifier for the data_center list, showing its memory location.

Modifying Lists#

Now, let’s add a new element, “ny,” to the data_center list.

data_center.append("ny")
id(data_center)

Even after adding an element, the list’s identifier remains the same because lists are mutable. Python doesn’t create a new list; it modifies the existing one.

How Lists Work Internally#

Python allocates a continuous block of memory for a list, but it stores pointers to the elements, not the elements themselves.

Memory Addresses#

A list contains references (pointers) to the actual data objects. Here’s a simplified view:

P1

P2

P3

P4

P5

sf

la

den

dal

ny

P1, P2, P3, P4, and P5 are pointers to the elements. The list holds references to where the elements are stored in memory.

You can check the id() of individual list elements:

id(data_center[0])  # Example output: 1668505141296
id(data_center)     # Example output: 1668504824832

Variable Assignment and List Mutability#

If you create a new variable, my_dc, and assign it the value of data_center, both variables point to the same list in memory:

my_dc = data_center
id(my_dc)  # Example output: 1668504824832

Modifying my_dc also affects data_center because they refer to the same object. To avoid this, use the copy() method to create a shallow copy:

my_dc = data_center.copy()
id(my_dc)  # Example output: 1668505142144

With a shallow copy, modifying one list doesn’t affect the other.

Understanding mutable objects like lists helps you work effectively with data structures and ensures changes to variables behave as expected.

Contents