Allow mutable values in custom dictionary to be mutated on the fly in python

Python provides a built-in dictionary data structure that allows us to store key-value pairs. However, by default, the values in a dictionary are immutable. This means that once a value is assigned to a key, it cannot be changed. But what if we want to allow mutable values in our custom dictionary to be mutated on the fly? In this article, we will explore three different ways to solve this problem.

Option 1: Using a List as the Value

One way to allow mutable values in our custom dictionary is to use a list as the value. Lists in Python are mutable, which means we can modify their elements. Here’s how we can implement this:

custom_dict = {
    'key1': [],
    'key2': []


print(custom_dict)  # Output: {'key1': [1, 2], 'key2': [3]}

In this example, we initialize the custom dictionary with empty lists as values. We can then append elements to these lists using the append() method. This allows us to mutate the values on the fly.

Option 2: Using a Mutable Object as the Value

Another option is to use a mutable object, such as a custom class, as the value in our custom dictionary. Here’s an example:

class MutableValue:
    def __init__(self):
        self.value = 0

custom_dict = {
    'key1': MutableValue(),
    'key2': MutableValue()

custom_dict['key1'].value = 1
custom_dict['key2'].value = 2

print(custom_dict)  # Output: {'key1': <__main__.MutableValue object at 0x7f9e3e7e7a90>, 'key2': <__main__.MutableValue object at 0x7f9e3e7e7b50>}

In this example, we define a custom class called MutableValue with a mutable attribute called value. We then initialize the custom dictionary with instances of this class as values. We can access and modify the value attribute of each instance to mutate the values on the fly.

Option 3: Using the MutableMapping Abstract Base Class

The third option is to use the MutableMapping abstract base class from the module. This class provides a blueprint for creating custom mutable mapping types. Here’s an example:

from import MutableMapping

class CustomDict(MutableMapping):
    def __init__(self):
        self._data = {}

    def __getitem__(self, key):
        return self._data[key]

    def __setitem__(self, key, value):
        self._data[key] = value

    def __delitem__(self, key):
        del self._data[key]

    def __iter__(self):
        return iter(self._data)

    def __len__(self):
        return len(self._data)

custom_dict = CustomDict()

custom_dict['key1'] = 1
custom_dict['key2'] = 2

print(custom_dict)  # Output: {'key1': 1, 'key2': 2}

In this example, we create a custom class called CustomDict that inherits from MutableMapping. We implement the required methods for a mutable mapping type, such as __getitem__, __setitem__, __delitem__, __iter__, and __len__. This allows us to use our custom class as a dictionary with mutable values.

After exploring these three options, it is clear that using a list as the value in our custom dictionary is the simplest and most straightforward solution. It requires less code and provides a convenient way to mutate the values on the fly. Therefore, option 1 is the better choice for allowing mutable values in a custom dictionary in Python.

Rate this post

8 Responses

  1. Option 1 sounds risky, but Option 3 using the MutableMapping ABC seems versatile. Thoughts? #PythonProgramming

    1. I totally disagree. Option 2 might have some bugs, but it also has the potential to push boundaries and create groundbreaking solutions. Playing it safe with option 1 is fine, but sometimes taking risks is what leads to real innovation.

Leave a Reply

Your email address will not be published. Required fields are marked *

Table of Contents