Lists of keys according to their value Python

Question

I have a python dictionary named marks:

marks={’joe’:4, ’suzan’:5, ’peter’:4, ’bob’:4, ’john’:6, ’ann’:5, ’fred’:3}

I want to produce a list of students according to their rank at that test. More precisely, build a list rank such that:

1. rank[0] contains the list of best students,
2. rank[1] contains the list of second best students, etc.

The output should be:

[[’john’], [’ann’, ’suzan’], [’joe’, ’bob’, ’peter’], [’fred’]]

Someone can help me? I'm trying for a while but I do not find any easy solutions.. Thanks

Answer 1

Python has some great builtin libraries like itertools and operator.

heres a one liner:

from itertools import groupby
from operator import itemgetter

marks = {'ann': 5, 'bob': 4, 'fred': 3, 'joe': 4, 'john': 6, 'peter': 4, 'suzan': 5}

print [[name for name, rank in g] for k, g in groupby(sorted(marks.iteritems(), key=itemgetter(1), reverse=True), key=itemgetter(1))]

I based my implementation heavily on the example here.

Answer 2

Generic algorithm (in pseudocode) would look like this:

temp = {}
for student, rank in marks:
    if not temp has key rank:
        temp[rank] = []
    push student to temp[rank]
keys = sort keys of temp
result = []
for key in keys:
    push temp[key] to result
return result

UPDATE:

Python implementation:

marks={'joe':4, 'suzan':5, 'peter':4, 'bob':4, 'john':6, 'ann':5, 'fred':3}

temp = {}

for student in marks:
    mark = marks[student]
    if not temp.has_key(mark):
        temp[mark] = []
    temp[mark].append(student)

ranks = sorted([v for v in temp])
ranks.reverse()

result = []

for rank in ranks:
    result.append(temp[rank])

print result

Answer 3

A more readable alternative using a defaultdict would be

marks = {'ann': 5, 'bob': 4, 'fred': 3, 'joe': 4, 'john': 6, 'peter': 4, 'suzan': 5}

from collections import defaultdict
rankings = defaultdict(list)
for name,score in marks.iteritems():
    rankings[score].append(name)

You know have that rankings[6] is a list of all the best, i.e. in this case rankings[6]=[john].

To recover the list of rankings from this dict you can sort the items by key:

result = []
for key in sorted(rankings,reverse=True):
    result.append(rankings[key])

Answer 4

One Line

marks = {'ann': 5, 'bob': 4, 'fred': 3, 'joe': 4, 'john': 6, 'peter': 4, 'suzan': 5}

[[name for name, val in marks.items() if val == score]\
 for score in sorted(set(marks.values()))]

edit: changed names for clarity.

Answer 5

I of course don't know your use case, but it seems like it would be better to store the information in a new "inverted dict" instead of creating a list of separate lists of students without any score information attached to them:

marks_inverted = {v: [] for v in marks.values()}
for k,v in marks.items():
    marks_inverted[v].append(k)
print(marks_inverted)
#OUTPUT: {6: ['john'], 5: ['suzan', 'ann'], 4: ['bob', 'joe', 'peter'], 3: ['fred']}
#Note that as a dict, marks_inverted doesn't have any order

Now you can look up the list of students who got each score:

print(marks_inverted[6])
#OUTPUT: ['john']

Or the maximum score:

print(marks_inverted[max(marks_inverted)]
#OUTPUT: ['john']

If you use a collections.defaultdict instead of a regular dict, you won't have to worry about getting an error if you ask for a score nobody got, and you don't have to initialize the empty lists first (idea for this came from here):

from collections import defaultdict as dd
marks_inverted = dd(list)
for k,v in marks.items():
    marks_inverted[v].append(k) 
    #if marks_inverted[v] doesn't exist it is initialized as [] before it is appended

Now if you look up 2, you won't get an error even though nobody got a 2:

print(marks_inverted[2])
#OUTPUT: []

If you're using a collections.defaultdict and you want to get the students who performed over a range of scores, you can do it like this:

[marks_inverted[k] for k in range(2,5) if marks_inverted[k]]
#OUTPUT: [['fred'], ['bob', 'joe', 'peter']]

...or if you want the list flattened:

[name for index in [marks_inverted[k] for k in range(2,5) if marks_inverted[k]] for name in index]
#OUTPUT: ['fred', 'bob', 'joe', 'peter']

(The if marks_inverted[k] part of the statement makes it so no empty lists are included as members of the list output.)

If at any time you really do need to get rid of the score information and just have a list of students in order of highest to lowest marks (like in the original question), you can just do:

[marks_inverted[k] for k in reversed(sorted(marks_inverted)) if marks_inverted[k]]
#OUTPUT: [['john'], ['ann', 'suzan'], ['bob', 'joe', 'peter'], ['fred']]