Question 12 - Sample Paper 2 by Teachoo - Teachoo Sample Paper

Which of the following statements is TRUE about mutable and immutable data types in Python? 

a)Mutable data types can be modified in place, while immutable data types create a new object when modified. 

b)Mutable data types are faster and more efficient than immutable data types. 

c)Mutable data types are always passed by reference, while immutable data types are always passed by value. 

d)Mutable data types have a fixed size and memory allocation, while immutable data types have a variable size and memory allocation.

Answer:

Answer by student

a)Mutable data types can be modified in place, while immutable data types create a new object when modified.

Detailed answer by teachoo

• In Python, data types can be classified into two categories: mutable and immutable.
• Mutable data types are those that can be changed after they are created, while immutable data types are those that cannot be changed after they are created.
• Examples of mutable data types are lists, dictionaries and sets, while examples of immutable data types are strings, numbers and tuples.

Let’s look at the options and see why they are correct or incorrect:

-lock-

• Option a is correct because it describes the main difference between mutable and immutable data types. When we modify a mutable data type, we change the original object without creating a new one. For example, if we have a list l = [1, 2, 3] and we append 4 to it, we get l = [1, 2, 3, 4] without creating a new list. However, when we modify an immutable data type, we create a new object with the modified value and assign it to the same variable. For example, if we have a string s = "hello" and we concatenate “world” to it, we get s = "helloworld" but this is a new string object, not the original one.
• Option b is incorrect because it is not true that mutable data types are faster and more efficient than immutable data types. In fact, the opposite is often true. Immutable data types are faster and more efficient because they do not require extra memory allocation or copying when modified. They also have some advantages such as being hashable (can be used as keys in dictionaries) and thread-safe (can be shared by multiple threads without causing errors).
• Option c is incorrect because it is not true that mutable data types are always passed by reference, while immutable data types are always passed by value. In Python, all arguments are passed by object reference, which means that the function receives a reference to the same object that was passed as an argument. However, this does not mean that the function can modify the original object. If the object is mutable, the function can modify it in place and affect the caller’s object. If the object is immutable, the function cannot modify it in place and will create a new object if it tries to do so. This will not affect the caller’s object.
• Option d is incorrect because it is not true that mutable data types have a fixed size and memory allocation, while immutable data types have a variable size and memory allocation. In fact, the opposite is often true. Mutable data types have a variable size and memory allocation because they can grow or shrink depending on the operations performed on them. For example, a list can have more or less elements depending on how many items are added or removed from it. Immutable data types have a fixed size and memory allocation because they cannot change after they are created. For example, a string has a fixed number of characters and bytes depending on its value.

So, the correct answer is a. Mutable data types can be modified in place, while immutable data types create a new object when modified.

-endlock-