python迭代查找字典中的最小值

debugcn 发表于 Dev

一起来

我有一本字典（命名为距离），看起来像这样：

{0: {0: 122.97560733739029, 1: 208.76062847194152, 2: 34.713109915419565}, 1: {0: 84.463009655114703, 1: 20.83266665599966, 2: 237.6299644405141}, 2: {0: 27.018512172212592, 1: 104.38390680559911, 2: 137.70257804413103}}

现在，我需要做的是找到与每个键对应的最小值，然后分别存储其索引。我已经为此编写了代码：

weights_indexes = {}    
for index1 in distances:
    min_dist = min(distances[index1], key=distances[index1].get)
    weights_indexes[index1] = min_dist

输出如下：

{0: 2, 1: 1, 2: 0}

现在，问题在于索引应该始终是唯一的。现在说，如果我们有一个像这样的字典：

{0: {0: 34.713109915419565, 1: 208.76062847194152, 2: 122.97560733739029}, 1: {0: 84.463009655114703, 1: 20.83266665599966, 2: 237.6299644405141}, 2: {0: 27.018512172212592, 1: 104.38390680559911, 2: 137.70257804413103}}

因此，为此找到最小索引的输出将是：

{0: 0, 1: 1, 2: 0}

在此，获得的索引（值）不是唯一的。在这种情况下，必须比较与找到重复项的索引对应的值。因此，将比较34.713109915419565和27.018512172212592。由于27.018512172212592较小，因此将选择其索引。对于索引0，将映射到下一个最小索引，即索引122.97560733739029。因此，最终映射将如下所示：

    {0: 2, 1: 1, 2: 0}

除非所有值都是唯一的，否则这应该迭代进行。我无法弄清楚如何检查唯一性，并且不断地寻找下一个最小值来进行映射。

kk模式

这是一个可行的解决方案：

test = {0: {0: 12.33334444, 1: 208.76062847194152, 2: 34.713109915419565}, 1: {0: 84.463009655114703, 1: 20.83266665599966, 2: 237.6299644405141}, 2: {0: 27.018512172212592, 1: 104.38390680559911, 2: 137.70257804413103}}

sorted_index_map = {}

for key, value in test.iteritems():
    sorted_index_map[key] = sorted(value, key=lambda k: value[k])

index_of_min_index_map = {key: 0 for key in test}

need_to_check_duplicate = True

while need_to_check_duplicate:
    need_to_check_duplicate = False
    min_index_map = {key: sorted_index_map[key][i] for key, i in index_of_min_index_map.iteritems()}
    index_set = list(min_index_map.itervalues())
    for key, index in min_index_map.iteritems():
        if index_set.count(index) == 1:
            continue
        else:
            for key_to_check, index_to_check in min_index_map.iteritems():
                if key != key_to_check and index == index_to_check:
                    if test[key][index] > test[key_to_check][index_to_check]:
                        index_of_min_index_map[key] += 1
                        need_to_check_duplicate = True
                        break

result = {key: sorted_index_map[key][i] for key, i in index_of_min_index_map.iteritems()}
print result

结果：

{0: 0, 1: 1, 2: 2}

细分：首先按索引值对索引进行排序：

test = {0: {0: 12.33334444, 1: 208.76062847194152, 2: 34.713109915419565}, 1: {0: 84.463009655114703, 1: 20.83266665599966, 2: 237.6299644405141}, 2: {0: 27.018512172212592, 1: 104.38390680559911, 2: 137.70257804413103}}

sorted_index_map = {}

for key, value in test.iteritems():
sorted_index_map[key] = sorted(value, key=lambda k: value[k])

然后，对于每个键，最小值的索引是中的第一个数字sorted_index_map：

index_of_min_index_map = {key: 0 for key in test}

现在，我们需要检查是否存在所有重复索引，如果存在，则对于同一索引的所有值（不是最小值）。我们将移至下一个小索引，即sorted_index_map密钥中的下一个。如果没有重复，那么我们就完成了。

need_to_check_duplicate = True

while need_to_check_duplicate:
    need_to_check_duplicate = False
    min_index_map = {key: sorted_index_map[key][i] for key, i in index_of_min_index_map.iteritems()}
    index_set = list(min_index_map.itervalues())
    for key, index in min_index_map.iteritems():
        if index_set.count(index) == 1:
            continue
        else:
            for key_to_check, index_to_check in min_index_map.iteritems():
                if key != key_to_check and index == index_to_check:
                    if test[key][index] > test[key_to_check][index_to_check]:
                        index_of_min_index_map[key] += 1
                        need_to_check_duplicate = True
                        break

请注意，如果有两个相同的值，您没有提到如何处理索引，因此我认为不会。

本文收集自互联网，转载请注明来源。

如有侵权，请联系[email protected] 删除。