Original Python Dictionary

Most developers are accustomed to using Python dictionaries. Here is a sample dictionary for demonstration:

my_profile = {

'name': 'Chris',

'age': 33,

'address': {

'country': 'Australia',

'state': 'Victoria'

}

}

To retrieve the value associated with "name", one would use my_profile['name']. For nested values, such as "country", you can chain square brackets as it resides inside "address".

While there isn't a significant issue here, it is worth noting that keys must be strings unless a class is defined to instantiate my_profile. This is where Munch comes in as a more flexible solution.

Using the Munch Dictionary

Munch can be easily installed via pip:

pip install munch

After installation, import the Munch class from the module:

from munch import Munch

You can then create your dictionary as follows:

my_profile = Munch({

'name': 'Chris',

'age': 33,

'address': Munch({

'country': 'Australia',

'state': 'Victoria'

})

})

The primary difference with a Munch dictionary is the ability to use dot notation to access values, enhancing both reliability and convenience due to IDE auto-completion.

If you're curious about why dot notation is more dependable than string keys, refer to my previous article.

Building Munch Dictionaries

In the previous example, we converted a standard Python dictionary to a Munch dictionary. However, it's also possible to create a Munch dictionary from scratch without first defining a standard dictionary, similar to JavaScript.

For instance, to recreate our earlier example:

my_new_profile = Munch()

This initializes an empty Munch dictionary, allowing you to add key-value pairs directly:

my_new_profile.name = 'Chris'

my_new_profile.age = 33

my_new_profile.address = Munch()

my_new_profile.address.country = 'Australia'

my_new_profile.address.state = 'Victoria'

The my_new_profile will mirror my_profile.

Munch as a Subclass of Dictionary

Munch is fundamentally a subclass of the Python dictionary. This means that my_new_profile functions as both a Munch and a standard dictionary, inheriting all features of Python dictionaries.

For instance, you can still use string keys to set or retrieve values, which is useful when keys are dynamically defined.

my_new_profile['programming_language'] = 'Python'

my_new_profile['programming_language']

All standard dictionary functions remain applicable, including retrieving keys.

my_new_profile.keys()

Serialization is another vital feature of Python dictionaries. With Munch, this feature is preserved, allowing conversions between dictionaries and JSON strings without loss of functionality.

import json

profile_json = json.dumps(my_new_profile)

print(profile_json)

Default Values

One of the exciting features of Munch is its handling of default values. In traditional Python dictionaries, key errors can be problematic. It's advisable to use the get() method to avoid this, allowing you to set default values.

my_profile.get('programming_language', 'undefined')

While effective, this method requires passing the default each time. With Munch, you can set a default value just once:

from munch import DefaultMunch

my_profile = DefaultMunch('undefined', {

'name': 'Chris',

'age': 33

})

This setup defines a default value for any non-existent keys.

Adding Keys Upon Query

Another convenient feature of Munch is the Default Factory class. When querying a key, if it doesn't exist, it will be automatically added to the Munch dictionary.

Define a Munch dictionary using the DefaultFactoryMunch class:

from munch import DefaultFactoryMunch

my_profile = DefaultFactoryMunch(list, {

'name': 'Chris',

'age': 33

})

This ensures that if you try to access a key that doesn’t exist, it will be created.

For example, if you want to ensure a key has a value, you can do the following:

if not my_profile.languages:

my_profile.languages.append('Python')

print(my_profile.languages)

This guarantees that the profile will include Python.

Summary

In summary, this article explored the Munch library, which enhances the standard Python dictionary by maintaining all original features while introducing dot notation for easier access. Additionally, it simplifies managing default values for non-existent keys, making it a powerful tool for developers.