Skip to main content
 首页 » 编程设计

python之确定数据类型/结构是否与数据的基本描述相同

2025年05月04日8lyhabc

想象一个简单的数据描述标签,用于描述在两个系统之间交换的数据类型。为了在这些系统之间保持数据完整性(它们也旨在通过创建新模块进行扩展),它们必须对它们输出的数据类型和结构进行简单描述。鉴于这些系统主要处理命令行命令和输出,数据类型不需要太复杂。

由于本系统的编写语言是Python,简单数据类型有bool、int、float、str、list、dict。列表和字典必须明确定义它们包含的数据类型(即 list(float) 用于 float 列表或 dict(str, list(str)) 用于将字符串映射到字符串列表的字典。

当一个系统从另一个系统传递数据时,它会检查传递的数据是否遵循模块对其输入的数据描述,如果符合则继续处理,否则抛出错误。下面是几个小例子:

verify("int", 1)                            -> True 
verify("int", "1")                          -> False 
verify("list(int)", [1, 2, 3])              -> True 
verify("list(int)", [])                     -> True 
verify("dict(str,int)", {"a": 1})           -> True 
verify("dict(str,int)", {"b": 1, "c": "d"}) -> False 

显然递归是解决这个问题的方法,如果我要从头开始编写它并且这不是一个太难的问题,但我想知道是否已经有用于此类功能的模块。

请您参考如下方法:

这是我目前所拥有的,之前它被更好地打包到一个“TypeLabel”对象中,但我将它压缩到一个函数中以更接近答案中测试用例指定的函数。该函数通过了上面的几个简单测试用例,但没有提供对不正确数据类型规范的错误检查。我将在今天晚些时候制作一个更强大的版本。并不是说这是批评的地方,但如果您发现任何明显的错误,请随时指出。

def verify(specification, test_data): 
    typenames = {"tuple": tuple, "dict": dict, "list": list, "str": str, "int": int, "bool": bool, "float": float} 
 
    def interpret_spec(spec): 
        def find_separators(spec): 
            seps = [] 
            depth = 0 
            for i in range(len(spec)): 
                if spec[i] == ',' and depth == 0: 
                    seps.append(i) 
                elif spec[i] == '(': 
                    depth += 1 
                elif spec[i] == ')': 
                    depth -= 1 
            return seps 
 
        def recurse_type(spec): 
            seps = find_separators(spec) 
            if len(seps) != 0: 
                sub_specs = [""] 
                for i in range(len(spec)): 
                    if i in seps: 
                        sub_specs.append("") 
                    else: 
                        sub_specs[-1] += spec[i] 
                if spec[-1] == "": 
                    spec = spec[:-1] 
                return tuple([recurse_type(sub_spec) for sub_spec in sub_specs]) 
            spec_name = spec 
            if "(" in spec: 
                spec_name = spec[:spec.find("(")] 
                sub_spec = spec[spec.find("(")+1:spec.rfind(")")] 
                return {spec_name: recurse_type(sub_spec)} 
            else: 
                return spec_name 
 
        return recurse_type(spec.replace(" ", "").strip()) 
 
    def recurse_verify(spec, data): 
        try: 
            if isinstance(spec, str): 
                return isinstance(data, typenames[spec]) 
            elif isinstance(spec, dict): 
                datatype_name = spec.keys()[0] 
                if not isinstance(data, typenames[datatype_name]): 
                    return False 
                if datatype_name == "list": 
                    for item in data: 
                        if not recurse_verify(spec[datatype_name], item): 
                            return False 
                elif datatype_name == "dict": 
                    for key in data: 
                        if not recurse_verify(spec[datatype_name][0], key) or not recurse_verify(spec[datatype_name][1], data[key]): 
                            return False 
                elif datatype_name == "tuple": 
                    if len(spec[datatype_name]) != len(data): 
                        return False 
                    for i in range(len(data)): 
                        subtype = spec[datatype_name][i] 
                        subdata = data[i] 
                        if not recurse_verify(subtype, subdata): 
                            return False 
        except TypeError: 
            return False 
        else: 
            return True 
 
    return recurse_verify(interpret_spec(specification), test_data)