How to make immutable dictionaries in Python #PyTip01

Python is known for its batteries included capability, it has solutions for every data structure requirements. Dictionaries in Python are very useful when storing a record as Key/Value pairs.
Although dictionaries are awesome, they are mutable that means their values can be changed after their intialization.

In this short post you will learn how you can use MappingProxyType to make your dictionaries immutable.

Problem

Below is the example of how you would use dictionaries in Python.

>>> person = {“id” : 735616, “first_name”: “John”, “last_name”:”Doe”}
>>> person[“id”]
735616
>>> person[“first_name”] + ‘ ‘ + person[“last_name”]
‘John Doe’
>>> person[“id”] = 000000
>>> person[“id”]
0

In the above code we can see that our `person` record was changed and we have no way to block this change. This is where `MappingProxyType` comes in.

Solution

`MappingProxyType` is a read-only wrapper that provides a proxy to the underlying data structure. `MappingProxyType` do not support item assignment which makes our data immutable.

>>> from types import MappingProxyType
>>> im_person = MappingProxyType({“id”:736533, “first_name”:”John”, “last_name”:”Doe”})
>>> im_person[“id”]
736533
>>> im_person[“id”] = 87
Traceback (most recent call last):
 File “<stdin>”, line 1, in <module>
TypeError: ‘mappingproxy’ object does not support item assignment

In the above example you can see that when we attempted to change the value of `id`, `MappingProxyType` immediately throws `TypeError`, thus making our dictionary immutable. Please note that `MappingProxyType` accepts any data type not just dictionaries. You can also use `str` and `list`.

Caveat

Before using `MappingProxyType`, you must know that it only provides a Proxy to the underlying data structure which means if the underlying data is changed then `MappingProxyType` will reflect those changes.

>>> im_person = MappingProxyType(person)
>>> im_person
mappingproxy({‘id’: 0, ‘first_name’: ‘John’, ‘last_name’: ‘Doe’})
>>> person
{‘id’: 0, ‘first_name’: ‘John’, ‘last_name’: ‘Doe’}
>>> person[“id”] = 00
>>> im_person
mappingproxy({‘id’: 0, ‘first_name’: ‘John’, ‘last_name’: ‘Doe’})
>>>

As you can see in the above code that the `MappingProxyType` changed when the underlying data dictionary was changed.

Conclusion

In this short article you learned about `types.MappingProxyType`,
they are useful when you want to make sure that your Key/Value pairs remains immutable. Hope you liked it.