Q.Write the names of the immutable data objects from the following:

The key idea is immutability, which means an object's state cannot be changed after it is created.

1. List: Lists are mutable; their elements can be modified, added, or removed after creation.
2. Tuple: Tuples are immutable; once created, their elements cannot be changed.
3. String: Strings are immutable; individual characters within a string cannot be altered. …

The concept of mutability versus immutability is fundamental in programming, especially in Python. It refers to whether an object's state can be modified after it has been created.

• Mutable objects are those whose internal state can be changed after they are created. Think of it like a whiteboard: you can write on it, erase parts, and write new things, all on the same board.
• Immutable objects are those whose internal state cannot be changed after they are created. Once an immutable object is made, it's fixed. If you want to "change" it, you actually have to create an entirely new object with the desired modifications. This is like a printed book: you can't change the text on a page; if you want different text, you need a new edition of the book.

Understanding this distinction is crucial because it affects how objects behave when passed to functions, how they are stored in memory, and whether they can be used as keys in dictionaries or elements in sets (only immutable objects can be hashed and thus used in these contexts).

Let's examine each of the given data objects:

1. List

   Lists in Python are mutable. This means you can add, remove, or change elements within a list after it has been created, without creating a new list object.

   Consider this example:

   my_list = [1, 2, 3]
   print(f"Original list: {my_list}") # Output: Original list: [1, 2, 3]
   
   # Modify an element
   my_list[0] = 10
   print(f"List after changing an element: {my_list}") # Output: List after changing an element: [10, 2, 3]
   
   # Add an element
   my_list.append(4)
   print(f"List after appending: {my_list}") # Output: List after appending: [10, 2, 3, 4]
   

   As you can see, the my_list object itself was modified in place.

2. Tuple

   Tuples in Python are immutable. Once a tuple is created, you cannot change its elements, add new elements, or remove existing ones.

   Consider this example:

   my_tuple = (1, 2, 3)
   print(f"Original tuple: {my_tuple}") # Output: Original tuple: (1, 2, 3)
   
   # Attempt to modify an element
   try:
       my_tuple[0] = 10
   except TypeError as e:
       print(f"Error when trying to modify tuple: {e}")
   # Output: Error when trying to modify tuple: 'tuple' object does not support item assignment
   

   This TypeError clearly demonstrates that tuples cannot be modified after creation. If you need a "modified" tuple, you must construct a new one.

   Watch out

   While a tuple itself is immutable, if a tuple contains mutable objects (like lists), those mutable objects within the tuple can still be modified. For example, my_tuple = ([1, 2], 3) allows my_tuple[0].append(4), making my_tuple effectively ([1, 2, 4], 3). The tuple's references to its elements don't change, but the contents of the mutable elements do.

3. String

   Strings in Python are also immutable. Just like tuples, once a string is created, its characters cannot be changed. Any operation that appears to modify a string, such as concatenation or replacing characters, actually results in the creation of a new string object.

   Consider this example:

   my_string = "hello"
   print(f"Original string: {my_string}") # Output: Original string: hello
   
   # Attempt to modify a character
   try:
       my_string[0] = 'H'
   except TypeError as e:
       print(f"Error when trying to modify string: {e}") …