### Question :

Other than doing list comprehensions of reversed list comprehension, is there a pythonic way to sort Counter by value? If so, it is faster than this:

```
>>> from collections import Counter
>>> x = Counter({'a':5, 'b':3, 'c':7})
>>> sorted(x)
['a', 'b', 'c']
>>> sorted(x.items())
[('a', 5), ('b', 3), ('c', 7)]
>>> [(l,k) for k,l in sorted([(j,i) for i,j in x.items()])]
[('b', 3), ('a', 5), ('c', 7)]
>>> [(l,k) for k,l in sorted([(j,i) for i,j in x.items()], reverse=True)]
[('c', 7), ('a', 5), ('b', 3)
```

##
Answer #1:

Use the `Counter.most_common()`

method, it’ll sort the items *for you*:

```
>>> from collections import Counter
>>> x = Counter({'a':5, 'b':3, 'c':7})
>>> x.most_common()
[('c', 7), ('a', 5), ('b', 3)]
```

It’ll do so in the most efficient manner possible; if you ask for a Top N instead of all values, a `heapq`

is used instead of a straight sort:

```
>>> x.most_common(1)
[('c', 7)]
```

Outside of counters, sorting can always be adjusted based on a `key`

function; `.sort()`

and `sorted()`

both take callable that lets you specify a value on which to sort the input sequence; `sorted(x, key=x.get, reverse=True)`

would give you the same sorting as `x.most_common()`

, but only return the keys, for example:

```
>>> sorted(x, key=x.get, reverse=True)
['c', 'a', 'b']
```

or you can sort on only the value given `(key, value)`

pairs:

```
>>> sorted(x.items(), key=lambda pair: pair[1], reverse=True)
[('c', 7), ('a', 5), ('b', 3)]
```

See the Python sorting howto for more information.

##
Answer #2:

A rather nice addition to @MartijnPieters answer is to get back a *dictionary* sorted by occurrence since `Collections.most_common`

only returns a tuple. I often couple this with a json output for handy log files:

```
from collections import Counter, OrderedDict
x = Counter({'a':5, 'b':3, 'c':7})
y = OrderedDict(x.most_common())
```

With the output:

```
OrderedDict([('c', 7), ('a', 5), ('b', 3)])
{
"c": 7,
"a": 5,
"b": 3
}
```

##
Answer #3:

Yes:

```
>>> from collections import Counter
>>> x = Counter({'a':5, 'b':3, 'c':7})
```

Using the sorted keyword key and a lambda function:

```
>>> sorted(x.items(), key=lambda i: i[1])
[('b', 3), ('a', 5), ('c', 7)]
>>> sorted(x.items(), key=lambda i: i[1], reverse=True)
[('c', 7), ('a', 5), ('b', 3)]
```

This works for all dictionaries. However `Counter`

has a special function which already gives you the sorted items (from most frequent, to least frequent). It’s called `most_common()`

:

```
>>> x.most_common()
[('c', 7), ('a', 5), ('b', 3)]
>>> list(reversed(x.most_common())) # in order of least to most
[('b', 3), ('a', 5), ('c', 7)]
```

You can also specify how many items you want to see:

```
>>> x.most_common(2) # specify number you want
[('c', 7), ('a', 5)]
```

##
Answer #4:

More general sorted, where the `key`

keyword defines the sorting method, minus before numerical type indicates descending:

```
>>> x = Counter({'a':5, 'b':3, 'c':7})
>>> sorted(x.items(), key=lambda k: -k[1]) # Ascending
[('c', 7), ('a', 5), ('b', 3)]
```