Python is an object-oriented programming language, and in Python everything is an object. Almost every object has some metadata (called attributes) and associated functionality (called methods). Even these attributes and methods of objects are themselves objects with their own type information.
Every object can be assigned to a variable or passed as an argument to a function.
Understand ID and Type Function
The integrated id() method contains an object’s id as just an integer. That integer normally refers to the storage position of the object. The ‘is’ operator relates the identities of two objects to each other. The integrated function, type(), returns the kind of an object. Compare two variables ‘x’ and ‘y’, having the same value, using equality operator ‘x == y’, it will output True. Using the id() function, we have compared the memory addresses of both variables, it will output False because both variables are different and located at different memory locations, although the values they contain are the same.
Mutable vs. Immutable
Mutable entities can alter their state or substance to describe the disparity, and immutable entities can’t alter their state or substance. So when an object is created, a special object ID is allocated. At runtime, the kind of object is specified and it cannot be updated later. Built-in forms such as int, float, bool, str, tuple, and Unicode variables are immutable. Objects such as list, set, byte arrays, and dictionary of built-in categories are mutable.
Make another variable ‘z’ which points to the identical entity that ‘x’ is directing to, using assignment operator ‘=’. Using the ‘is’ operator we have found that they both, point to the same object and have the same memory addresses.
Immutable Variable Types
Let’s have a look at some immutable variable types.
Let’s define a variable ‘x’ having a value ‘10’. A built-in id() method is used to find out the location of ‘x’ in memory and type() is used to identify its type. When we try to change the value of ‘x’, it is successfully changed, although the memory address returns differently. It is because we haven’t actually changed the value of ‘x’, but we have created another object with the same name ‘x’ and assign it a different value. We have bonded the name ‘x’ to the new value. Now, whenever you call ‘x’ it will output the new value.
Same for the string data type, we cannot modify the existing variable but we have to create a new one with the same name. Here we have defined a string variable ‘x’ and want to add ‘w’ to its zero indexes. It will output TypeError, showing that the string object doesn’t support update.
Have a glimpse of a tuple type variable, we have defined a tuple with 4 values. We have used the id() function to output its address. When we want to change its value at 0 indexes, it gives the TypeError that tuple doesn’t support item assignment or update.
On the contrary, you can update the entire tuple by defining it from scratch. Now, whenever you check it, you will find a new value and a new address.
We have a float type variable ‘x’. Using the id() function, we have to find out its address. When we want to change its value at index 1, it gives the TypeError that float doesn’t support item modification.
Conversely, we have updated the float by defining it again. Now, whenever we call it, we will find a new value and a new address.
Mutable Variable Types
Now we will be looking at some mutable variable types.
We have defined a list named ‘x’ and add some values to it. While run, it will display list values. When you update the list by assigning new values to index 0 and 2, it will successfully do that.
The above described example is a simple and basic example of modification. To check mutability to a different level, let’s take a look at the same example with little change. We have created a new name ‘y’ and bound it to the same list object. When we checked if the ‘x’ is the same as ‘y’, it returns True. On the other hand, both ‘x’ and ‘y’ have the same memory addresses.
Now append a new value to a list name ‘x’ and check the updated output.
Now, when you check for list name ‘y’, it will display the same list as it displays for ‘x’. That means, when we update the same object list, which has two different names ‘x’ and ‘y’. Both are the same and share the same memory addresses even after the modification.
As dictionaries are commonly used variables in Python, let’s have a look at the mutability of dictionaries. We have defined a dictionary named ‘dict’ with three keys and their values. When we print it out, it will display all contents of it. You can print each dictionary value separately, as well as using their keys instead of indexes.
We want to change the particular value by updating the key ‘Name’. It will output the updated dictionary. Dictionary keys are immutable.
Let’s define a list and tuple separately. Make sure that tuple must have a list type value in it and a list have a tuple type value in it consequently.
A tuple has a list on its 0 indexes so when you change at the 0 indexes of a tuple, you have to mention the index of a list where you want to change. Change occurs because the list is immutable.
On the contrary, the list variable can’t be updated because it has a tuple on 0 index, which is mutable.
We have seen variations in Python between mutable and immutable. You have to make your mind clear that everything in Python is referred to as an object. Primarily, the distinction among objects that are mutable vs. immutable.
I hope you have enjoyed reading the content))