Are dictionaries mutable in Python?

Are Dictionaries Mutable in Python?

Direct Answer: Yes, Dictionaries are Mutable in Python

In Python, dictionaries are one of the most used data structures. A dictionary, also known as a hash map, is a collection of key-value pairs. In programming, dictionaries are used to store and retrieve data, and they are an essential data structure in many applications.

What does "Mutable" Mean?

Before we dive deeper into the topic, let’s understand what "mutable" means. In programming, an object is considered mutable if its contents can be modified after it’s created. In other words, a mutable object can be changed after it’s created. On the other hand, an immutable object cannot be changed once it’s created.

Why are Dictionaries Mutable?

Dictionaries are mutable because they are implemented as hash tables. A hash table is a data structure that stores key-value pairs, where keys are unique and map to specific values. When you create a dictionary, you can add, remove, and modify key-value pairs at will. This is because dictionaries are implemented as arrays, which can be resized at runtime.

How to Make a Dictionary Mutable?

To create a mutable dictionary in Python, you simply use the {} notation:

my_dict = {'a': 1, 'b': 2, 'c': 3}

How to Make a Dictionary Immutable?

While dictionaries are mutable by default, you can also create an immutable dictionary by using the tuple() function:

my_immut_dict = tuple({'a': 1, 'b': 2, 'c': 3})

In this case, the dictionary becomes an immutable object, and any attempts to modify it will raise a TypeError.

Example: Modifying a Dictionary

Here’s an example of modifying a dictionary:

my_dict = {'a': 1, 'b': 2, 'c': 3}

my_dict['d'] = 4

print(my_dict)  # Output: {'a': 1, 'b': 2, 'c': 3, 'd': 4}



my_dict.pop('a')

print(my_dict)  # Output: {'b': 2, 'c': 3, 'd': 4}

As you can see, we can add and remove key-value pairs at will.

Example: Modifying an Immutable Dictionary

On the other hand, if we try to modify an immutable dictionary, we’ll get a TypeError:

my_immut_dict = tuple({'a': 1, 'b': 2, 'c': 3})

try:

    my_immut_dict['d'] = 4

except TypeError as e:

    print(e)  # Output: '__main__.tuple' object does not support item assignment

Why would you want to make a Dictionary Immutable?

While dictionaries are often used to store data that needs to be modified, there are cases where immutability is desirable. For example, in functional programming, immutability is a fundamental concept. It ensures that a function does not modify its arguments, which makes it easier to reason about the behavior of the code. Immutable data structures also make it easier to write concurrent code, as multiple threads can safely access the data without worrying about it changing under their feet.

Conclusion

In conclusion, dictionaries in Python are mutable by default, but can be made immutable using the tuple() function. Understanding the difference between mutable and immutable data structures is crucial in programming, as it can affect the behavior of your code and the complexity of your program. While dictionaries are often used for storing and retrieving data, immutability is an important concept to consider in certain situations.