Jodo1992 - 1 year ago 82

Python Question

I am trying to sort a list of tuples by the second parameter in the tuple in Python 3.5.2 to find which algorithms take the

`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)

The expected output should be tuples in ascending order by the second parameter, but instead, I receive this:

`(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)

Can anyone tell me why I'm getting a seemingly random order from this? Can't seem to find where my problem is.

Answer Source

If you examine `sorted_list`

following the sort, you will see that it has been sorted correctly.

```
[(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)]
```

The error occurs in the following line:

```
for i, x in sorted_list:
```

You are not iterating over the keys and values as you think. Rather, this is unpacking each tuple in the list and assigning its first component to `i`

and its second component to `x`

. You are then accessing the element at the `i`

th position in the list, which leads to what appears to be a random ordering. You can instead write:

```
for i, x in enumerate(sorted_list):
```

Or more simply, you can print the tuple you are trying to display

```
for item in sorted_list:
print(item)
```