How Can I Create a Custom Dictionary in Python with Transformed Keys?

Creating a "Perfect" Dict

In Python, creating a custom class that behaves identically to a dictionary can be a complex task. Here's how to achieve it with Abstract Base Classes (ABCs).

Implementing the MutableMapping ABC

The collections.abc module provides ABCs for various data structures, including MutableMapping. By implementing MutableMapping, we can create an object with the same interface as a dict. Here's a minimalist implementation:

from collections.abc import MutableMapping

class TransformedDict(MutableMapping):

    def __init__(self, *args, **kwargs):
        self.store = dict()
        self.update(dict(*args, **kwargs))

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

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

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

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

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

    def _keytransform(self, key):
        return key

Customizing Key Transformation

By overriding the _keytransform method, we can apply arbitrary transformations to keys. For instance, to force lowercase keys:

class MyTransformedDict(TransformedDict):

    def _keytransform(self, key):
        return key.lower()

Benefits of ABCs

Implementing ABCs offers several advantages:

• Ensures compliance with the dict interface.
• Provides essential methods like __contains__, get(), and setdefault() for free.
• Simplifies pickling and unpickling.

In summary, implementing MutableMapping and overriding _keytransform provides a concise and effective way to create a custom dict with tailored key handling while maintaining the functionality of a standard dict.

The above is the detailed content of How Can I Create a Custom Dictionary in Python with Transformed Keys?. For more information, please follow other related articles on the PHP Chinese website!