Question

我有两个列表（List1和List2以及一个包含键值对的字典，其中键是List1+List2的元素，值是数值。

我想要返回的是字典字典，其中键将List1的每个元素作为键，值将是从字典中提取的List2的所有元素。

作为一个理论上的例子，这就是我想要解决的问题：

List_1 = ['A', 'B', 'C', 'D']

List_2 = ['E' ,'F' ,'G' ,'H']

Old_Dict = {'A':0.12, 'B':0.3, 'C':0.22, 'D':0.35, 'E':0.12, 'F':0.23, 'G':0.32, 'H':0.14}

我想要返回的是（dict值应该按最小绝对差异排序到最高绝对差异。对于第一个密钥A，列表差异是E (0.12-0.12)，下一个是H (0.14-0.12)下一个是F(0.23-0.12)，下一个是G(0.32-0.12)，因此在对值进行排序时，顺序为E,H,F,G。

New_dict（返回）

{
    'A': {'E':0.12, 'H':0.14, 'F':0.23, 'G':0.32},
    'B': {'G':0.32, 'F':0.23, 'H':0.14, 'E':0.12},
    'C': {'F':0.23, 'H':0.14, 'E':0.12, 'G':0.32},
    'D': {'G':0.32, 'F':0.23, 'H':0.14, 'E':0.12}
}

Answer 1

sorted不需要在内循环中调用。
product_dict现在处于所需的形式。

def Nearest_cluster (ListA,ListB,dict1):
    product_dict={}
    for elem in ListA:
        elem_val = dict1.get(elem)
        holding_dict = {}
        for item in ListB:
            item_val = dict1.get(item)
            diff = abs(elem_val - item_val)
            holding_dict[item] = diff
        holding_dict2 = sorted(holding_dict.items(), key = lambda x: x[1])
        product_dict[elem] = [(k[0],dict1[k[0]]) for k in holding_dict2]
    return product_dict

>>> Nearest_cluster(List_1, List_2, Old_Dict)
{'C': [('F', 0.23), ('H', 0.14), ('G', 0.32), ('E', 0.12)],
'B': [('G', 0.32), ('F', 0.23), ('H', 0.14), ('E', 0.12)],
'D': [('G', 0.32), ('F', 0.23), ('H', 0.14), ('E', 0.12)],
'A': [('E', 0.12), ('H', 0.14), ('F', 0.23), ('G', 0.32)]}

Answer 2

我通过以下方法解决了这个问题，但想知道是否有人有更好的N操作顺序：

def Nearest_cluster (ListA,ListB,dict1):
    product_dict = {}
    for elem in ListA:
        elem_val = dict1.get(elem)
        holding_dict = {}
        for item in ListB:
            item_val = dict1.get(item)
            diff = abs(elem_val-item_val)
            holding_dict[item] = diff
        holding_dict2=sorted(holding_dict.items(), key=lambda x: x[1])
        product_dict[elem] = holding_dict2
    return product_dict

基于具有唯一元素的两个列表从字典中获取已排序的键值对

2 个答案: