Immutable Vs Mutable: In Pyhton Everything Is an Object

Python is an interpreted, high-level, general-purpose programming language created by Guido van Rossum and first released in 1991. Python's design philosophy emphasizes code readability with its notable use of significant whitespace. Its language constructs and object-oriented approach aim to help programmers write clear, logical code for small and large-scale projects, following the Phyton zen:

>>> import this


The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

Python is dynamically typed and garbage-collected. It supports multiple programming paradigms, including structured (particularly, procedural), object-oriented, functional, and modular programming.

Python 2.0, released in 2000, introduced features like list comprehensions and a garbage collection system capable of collecting reference cycles. Python 3.0, released in 2008, was a major revision of the language that is not completely backward-compatible, and much Python 2 code does not run unmodified on Python 3. That is the reason for Python 2 language was officially discontinued in February 2020 where Python 2.7.18 is the last Python 2.7 release and therefore the last Python 2 release, only Python 3.5.x and later are supported now.

Python interpreters are available for many operating systems. A global community of programmers develops and maintains CPython, an open-source reference implementation. A non-profit organization, the Python Software Foundation, manages and directs resources for Python and CPython development. There are a lot of Python IDE for the easiest work in this language like Spyder, Jupyter, Pycharm, Visual Code, etc..

In Python, everything is an object, and that's the reason that different types of data structures and variables may be a specific characteristic in this language: Mutable or Immutable.

Difference between mutable and immutable objects:

Mutable objects may change value; immutable objects may not. Some immutable objects at times may look like they are changing their values. But they are not actually changing their values though. The distinction is visible using the id function.  Integers, containers, objects, and strings, things like these may appear to be changing values when they are not.

For example, we'll define a variable x as integer and assigned it the value 35.

>>> x = 35  # Assigne the value 35 to a variable x
>>> x
35

>>> type(x)  # Now, see what is the type of the variable x
<class 'int'>

>>> id(x)  # And ask for its memory address
20397856321

>>> x = 46  #Change the value stored in variable x to 46
>>> x
46

>>> id(x)  # And ask for its memory address agian
20397802359

>>> x = 35  # Assigne the value 35 to a variable x again
>>> id(x)  # And ask for its memory address
20397856321

>>> x
35

Notice when you ask for memory address using id() function for a variable x with stored value 35, Python shows the address 20397856321, but if you change the x value to 46, the id(x) returns a different address 20397802359. Moreover, when you reassign the value 35 to x, id() returns the previous address. What happened here?. The reason for that is variables in Python are references to objects, and x is an integer type, and integer type is immutable. X is an object point to object value 35, thus when the value is actualized to another, Python created another object with this value and x points to this object right now.

I show you to important functions to understand the difference between Mutable and immutable objects in Python.

* type(<variable>): to show Who is <variable>?

* id(<variable>): to know Where <variable> is stored?

What is a hash?

According to Python , “An object is hashable if it has a hash value which never changes during its lifetime”, if and only if the object is immutable.

According to the definition Mutable objects are objects that can be changed, for example lists, sets, and dictionaries. But the most common type of variables in python n are Inmutables like int, float, decimal, complex, bool, string, tuple, range, frozenset, and bytes.

Mutable / Immutable Advantages, and Disadvantages

There are many use-cases for immutability as well. Here are some straightforward ones:

Mutable objects are great for efficiently passing around data. Let’s define two objects list_1 and list_2 have access to the same list ["hello", "world"]. But you add the word “Python” to the list_1, automatically list_2 has access to this information.

# MUTABLE OBJECT IN PYTHON


>>> list_1 = ["hello", "world"]

>>> list_2 = list_1

>>> list_1
Out[1]: ['hello', 'world']

>>> list_2
Out[2]: ['hello', 'world']

>>> list_1.append("Python")

>>> list_2

Out[3]: ['hello', 'world', 'Python']

If you use a tuple, you would have to copy the entries of tuple_1, add the new element, create a new tuple, then send that to tuple_2. Even if both can talk directly, that is a lot of work.

# IMMUTABLE OBJECT IN PYTHON


>>> tuple_1 = ("hello", "world")

>>> tuple_2 = tuple_1

# Both tuples have the same information

>>> tuple_1

Out[1]: ('hello', 'world')

>>> tuple_2

Out[2]: ('hello', 'world')


# Add "Python" to tuple_1

>>> tuple_1 = ("hello", "world") + ("Python",) 


# tuple_1 was updated, but tuple_2 not

>>> tuple_1

Out[3]: ('hello', 'world', 'Python')

>>> tuple_2


Out[4]: ('hello', 'world')

Mutable objects are great for working with the data. So list_2 does not have to double-check for changes because list_2 is updated immediately.

Why Does it Matter?

It’s important to consider mutability when choosing data structures for a program. For example, if you have a data collection with hundred of values that you want to keep safe, it’s probably best to store them in an immutable object like tuple rather than a list that allows assignments to change, add, or delete values in this data collection.

How Python Objects Get Passed

The biggest problem occurs when you assign multiple labels to the same mutable object:

>>> x = [1, 2, 3, 4]
>>> y = x
>>> y is x
True   


>>> y.extend([5, 6, 7, 8, 9])
>>> x
[1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> y
[1, 2, 3, 4, 5, 6, 7, 8, 9]

# y and x points to te same list. If you modify the object, both labels
# appear modified.

Functions or methods of the object’s type class can be changes them, because it was designed to be able to modify the values of the object that’s passed to it.

They are able to make these changes because they are being passed a reference of the object. In CPython, that is the same as the memory address of the object. This is known as “call by sharing” — because the argument’s objects are shared between the calling and caller functions.

Immutable objects are also passed around by reference to them.

>>> def increment(n):
...     n += 1
...     return n
...

>>> a = 5
>>> id(a)

987534567448

>>> increment(a)
10

>>> a
5

By nature, immutable objects (i.e. integers) cannot be changed, so a function can not change them.

Conclusion

Be careful when using data structures and variables in Python. You need to clarify what type of variables are mutable or immutables, what do you need to do with this data, and how Python uses these objects in order to obtain the correct output in your code, being aside possible positive-false outputs.