类对象字典访问：使用 DotDict 处理嵌套数据

在 Python 中，字典是我们处理数据时最常用的数据结构之一。特别是在处理复杂的嵌套字典时，传统的访问方式显得繁琐，尤其是当字典层级较深时。为了让这个过程更简洁高效，我们可以使用 DotDict 类，它能让我们通过点符号（dot notation）访问嵌套字典中的数据，就像操作对象属性一样。

什么是 DotDict 类？

DotDict 类是一种自定义的字典类，它允许我们通过点符号访问嵌套字典中的键值对。例如，传统的字典访问方式是 dict['key']，而通过 DotDict，我们可以像访问对象的属性那样使用 dot.object.key 的形式来访问数据。

dot.person1.name
dot.person1.pets[0].name

DotDict 的主要特点

1. 点符号访问嵌套字典：我们可以像访问对象的属性一样，通过点符号来访问字典中的元素。
2. 自动递归处理嵌套结构：如果字典的值本身是另一个字典或列表，DotDict 会递归转换这些数据结构为 DotDict，并允许继续使用点符号访问。
3. 支持字典常用操作：你可以像普通字典一样对 DotDict 进行增、删、改操作。
4. 轻松转换为普通字典：可以通过 dict() 方法将 DotDict 转换为普通的 Python 字典。

如何使用 DotDict？

下面是如何使用 DotDict 类的几个示例：

1. 创建 DotDict 对象

首先，我们需要定义一个嵌套字典，然后将其传递给 DotDict 类来创建一个对象。

nested_dict = {
    'person1': {
        'name': 'Alice',
        'age': 25,
        'pets': [
            {'name': 'Dog', 'type': 'Labrador'},
            {'name': 'Cat', 'type': 'Siamese'}
        ]
    }
}

dot = DotDict(nested_dict)

2. 通过点符号访问数据

有了 DotDict 对象后，你就可以通过点符号访问其中的嵌套数据了。

print(dot.person1.name)  # 输出：Alice
print(dot.person1.pets[0].name)  # 输出：Dog

3. 修改、添加和删除数据

通过点符号，你还可以方便地修改、添加或删除数据。

dot.person1.age = 26  # 修改 age 属性
dot.person1.address = 'New York'  # 添加 address 属性
del dot.person1.address  # 删除 address 属性

4. 将 DotDict 转换为普通字典

如果你需要将 DotDict 转换为普通的字典，可以使用 dict() 方法。

dict_version = dot.dict()
print(dict_version)  # 输出普通字典形式的数据

5. 合并字典

你还可以通过 assign() 方法将另一个字典或 DotDict 合并到当前对象中。

another_dict = {'person2': 'Mary'}
another_dot = DotDict(another_dict)

dot.assign(another_dot)
print(dot)  # 输出：{'person1': {...}, 'person2': 'Mary'}

6. 遍历嵌套数据

当字典中包含列表时，遍历列表中的数据也非常简便：

for pet in dot.person1.pets:
    print(pet.name)  # 输出每个宠物的名字

总结

DotDict 是处理嵌套字典的一个非常有用的工具，它能够通过点符号简化访问嵌套数据的复杂度，并且提供了一些额外的功能，如字典的合并、转换等。

通过本文的介绍，你应该能够更好地理解和使用 DotDict 类，让你在处理嵌套字典时更加得心应手。希望这篇文章能帮助你提高工作效率，如果你有任何问题或建议，欢迎在评论区留言。

源码

class DotDict:
    def __init__(self, dictionary):
        # 将字典的内容保存为对象属性
        for key, value in dictionary.items():
            if isinstance(value, dict):
                # 如果值是字典，递归创建 DotDict 对象
                value = DotDict(value)
            elif isinstance(value, list):
                # 如果值是列表，递归处理列表中的每个元素
                value = [DotDict(item) if isinstance(item, dict) else item for item in value]
            object.__setattr__(self, key, value)

    def __getattr__(self, name):
        # 如果访问的属性不存在，则抛出 AttributeError
        raise AttributeError(f"'{self.__class__.__name__}' object has no attribute '{name}'")

    def __setattr__(self, name, value):
        # 通过点操作符修改属性或添加新属性
        if isinstance(value, dict):
            value = DotDict(value)
        elif isinstance(value, list):
            value = [DotDict(item) if isinstance(item, dict) else item for item in value]
        object.__setattr__(self, name, value)

    def __delattr__(self, name):
        # 使用 del 删除属性
        if hasattr(self, name):
            object.__delattr__(self, name)
        else:
            raise AttributeError(f"'{self.__class__.__name__}' object has no attribute '{name}'")

    def __getitem__(self, index):
        # 如果是列表，可以通过索引访问
        if isinstance(self, list):
            return self[index]
        else:
            raise TypeError("Object is not a list")

    def __setitem__(self, index, value):
        # 如果是列表，允许修改特定索引位置的元素
        if isinstance(self, list):
            self[index] = value
        else:
            raise TypeError("Object is not a list")

    def __delitem__(self, index):
        # 如果是列表，允许删除特定索引位置的元素
        if isinstance(self, list):
            del self[index]
        else:
            raise TypeError("Object is not a list")

    def dict(self):
        # 将 DotDict 转换回普通字典
        result = {}
        for key in self.__dict__:
            value = getattr(self, key)
            if isinstance(value, DotDict):
                # 如果值是 DotDict 类型，递归转换
                result[key] = value.dict()
            elif isinstance(value, list):
                # 如果值是列表，递归转换列表中的每个 DotDict
                result[key] = [item.dict() if isinstance(item, DotDict) else item for item in value]
            else:
                result[key] = value
        return result

    def __repr__(self):
        # 返回一个简洁的字符串表示 DotDict 对象
        dict_repr = self.dict()  # 获取 DotDict 对象的字典表示
        return f"DotDict({dict_repr!r})"  # 使用 !r 确保调用 repr() 方法以获取更详细的输出

    def keys(self):
        # 返回对象的所有键
        return list(self.dict().keys())

    def values(self):
        # 返回对象的所有值
        return list(self.dict().values())

    def assign(self, other):
        # 合并另一个字典或 DotDict 对象
        if isinstance(other, DotDict):
            other = other.dict()  # 转换成普通字典
        if isinstance(other, dict):
            for key, value in other.items():
                setattr(self, key, value)
        else:
            raise TypeError("Argument must be a dictionary or DotDict")

    def entries(self):
        # 返回对象的所有键值对
        return list(self.dict().items())

# 示例
nested_dict = {
    'person1': {
        'name': 'Alice',
        'age': 25,
        'pets': [
            {'name': 'Dog', 'type': 'Labrador'},
            {'name': 'Cat', 'type': 'Siamese'}
        ]
    }
}

another_dict = {'person2':'Mary'}

dot = DotDict(nested_dict)
another_dot = DotDict(another_dict)
print(dot)  # 打印 DotDict 对象

# 访问属性
pet = dot.person1.pets[0]
print(pet.name)

# 添加属性
pet.age = 26
print(pet.age)

# 修改属性
pet.age = 27
print(pet.age)

# 删除属性
del pet.type

# 转换回字典
dict_version = dot.dict()
print(dict_version)

# 可遍历
for i in dot.person1.pets:
    print(i)

# 获取所有键和值
print(dot.keys())
print(dot.values())
print(dot.entries())

# 合并
dot.assign(another_dot)
print(dot)

本作品采用《CC 协议》，转载必须注明作者和本文链接