how to sort tuple element first on the basis of key and then on the basis of value

Question

How to sort a tuple of elements in python, first on the basis of value and then on the basis of key. Consider the program in which I am taking input from the user as a string. I want to find out the count of each character and print the 3 most common characters in a string.

#input string
strr=list(raw_input())
count=dict()

#store the count of each character in dictionary
for i in range(len(strr)):
count[strr[i]]=count.get(strr[i],0)+1

#hence we can't perform sorting on dict so convert it into tuple 
temp=list()
t=count.items()

for (k,v) in t:
    temp.append((v,k))

temp.sort(reverse=True)

 #print 3 most common element
for (v,k) in temp[:3]:
         print k,v

on giving the i/p -aabbbccde

Output of the above code is:

3 b
2 c
2 a

But I want the output as:

3 b
2 a
2 c

In the sort statement, you just need to sort by key. Something like this: `temp.sort(key=lambda x: x[0], reverse=True)` — karthikr, May 29 '16 at 18:52
@TadhgMcDonald-Jensen, this question is not simply about sorting by value, but sorting by `(t[0], t[1])` with different order. — SparkAndShine, May 29 '16 at 19:29
@sparkandshine you are right, since primarily sorting by value in descending order then secondary by key in ascending order is very much a different problem then just sorting by value. — Tadhg McDonald-Jensen, May 29 '16 at 19:35

SparkAndShine · Answer 1 · 2016-05-30T08:16:05.797

7

Sort a list of tuples, the first value in descending order (reverse=True) and the second value in ascending order (reverse=False, by default). Here is a MWE.

lists = [(2, 'c'), (2, 'a'), (3, 'b')]

result = sorted(lists, key=lambda x: (-x[0], x[1])) # -x[0] represents descending order

print(result)
# Output
[(3, 'b'), (2, 'a'), (2, 'c')]

It is straightforward to use collections.Counter to count each letter's frequency in a string.

import collections

s = 'bcabcab'

# If you don't care the order, just use `most_common`
#most_common = collections.Counter(s).most_common(3)

char_and_frequency = collections.Counter(s)
result = sorted(char_and_frequency.items(), key=lambda x:(-x[1], x[0]))[:3]    # sorted by x[1] in descending order, x[0] in ascending order

print(result)
# Output
[('b', 3), ('a', 2), ('c', 2)]

edited May 30 '16 at 08:16

answered May 29 '16 at 18:46

SparkAndShine

17,001
22
90
134

by applying `sorted` on `count.items()` you don't need to have the `lists` intermediate step. – Tadhg McDonald-Jensen May 29 '16 at 19:36
@TadhgMcDonald-Jensen, I see. `result = sorted(count.items(), key=lambda x: (-x[0], x[1]))`. Here, I just use `lists` to show an example. – SparkAndShine May 29 '16 at 19:40
well using items `x[0]` would be the letter (key) and `x[1]` would be the occurence so it would actually be `key = lambda x:(-x[1], x[0])` :) – Tadhg McDonald-Jensen May 29 '16 at 19:42
1

using `Counter` here will give arbitrary order for letters that occur the same number of time: `collections.Counter(string.ascii_lowercase).most_common(3) -> [('z', 1), ('x', 1), ('w', 1)]` – Tadhg McDonald-Jensen May 29 '16 at 19:44
@TadhgMcDonald-Jensen, thx for pointing out this. I just edited my answer. – SparkAndShine May 29 '16 at 19:54

Tadhg McDonald-Jensen · Answer 2 · 2016-06-05T02:45:34.440

As a general solution for "sort by value descending then by key ascending" you can use itertools.groupby:

import itertools
from operator import itemgetter

def sort_by_value_then_key(count_dict):
    first_level_sorted = sorted(count_dict.items(), key=itemgetter(1), reverse=True)
    for _, group in itertools.groupby(first_level_sorted,itemgetter(1)):
        for pair in sorted(group):
            yield pair


strr=list("aabbccdef")
count=dict()

#store the count of each character in dictionary
for i in range(len(strr)):
    count[strr[i]]=count.get(strr[i],0)+1


temp = list(sort_by_value_then_key(count))

for (letter, freq) in temp[:3]:
    print letter, freq

Output:

a 2
b 2
c 2

since you are using integers @sparkandshine's solution of sorting by the negative number will probably be easier to work with but this is much more generalized.

how to sort tuple element first on the basis of key and then on the basis of value

2 Answers2

Linked