Python 在不使用 min max 函数的情况下查找字典的最小值和最大值

Question

所以基本上我有这个字典，我需要在不使用 min 和 max 函数的情况下找到最小值和最大值，我需要返回键而不是值。下面是我目前拥有的它返回第一个键的最小值和最大值而不查看其余部分，我不知道如何让它返回键，但感谢任何帮助。

sol = {"Uranus":[2750, 3000, 2880], "Mercury":[46, 70, 57], "Earth":[147, 152, 150], "Venus":[107, 109, 108], "Mars":[205, 249, 228], "Saturn":[1350, 1510, 1430], "Jupiter":[741, 817, 779], "Pluto":[4440, 7380, 5910], "Neptune":[4450, 4550, 4500]}


def distance(sol, close=True):

    for name in sol:
        l = len(sol)
        closefar = sol[name][0]
        for i in range(1, l):
            if close:
                if sol[name][i] < closefar: closefar = sol[name][i]
            else:
                if sol[name][i] > closefar: closefar = sol[name][i]
            return closefar

print("Min:", distance(sol, True))
print("Max:", distance(sol, False))

Answer 1

您需要一个内部循环来查看每个字典条目的每个元素，并将其与所有其他条目中的所有其他元素进行比较。

sol = {"Uranus":[2750, 3000, 2880], "Mercury":[46, 70, 57], "Earth":[147, 152, 150], "Venus":[107, 109, 108], "Mars":[205, 249, 228], "Saturn":[1350, 1510, 1430], "Jupiter":[741, 817, 779], "Pluto":[4440, 7380, 5910], "Neptune":[4450, 4550, 4500]}

def distance(close=True):
    closest = 999999 
    farthest = 0
    for name in sol:
        for index in range (3) :
            closefar = sol[name][index]
            if close :
                if closefar < closest :
                    closefarname = name
                    closest = closefar
            else :
                if closefar > farthest :
                    closefarname = name
                    farthest = closefar
    return closefarname

print("Min:", distance(True))
print("Max:", distance(False))

Answer 2

嗯，这可能超出了您的需要，但我会向您展示另一种选择：

将您的字典变成元组列表。元组的 [0] 部分将具有键，[1] 将具有值（在您的情况下为列表）

list_sol = list(sol.items())

对内部列表进行排序，之后你会明白为什么

for x in list_sol:
    x[1].sort()

这是令人兴奋的部分

list_sol.sort(key = lambda x: x[1][0])

这是做什么的？好吧，我们正在对元组列表进行排序。如何？为了排序，我们正在查看值x[1][0]。该值是每个列表的第一个数字（作为每个字典条目的值出现）。我们之前对这些列表进行了排序，以确保第一个元素是最小的数字，最后一个元素是最大的。

现在，要获取最小距离的key，我们只需要抓取元组列表的第一个元素，然后抓取字典的key对应的字符串即可。

list_sol[0][0] # here's Mercury!

现在，最大距离是在 list_sol[-1]？没有。请记住，我们通过查看每个距离列表的 first 元素对这个列表进行排序，这是最短的一个。我们必须对最大的一个做同样的事情。方法如下：

list_sol.sort(key = lambda x: x[1][-1])

澄清一下，x[1] 选择字典的值，x[1][-1] 选择值的最后一个元素（因为它是一个列表）。

最后，

list_sol[-1][0] # here's Pluto!

Answer 3

通过更改列表中的值并更改已修改值的位置来测试此方法。

sorted(sol.items(), key=lambda e: sorted(e[1], reverse = True)[len(e)])[0][0]
Mercury

最大的：

sorted(sol.items(), key=lambda e: sorted(e[1])[len(e)], reverse = True)[0][0]
Pluto

解释：

sorted(sol.items()) 返回一个元组对列表（按字母顺序排列，Earth, Jupiter, Mars and so on）

因此，我们使用另一个键（排序标准）：

 key=lambda e: sorted(e[1])[2])
 Tuple pairs:
 e[0] = Uranus, Mercury and so on                     (dict keys)
 e[1] = [2750, 3000, 2880], [46, 70, 57] and so on    (dict values)

我们正在对元组值 (e[1]) 应用另一种排序：

 sorted(e[1]) 

翻译为：

 sorted([46, 70, 57]) = [46, 57, 70]

在这里我们捕捉到每个星球的最大价值：

 sorted([46, 70, 57])[2] = [46, 57, 70][2] = [70] Mercury
 sorted([147, 152, 150])[2] = 152 Earth

 [('Mercury', [70]), ('Venus', [109]), ('Earth', [152]), ('Mars', [249]), ('Jupiter', [817]) ...]

取每个列表的最小值：

 sorted(e[1], reverse = True)

再次，如本文开头所述，通过更改列表的值并更改最大值/最小值的位置来进行测试。

希望对你有帮助。