查找 3 级嵌套字典的最大字典值

Question

我有一个 3 级嵌套字典，我想找到 3 级字典的最大值并将其映射到它所属的 2 级键。 例如，在 "Loc-1" dict 值中，有两个 2 级键是 "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"}}
        
    }

}

这是所需的 state：

{ 
    "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

IIUC，您可以执行以下操作。

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

Output

{
    "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的 function ：

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"
    }
}