Mutable, Immutable... In python everything is an object!

Ready to unravel the mysteries of Python like it’s a season finale of your favorite show? Let's dive deep into the ("mysterious at first") thrilling world of mutable and immutable objects. Think of mutable objects as those friends who are always up for a spontaneous road trip, while immutable objects are more like that one person who insists on sticking to their plans no matter what. This knowledge will help you write code that’s cleaner, smarter, and less likely to make you want to throw your laptop out the window. You wouldn't want to do that. Especially in Kigali. Its hilly. At the same time its steep. I kid you not, try loose grip of your house keys, you'll quickly find out. Tssk!

So, grab your favorite debugging snack and let’s get this party started!

ID and Type

First things first, every object in Python has a unique identity, a type, and a value. Think of the identity as the object's home address in memory, which you can check using the id() function. The type tells you what kind of object it is (like an integer, list, etc.), and you can find this out using the type() function. Here’s a quick peek:

These basic attributes are the building blocks for understanding how Python handles different objects.

Mutable Objects

Mutable objects are like clay; you can mold and change them after they’re created. Common examples in Python are lists, dictionaries, and sets. Here’s how it works with a list:

Notice that even after adding a new item, the list’s id remains the same. This shows that the list itself has been modified, not replaced.

Immutable Objects

On the flip side, immutable objects are like sculptures carved in stone; once they’re created, they can’t be changed. Examples include integers, floats, strings, and tuples. Let’s look at a tuple:

Here, trying to change the tuple actually creates a new tuple with a different id. The original tuple remains untouched.

Why It Matters

So, why should you care whether an object is mutable or immutable? Understanding this difference is crucial because it affects how your code behaves, especially when it comes to memory usage and data integrity. Mutable objects can be more memory-efficient because they allow in-place modifications, which is great for large datasets. However, immutable objects are safer in some contexts because they can’t be changed unintentionally, reducing the risk of bugs.

Function Arguments

Here’s where things get really interesting: how Python handles mutable and immutable objects when they’re passed to functions. Immutable objects (like integers and strings) are passed by value, which means the function gets a copy and can’t change the original object. Mutable objects (like lists and dictionaries), however, are passed by reference, allowing the function to modify the original object:

In the first example, the modify_list function changes my_list directly. In the second, modify_int does not change my_int because integers are immutable.

Alright, fellow Pythonistas, we've reached the end of our mutable and immutable yada yada yada!

Imagine trying to bake a cake but every time you add an ingredient, it teleports to a new kitchen. That's what working with immutable objects can feel like. On the other hand, mutable objects are like that friend who shows up at your door with pizza—reliable and ready to adapt to whatever toppings you throw on. Knowing when to use each is like mastering the art of balancing your checkbook while riding a unicycle: tricky at first, but once you get it, you’re a coding acrobat.

So, the next time you’re coding away, remember: mutable objects are your flexible friends, and immutable objects are your steadfast sentinels. Use them wisely, and you’ll avoid many a headache. Now, go forth and conquer the world of Python. As for me, I'm hungry. I'm the friend who always prefers to receive the pizza. Please visit and we'll code.

Don't forget the pizza!

Happy coding!