How does the key argument in python’s sorted function work?

Say I have

votes = {'Charlie': 20, 'Able': 10, 'Baker': 20, 'Dog': 15}

I understand

print(sorted(votes.items(), key=lambda x: x[1]))

will lead to

[('Able', 10), ('Dog', 15), ('Baker', 20), ('Charlie', 20)]

But how does this work?

Answers:

Thank you for visiting the Q&A section on Magenaut. Please note that all the answers may not help you solve the issue immediately. So please treat them as advisements. If you found the post helpful (or not), leave a comment & I’ll get back to you as soon as possible.

Method 1

The function you pass in to key is given each of the items that are being sorted, and returns a “key” that Python can sort by. So, if you want to sort a list of strings by the reverse of the string, you could do this:

list_of_strings.sort(key=lambda s: s[::-1])

This lets you specify the value each item is sorted by, without having to change the item. That way, you don’t have to build a list of reversed strings, sort that, then reverse them back.

# DON'T do this

data = ['abc', 'def', 'ghi', 'jkl']
reversed_data = [s[::-1] for s in data]
reversed_data.sort()
data = [s[::-1] for s in reversed_data]

# Do this

data.sort(key=lambda s: s[::-1])

In your case, the code is sorting each item by the second item in the tuple, whereas normally it would initially sort by the first item in the tuple, then break ties with the second item.

Method 2

>>> votes = {'Charlie': 20, 'Able': 10, 'Baker': 20, 'Dog': 15}

If we apply .items() on the votes dictionary above we get:

>>> votes_items=votes.items()
>>> votes_items
[('Charlie', 20), ('Baker', 20), ('Able', 10), ('Dog', 15)]
#a list of tuples, each tuple having two items indexed 0 and 1

For each tuple, the first index [0] are the strings ('Charlie','Able','Baker','Dog') and the second index [1] the integers (20,10,20,15).

print(sorted(votes.items(), key = lambda x: x[1])) instructs python to sort the items(tuples) in votes using the second index [1] of each tuple, the integers, as the basis of the sorting.

Python compares each integer from each tuple and returns a list that has ranked each tuple in ascending order (this can be reversed with the reverse=True argument) using each tuple’s integer as the key to determine the tuple’s rank,

Where there is a tie in the key, the items are ranked in the order they are originally in the dictionary. (so ('Charlie', 20) is before ('Baker', 20) because there is a 20==20 tie on the key but (‘Charlie', 20) comes before ('Baker', 20) in the original votes dictionary).

The output then is:

 [('Able', 10), ('Dog', 15), ('Charlie', 20), ('Baker', 20)]

I hope this makes it easier to understand.

Method 3

key is a function that will be called to transform the collection’s items before they are compared. The parameter passed to key must be something that is callable.

The use of lambda creates an anonymous function (which is callable). In the case of sorted the callable only takes one parameters. Python’s lambda is pretty simple. It can only do and return one thing really.

Method 4

The key parameter takes a function as its value, which is applied to each element before sorting, so that the elements are sorted based on the output of this function.

For example if you want to sort a list of strings based on their length, you can do something like this:

    list = ['aaaaaa', 'bb', 'ccc', 'd']
    sorted(list, key=len)

    # ['d', 'bb', 'ccc', 'aaaaaa']

All methods was sourced from stackoverflow.com or stackexchange.com, is licensed under cc by-sa 2.5, cc by-sa 3.0 and cc by-sa 4.0