Creating a Case Insensitive Dictionary in Python 3.7 and Beyond

Learn how to implement a case insensitive dictionary in Python 3.7 using a custom class with simple methods for easy data handling.
---

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: Case insensitive dicts in python 3.7?

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Case Insensitive Dictionaries in Python 3.7 and Beyond

When working with dictionaries in Python, you might find it necessary to treat keys as case insensitive. This means that looking up a key such as dict['value'] would yield the same result as dict['VALUE']. Unfortunately, native Python dictionaries do not support this behavior by default. In this guide, we'll explore how you can create your own case insensitive dictionary class to solve this problem.

The Problem

If you've ever encountered a situation where you needed to access dictionary items without regard to the case of the keys, you know how tedious it can be to rewrite code or keep track of key cases. Python's built-in dictionaries are case sensitive, making it impossible to retrieve values without worrying about the capitalization of your keys.

The question many Python developers grappled with is whether there has been any version of Python that supports case insensitive dictionaries natively. As of now, the answer is no. However, you can create your own case insensitive dictionary that mimics this functionality!

Solution: Creating a Custom Class

Introducing UncasedDict

To create a case insensitive dictionary, we can define a new class called UncasedDict that inherits from Python's built-in dict. This class will override the methods for getting and setting items, so they automatically normalize the keys to lowercase.

Implementation

Here's how you can implement the UncasedDict class in Python:

[[See Video to Reveal this Text or Code Snippet]]

How It Works

Overriding Methods: The __getitem__ and __setitem__ methods are overridden to convert keys to lowercase. This ensures that regardless of how the key is provided ('hello', 'HELLO', or 'HeLlo'), they all point to the same entry in the dictionary.

Using Super: The super() function is called to access the original dictionary's methods, allowing us to maintain their functionality while adding our custom logic.

Additional Functionality

While overriding the get and set item methods is a great start, you may want to extend the functionality of UncasedDict by overriding more dictionary methods, such as:

__delitem__() to allow case insensitive removal of items.

__contains__() to check for existence of items without case sensitivity.

Conclusion

While case insensitive dictionaries are not built into Python by default, creating your own class UncasedDict can provide a seamless workaround for this limitation. With the implemented functionality, you can more easily manage keys within your dictionaries without worrying about capitalization.
By using UncasedDict, you can streamline your code and enhance readability, making it easier to manage data in a case insensitive manner.

Feel free to experiment with this implementation and build upon it further by adding more functionality as needed!