list.sort（）無法通過第二個元組參數正確地對值進行排序

Question

我正在嘗試通過Python 3.5.2中元組中的第二個參數對元組列表進行排序，以查找哪種算法花費least -> most時間（ least -> most以升序排列，但是出於某種原因，外觀看起來是隨機排序的。 我的代碼：

import math

def speeds(n):

    new_dictionary = {}

    six_n_log_n = 6 * n * math.log(n, 2)
    thr_n_exp05 = 3 * (n ** 0.5)
    four_expn = 4 ** n
    ceil_sqrt_n = math.ceil(math.sqrt(n))
    five_n = 5 * n
    n_cubed = n ** 3
    log_log_n = math.log(math.log(n, 2))
    n_exp_01 = n ** 0.01
    floor_2_n_log_exp2_n = math.floor(2 * n * (math.log(n, 2)**2))
    n_exp2_log_n = (n ** 2) * math.log(n, 2)
    log_exp2_n = math.log(n, 2) ** 2
    one_div_n = 1 / n
    two_exp_n = 2 ** n
    four_exp_logn = 4 ** (math.log(n, 2))
    two_exp_logn = 2 ** (math.log(n, 2))
    four_n_exp_threehalves = 4 * (n ** (3/2))
    n_exp2 = n ** 2
    sqrt_log_n = math.sqrt(math.log(n, 2))

    new_dictionary[0] = six_n_log_n
    new_dictionary[1] = thr_n_exp05
    new_dictionary[2] = four_expn
    new_dictionary[3] = ceil_sqrt_n
    new_dictionary[4] = five_n
    new_dictionary[5] = n_cubed
    new_dictionary[6] = log_log_n
    new_dictionary[7] = n_exp_01
    new_dictionary[8] = floor_2_n_log_exp2_n
    new_dictionary[9] = n_exp2_log_n
    new_dictionary[10] = log_exp2_n
    new_dictionary[11] = one_div_n
    new_dictionary[12] = two_exp_n
    new_dictionary[13] = four_exp_logn
    new_dictionary[14] = two_exp_logn
    new_dictionary[15] = four_n_exp_threehalves
    new_dictionary[16] = n_exp2
    new_dictionary[17] = sqrt_log_n

    sorted_list = []
    for key in new_dictionary:
        sorted_list.append((key, new_dictionary[key]))

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

    for i, x in sorted_list:
        print(sorted_list[i])

    return sorted_list

n = 15
speeds(n)

預期的輸出應該是第二個參數按升序排列的元組，但我收到的是：

(15, 232.379000772445)
(10, 15.263794126054286)
(14, 15.000000000000002)
(2, 1073741824)
(17, 1.9765855902562173)
(7, 1.027450511266727)
(9, 879.0503840119167)
(13, 225.00000000000006)
(3, 4)
(12, 32768)
(8, 457)
(5, 3375)
(11, 0.06666666666666667)
(4, 75)
(16, 225)
(1, 11.618950038622252)
(0, 351.6201536047667)
(6, 1.3627418135330593)

誰能告訴我為什么我從中得到一個看似隨機的訂單？ 似乎找不到我的問題在哪里。

Answer 1

如果您在排序之后檢查sorted_list ，您將看到它已正確排序。

[(11, 0), (7, 1.027450511266727), (6, 1.3627418135330593), (17, 1.9765855902562173), (3, 4.0), (1, 11.618950038622252), (14, 15.000000000000002), (10, 15.263794126054286), (15, 60), (4, 75), (16, 225), (13, 225.00000000000006), (0, 351.6201536047667), (8, 457.0), (9, 879.0503840119167), (5, 3375), (12, 32768), (2, 1073741824)]

錯誤發生在以下行：

for i, x in sorted_list:

您沒有按照您的想法遍歷鍵和值。 而是將列表中的每個元組解包，並將其第一部分分配給i ，將其第二部分分配給x 。 然后，您將訪問列表中第i個位置的元素，這將導致出現隨機排序。 您可以改寫：

for i, x in enumerate(sorted_list):

或更簡單地說，您可以打印要顯示的元組

for item in sorted_list:
    print(item)

Answer 2

遍歷元組時，您要打印元組本身：

for tup in sorted_list:
    print(tup)

否則，您將根據索引的第一個值在索引處打印值。 例如，排序列表中的第一個值是：

(11, 0)

實際上正在尋找：

sorted_list[11]

這就是為什么您看到不正確的第一價值的原因。