请教一个问题，如何遍历并增减多重嵌套字典中的数据？

同级别下，type_class 中定义了 A、B、C 等变量当前有效数据位于哪一个集合中，如果A的值为1，则同一层级中cache_one中的A的键值就是A的有效数据，如果值为2，则有效数据是放置在cache_two中，但如果值为0，则这个名称的数据会返回为空，不管它是不是在cache_one和cache_two中有数据

用 JSON 的某一个块来举例：

...
"type_class": {
	"A": 1,
	"B": 2,
	"C": 0,
	...
	"E": 2,
	"F": 3
},
"cache_one": {
	"A": 55,
	"B": 12,
	"C": 27,
	...
	"E":14,
	"F": 3
},
"cache_two": {
	"A": 32,
	"B": 99,
	"C": 2
	...
	"E": 0
}，
"cache_three": {
	"A": 51
	"B": 6,
	...
	"F": 127
}
...

如果我要返回A的值，那么就应该是取cache_one中的A的值，也就是55

返回B的值，取cache_two中的B值，99

返回C的值，为空

返回F的值，取cache_three中的F值，127

这套数据的存储大概就是这么个形式。

现在需要对这些数据进行清理，使得最终的输出变为（如果返回的键值为0，一样需要清理，比如上面的E，定义在cache_two中，键值为0，则最终的输出会把它剔除）：

	...
	"type_class": {
		"A": 1,
		"B": 1,
		"F": 1
	},
	"cache_one": {
		"A": 55
		"B": 99,
		"F":127
	},
	"cache_two": {
	}，
	"cache_three": {
	}
	...

我本以为跑几次循环就能够解决问题了，结果没想到这个 JSON 文件还有多层嵌套，它的形式差不多如下：

（下面出现X和Y仅供示意，代表乱七八糟的各种内容，这些内容需要保留）

{
    "type_class": {
        "A": 1,
        "B": 2,
        "C": 0,
        ...
        "F": 3
    },
    "type_one": {
        "A": 55,
        "B": 12,
        "C": 27,
        "F": 3
    },
    "type_two": {
        "A": 32,
        "B": 99,
        "C": 2
    }，
    "type_three": {
        "A": 51
        "B": 6,
        "F": 127
    },
    "XXXXXX": {
        "XXXX": "XXXXXXX",
        "YYY": "YYYYY"
    },
    "YYYY": "YYYYY",
	"XXXX": "XXXXXXX",
    "history_items": [{
            "type_class": {
                "A": 1,
                "F": 0
            },
            "type_one": {
                "A": 55
            },
            "type_two": {
                "A": 32,
            }
            "XXXXXX": {
                "YYY": "YYYYY"
            }
        }, {
            "type_class": {
                "F": 3
            },
            "type_three": {
                "A": 51
                "B": 6,
                "F": 127
            },
            "XXXXXX": {
                "XXXX": "XXXXXXX",
                "YYY": "YYYYY"
            },
            "YYYY": "YYYYY",
            "history_items": [{
                    "type_class": {
                        "A": 1,
                        "B": 2,
                        "C": 0,
                        ...
                        "F": 0
                    },
                    "type_one": {
                        "A": 55,
                        "B": 12,
                        "C": 27,
                        "F": 3
                    },
                    "type_two": {
                        "A": 32,
                        "B": 99,
                        "C": 2
                    }
                    "XXXXXX": {
                        "XXXX": "XXXXXXX",
                        "YYY": "YYYYY"
                    }
                }
            ]
        }
    ]
}

我现在头都大了，这个 JSON 里面大概有上万个type_class，字典里有数组，数组里又有字典，最深的嵌套层级可能有个十几级，今天折腾了快一天，把我知道的方式都试过了，但最终输出的数据里的type_class数目和原始数据根本对不上……

求教一个方式……

第 1 条附言 · 2021-01-01 05:54:16 +08:00

已解决
看来还是不要加班熬夜，容易降低效率影响思维方式

4 条回复 • 2021-01-01 19:08:38 +08:00