How to Use UserDict in Python: Simple Guide with Examples

In Python, UserDict is a class from the collections module that lets you create your own dictionary-like objects by extending it. You use it by importing UserDict, subclassing it, and then customizing its behavior while still having dictionary features.

Syntax

The basic syntax to use UserDict is to import it from the collections module and create a subclass. You can then override or add methods to customize how your dictionary works.

• Import: from collections import UserDict
• Subclass: Create a class that inherits from UserDict
• Customize: Override methods like __setitem__, __getitem__, or add new ones

python

from collections import UserDict

class MyDict(UserDict):
    def __init__(self, initial_data=None):
        super().__init__(initial_data or {})

    def __setitem__(self, key, value):
        # Custom behavior here
        super().__setitem__(key, value)

Example

This example shows how to create a custom dictionary that stores all keys as uppercase strings. It demonstrates subclassing UserDict and overriding the __setitem__ method.

python

from collections import UserDict

class UpperCaseDict(UserDict):
    def __setitem__(self, key, value):
        # Convert key to uppercase before setting
        super().__setitem__(key.upper(), value)

# Create instance
my_dict = UpperCaseDict()
my_dict['apple'] = 10
my_dict['Banana'] = 20

print(my_dict)  # Output the dictionary
print(my_dict['APPLE'])  # Access with uppercase key

Output

{'APPLE': 10, 'BANANA': 20}
10

Common Pitfalls

One common mistake is forgetting to call super().__setitem__ when overriding methods, which can break dictionary behavior. Another is not initializing the base UserDict properly, causing errors or missing data.

Also, remember that UserDict stores data in an internal dictionary called self.data, so direct manipulation of self.data can bypass your custom logic.

python

from collections import UserDict

# Wrong way: missing super call
class BadDict(UserDict):
    def __setitem__(self, key, value):
        print(f"Setting {key} to {value}")
        # Missing super().__setitem__ call

bad = BadDict()
bad['key'] = 'value'  # This won't actually store the item
print(bad)  # Outputs empty dictionary

# Right way
class GoodDict(UserDict):
    def __setitem__(self, key, value):
        print(f"Setting {key} to {value}")
        super().__setitem__(key, value)

good = GoodDict()
good['key'] = 'value'
print(good)  # Outputs {'key': 'value'}

Output

Setting key to value
{}
Setting key to value
{'key': 'value'}

Quick Reference

UserDict Cheat Sheet:

Feature	Description
Import	from collections import UserDict
Subclass	class MyDict(UserDict): ...
Initialize	Use super().__init__(initial_data or {})
Override __setitem__	Customize how items are set
Access data	Use self.data dictionary internally
Use like dict	Supports all normal dict methods

Key Takeaways

UserDict lets you create custom dictionary-like classes by subclassing it.

Always call super() methods when overriding to keep dictionary behavior intact.

UserDict stores data in self.data, so use it carefully to avoid bypassing custom logic.

You can customize key handling, value setting, or add new methods easily.

UserDict is useful when you want a dict with extra features or validation.