玩转python：通俗易懂掌握高级数据结构-collections模块之UserDict

引言

UserDict是Python中collections模块提供的一个强大工具，它是dict的封装类，允许用户自定义字典的行为。通过继承UserDict，开发者可以轻松扩展字典的功能，实现自定义的字典逻辑。本文将详细介绍UserDict的关键用法和特性，并通过10个丰富的案例帮助读者掌握其应用。

关键用法和特性表格

1. UserDict的概念

UserDict是collections模块中的一个类，它是dict的封装类。它的主要特点是：

• 自定义字典行为：通过继承UserDict，可以自定义字典的行为。
• 封装原始字典：UserDict内部封装了一个字典对象，可以通过data属性访问。
• 高效性能：与普通字典相比，UserDict在自定义功能的同时性能依然高效。

2. UserDict的用法

2.1 创建UserDict

from collections import UserDict

# 创建一个空的UserDict
ud = UserDict()
print(ud)  # 输出: {}

# 从字典创建UserDict
ud = UserDict({'a': 1, 'b': 2})
print(ud)  # 输出: {'a': 1, 'b': 2}

2.2 访问键值对

# 访问键值对
print(ud['a'])  # 输出: 1
print(ud['b'])  # 输出: 2

2.3 修改键值对

# 修改键值对
ud['a'] = 10
print(ud)  # 输出: {'a': 10, 'b': 2}

3. UserDict的常见方法

3.1 data：访问内部字典

# 访问内部字典
print(ud.data)  # 输出: {'a': 10, 'b': 2}

3.2 自定义字典行为

# 自定义字典行为
class MyDict(UserDict):
    def __setitem__(self, key, value):
        if not isinstance(key, str):
            raise TypeError("Key must be a string")
        super().__setitem__(key, value)

md = MyDict({'a': 1, 'b': 2})
md['c'] = 3  # 正常
md[1] = 'a'  # 报错: TypeError

4. UserDict的10个应用案例

案例1：验证键类型

场景：自定义一个字典，确保所有键都是字符串。

class StrKeyDict(UserDict):
    def __setitem__(self, key, value):
        if not isinstance(key, str):
            raise TypeError("Key must be a string")
        super().__setitem__(key, value)

# 使用StrKeyDict
skd = StrKeyDict({'a': 1, 'b': 2})
skd['c'] = 3  # 正常
skd[1] = 'a'  # 报错: TypeError

案例2：记录操作日志

场景：自定义一个字典，记录所有添加和删除操作。

class LoggingDict(UserDict):
    def __setitem__(self, key, value):
        print(f"添加键值对: {key} -> {value}")
        super().__setitem__(key, value)

    def __delitem__(self, key):
        print(f"删除键: {key}")
        super().__delitem__(key)

# 使用LoggingDict
ld = LoggingDict({'a': 1, 'b': 2})
ld['c'] = 3  # 输出: 添加键值对: c -> 3
del ld['a']  # 输出: 删除键: a

案例3：限制字典大小

场景：自定义一个字典，限制其最大大小。

class LimitedDict(UserDict):
    def __init__(self, maxsize, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.maxsize = maxsize

    def __setitem__(self, key, value):
        if len(self) >= self.maxsize:
            self.popitem()
        super().__setitem__(key, value)

# 使用LimitedDict
ld = LimitedDict(2, {'a': 1, 'b': 2})
ld['c'] = 3  # 字典变为 {'b': 2, 'c': 3}

案例4：实现默认值字典

场景：自定义一个字典，访问不存在的键时返回默认值。

class DefaultValueDict(UserDict):
    def __init__(self, default_value, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.default_value = default_value

    def __missing__(self, key):
        return self.default_value

# 使用DefaultValueDict
dvd = DefaultValueDict(0, {'a': 1, 'b': 2})
print(dvd['a'])  # 输出: 1
print(dvd['c'])  # 输出: 0（默认值）

案例5：实现大小写不敏感字典

场景：自定义一个字典，键的大小写不敏感。

class CaseInsensitiveDict(UserDict):
    def __setitem__(self, key, value):
        super().__setitem__(key.lower(), value)

    def __getitem__(self, key):
        return super().__getitem__(key.lower())

# 使用CaseInsensitiveDict
cid = CaseInsensitiveDict({'a': 1, 'B': 2})
print(cid['A'])  # 输出: 1
print(cid['b'])  # 输出: 2

案例6：实现只读字典

场景：自定义一个字典，禁止修改和删除操作。

class ReadOnlyDict(UserDict):
    def __setitem__(self, key, value):
        raise TypeError("字典是只读的，不能修改")

    def __delitem__(self, key):
        raise TypeError("字典是只读的，不能删除")

# 使用ReadOnlyDict
rod = ReadOnlyDict({'a': 1, 'b': 2})
print(rod['a'])  # 输出: 1
rod['c'] = 3  # 报错: TypeError

案例7：实现计数器字典

场景：自定义一个字典，统计每个键的访问次数。

class CountingDict(UserDict):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.count = {}

    def __getitem__(self, key):
        self.count[key] = self.count.get(key, 0) + 1
        return super().__getitem__(key)

# 使用CountingDict
cd = CountingDict({'a': 1, 'b': 2})
print(cd['a'])  # 输出: 1
print(cd['a'])  # 输出: 1
print(cd.count)  # 输出: {'a': 2}

案例8：实现缓存字典

场景：自定义一个字典，缓存计算结果。

class CachingDict(UserDict):
    def __init__(self, func, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.func = func

    def __getitem__(self, key):
        if key not in self:
            self[key] = self.func(key)
        return super().__getitem__(key)

# 使用CachingDict
def expensive_computation(key):
    return key.upper()

cd = CachingDict(expensive_computation)
print(cd['a'])  # 输出: A
print(cd['a'])  # 输出: A（从缓存中获取）

案例9：实现优先级字典

场景：自定义一个字典，按优先级插入键值对。

class PriorityDict(UserDict):
    def insert_priority(self, key, value, priority):
        for k, (p, _) in self.items():
            if priority > p:
                self[key] = (priority, value)
                return
        self[key] = (priority, value)

# 使用PriorityDict
pd = PriorityDict()
pd.insert_priority('task1', 'low', 1)
pd.insert_priority('task2', 'high', 3)
pd.insert_priority('task3', 'medium', 2)
print(pd)  # 输出: {'task2': (3, 'high'), 'task3': (2, 'medium'), 'task1': (1, 'low')}

案例10：实现去重字典

场景：自定义一个字典，确保值不重复。

class UniqueValueDict(UserDict):
    def __setitem__(self, key, value):
        if value in self.values():
            raise ValueError("值已存在")
        super().__setitem__(key, value)

# 使用UniqueValueDict
uvd = UniqueValueDict({'a': 1, 'b': 2})
uvd['c'] = 3  # 正常
uvd['d'] = 2  # 报错: ValueError

总结

UserDict是Python中一个非常实用的工具，能够帮助开发者轻松扩展字典的功能。通过本文的详细讲解和10个实际案例，大家可以快速掌握UserDict的使用方法，并在实际项目中灵活应用。无论是验证键类型、记录操作日志，还是实现缓存和去重字典，UserDict都能轻松应对！