Python中存储多类型数据实例的动态层级数据结构选型咨询

问题描述 #

我正在开发一款Python程序用于记录不同类型的数据，期望采用如下层级数据结构：

dataStructure
                              /                      \
                     dataType1                          dataType2
                /        |        \                /        |        \
           instance1 instance2 instance3      instance1 instance2 instance3

需求包括：

• 运行时可创建新的数据类型以及对应类型的实例
• 每个实例必须遵循包含time、type、data的统一格式
• 新增实例时自动判断是否存在对应dataType，不存在则创建新类型并插入实例

之前尝试用嵌套字典实现，但很快变得繁琐，难以追踪数据流向，不确定是否使用方式有误。

解决方案 #

嵌套字典的问题在于缺少逻辑封装，数据和操作分离，导致维护困难。推荐用面向对象封装来实现，将数据结构和操作逻辑绑定，让代码更清晰、易维护。

1. 核心类设计 #

实例类（Instance）

封装单个数据实例的属性，确保格式统一：

from datetime import datetime

class Instance:
    def __init__(self, data_type, data, time=None):
        # 自动填充当前时间（如果未传入）
        self.time = time or datetime.now()
        self.type = data_type
        self.data = data

    # 自定义打印格式，方便调试
    def __repr__(self):
        return f"Instance(time={self.time}, type={self.type}, data={self.data})"

数据类型类（DataType）

管理同类型的所有实例，负责实例的添加和存储：

class DataType:
    def __init__(self, name):
        self.name = name
        self.instances = []

    def add_instance(self, instance):
        # 校验实例类型匹配，避免错误插入
        if instance.type != self.name:
            raise ValueError(f"实例类型 '{instance.type}' 与数据类型 '{self.name}' 不匹配")
        self.instances.append(instance)

    def __repr__(self):
        return f"DataType(name={self.name}, 实例数量={len(self.instances)})"

顶层数据结构类（DataStructure）

管理所有数据类型，实现自动创建新类型的逻辑：

class DataStructure:
    def __init__(self):
        # 用字典存储数据类型，key为类型名称，value为DataType对象
        self.data_types = {}

    def add_instance(self, instance):
        type_name = instance.type
        # 检查类型是否存在，不存在则创建
        if type_name not in self.data_types:
            self.data_types[type_name] = DataType(type_name)
        # 将实例添加到对应类型中
        self.data_types[type_name].add_instance(instance)

    # 获取指定数据类型
    def get_data_type(self, type_name):
        return self.data_types.get(type_name)

    def __repr__(self):
        return f"DataStructure(已包含类型={list(self.data_types.keys())})"

2. 使用示例 #

# 初始化顶层数据结构
ds = DataStructure()

# 添加温度实例，自动创建temperature类型
temp_inst1 = Instance("temperature", {"value": 25, "unit": "℃"})
ds.add_instance(temp_inst1)

temp_inst2 = Instance("temperature", {"value": 26, "unit": "℃"})
ds.add_instance(temp_inst2)

# 添加湿度实例，自动创建humidity类型
hum_inst = Instance("humidity", {"value": 65, "unit": "%"})
ds.add_instance(hum_inst)

# 查看整体结构
print(ds)
# 输出: DataStructure(已包含类型=['temperature', 'humidity'])

# 获取温度类型的所有实例
temp_type = ds.get_data_type("temperature")
print(temp_type.instances)
# 输出: [Instance(time=2024-05-20 14:30:00, type=temperature, data={'value': 25, 'unit': '℃'}), Instance(time=2024-05-20 14:30:01, type=temperature, data={'value': 26, 'unit': '℃'})]

3. 嵌套字典的改进方案（如果不想用类） #

如果坚持用字典，可通过封装函数来统一逻辑，避免混乱：

from datetime import datetime

data_structure = {}

def add_instance(instance):
    # 强制校验实例格式
    required_keys = {"time", "type", "data"}
    if not required_keys.issubset(instance.keys()):
        raise ValueError("实例缺少必要字段：time/type/data")
    
    type_name = instance["type"]
    if type_name not in data_structure:
        data_structure[type_name] = []
    data_structure[type_name].append(instance)

# 使用示例
new_inst = {
    "time": datetime.now(),
    "type": "pressure",
    "data": {"value": 1013, "unit": "hPa"}
}
add_instance(new_inst)

方案对比 #

• 面向对象方案：逻辑清晰，数据格式有约束，易于扩展（比如添加实例查询、统计方法），调试和维护更简单。
• 嵌套字典方案：代码更轻量化，但缺少格式校验，逻辑分散，复杂场景下易出错。

内容的提问来源于stack exchange，提问作者Alan