求三级嵌套dict的最大dict值

Question

我有一个3级嵌套dict，我希望找到第3级dict的最大值，并将其映射到它所属的第2级键。例如，在"Loc-1“dict值中，有两个二级键，即"36"，我希望这个键映射到值"56”。

这就是我的观点：

{
    "Loc-1": {
        "A-1": {"36" : {"value" : "34"}},
        "A-2": {"36" : {"value" : "56"}},
        "A-3": {"48" : {"value" : "72"}},
        "A-4": {"100" : {"value" : "77"}},
        "A-5": {"48" : {"value" : "2"}},
        "A-6": {"100" : {"value" : "10"}},
        "A-7": {"44" : {"value": "21"}}
        
    }
    
    "Loc-2": {
        "A-8": {"44" : {"value" : "52"}},
        "A-9": {"48" : {"value" : "23"}},
        "A-10": {"40" : {"value" : "62"}},
        "A-11": {"153" : {"value" : "43"}},
        "A-12": {"40" : {"value" : "22"}},
        "A-13": {"153" : {"value" : "10"}},
        "A-14": {"36" : {"value": "21"}}
        
    }

}

这是所需的状态：

{ 
    "Loc-1": {   
        "36" : "56",
        "48" : "72",
        "100": "77",
        "44" : "21"
        
    }
    
    "Loc-2": { 
        "36" : "21",
        "40" : "62",
        "48" : "23",
        "44" : "52",
        "153": "43",
        
    }
    
}

当像这样嵌套时，我发现很难用相同的键将一个值与所有其他值进行比较。我怎样才能做到这一点？

Answer 1

嵌套循环将起作用：

results = {}

# 1st level: "Loc-1", "Loc-2"
for key1 in data:
    # Initialize to empty dictionary
    results[key1] = {}
    # 2nd level: A-1, A-2, etc
    for key2 in data[key1]:
        # First key 3rd level: 38, 36, etc
        key3 = next(iter(data[key1][key2]))
        value = data[key1][key2][key3]["value"]
        # Set max if already in results or just add
        if key3 in results[key1]:
            results[key1][key3] = max(results[key1][key3], value)
        else:
            results[key1][key3] = value

Answer 2

你可以做下面的事。

def process(d):
    def process_(dic_1st_level):
        ' Get max values from 2nd level dics '
        result = {}
        for a, d_2nd_level in dic_1st_level.items():
            for label, v in d_2nd_level.items():
                result[label] = max(result.get(label, 0), v['value'], key = int)

        # Sort result by key as ints
        return dict(sorted(result.items(), key = lambda kv: int(kv[0])))

    return {k.replace("Loc", "Site"):process_(v) for k, v in d.items()}

使用

print(process(d))   # d is the input nested dictionary

输出

{
    "Site-1": {
        "36": "56",
        "44": "21",
        "48": "72",
        "100": "77"
    },
    "Site-2": {
        "36": "21",
        "40": "62",
        "44": "52",
        "48": "23",
        "153": "43"
    }
}

Answer 3

让我们先从最简单的，最内部的字典开始，然后找到外边的字典。我将把最内部的字典简单地称为dict_object，例如{"36" : {"value" : "34"}}。为了使用本词典，我发现更容易将其转换为一个更简单的结构:一个包含两个元素的元组：("36", "34")。为此，我创建了一个名为transform_value的函数

def transform_value(dict_object):
    """Transform {"36" : {"value" : "34"}} --> ("36", "34")."""
    for key, value in dict_object.items():
        return key, value["value"]

# Test it out
>>> transform_value({"36" : {"value" : "34"}})
('36', '34')

接下来，我还需要对两个字符串进行数值比较，并返回较大的字符串：

def maxint(a, b):
    """Take max of two strings which represents two ints."""
    return str(max(int(a), int(b)))

# Test it out:
>>> maxint("34", "56")
'56'

计算出(或向上)另一个级别，即具有“Loc-1”值的级别：

def transform_loc(loc_values):
    transformed = {}
    for dict_object in loc_values:
        key, value = transform_value(dict_object)
        transformed.setdefault(key, value)
        transformed[key] = maxint(transformed[key], value)
    return transformed

# Test it out, let's call the original structure `data`
>>> transform_loc(data["Loc-1"].values())
{'36': '56', '48': '72', '100': '77', '44': '21'}

把这一切结合在一起：

new_data = {
    key: transform_loc(loc.values())
    for key, loc in data.items()
}

# New data is
{
    "Loc-1": {
        "36": "56",
        "48": "72",
        "100": "77",
        "44": "21"
    },
    "Loc-2": {
        "44": "52",
        "48": "23",
        "40": "62",
        "153": "43",
        "36": "21"
    }
}