Sorting dictionary using operator.itemgetter

Question

A question was asked here on SO , a few minutes ago, on sorting dictionary keys based on their values.

I just read about the operator.itemgetter method of sorting a few days back and decided to try that, but it doesn't seem to be working.

Not that I have any problems with the answers presented to the questions, I just wanted to try this with operator.itemgetter .

So the dict was:

>>> mydict = { 'a1': ['g',6],
           'a2': ['e',2],
           'a3': ['h',3],
           'a4': ['s',2],
           'a5': ['j',9],
           'a6': ['y',7] }

I tried this:

>>> l = sorted(mydict.itervalues(), key=operator.itemgetter(1))
>>> l
[['e', 2], ['s', 2], ['h', 3], ['g', 6], ['y', 7], ['j', 9]]

And this works as I want it to. However, since I don't have the complete dictionary ( mydict.itervalues() ), I tried this:

>>> complete = sorted(mydict.iteritems(), key=operator.itemgetter(2))

This doesn't work (as I expected it to).

So how do I sort the dict using operator.itemgetter and call itemgetter on the nested key - value pair.

Answer 1

In [6]: sorted(mydict.iteritems(), key=lambda (k,v): operator.itemgetter(1)(v))
Out[6]: 
[('a2', ['e', 2]),
 ('a4', ['s', 2]),
 ('a3', ['h', 3]),
 ('a1', ['g', 6]),
 ('a6', ['y', 7]),
 ('a5', ['j', 9])]

The key parameter is always a function that is fed one item from the iterable ( mydict.iteritems() ) at a time. In this case, an item could be something like

('a2',['e',2])

So we need a function that can take ('a2',['e',2]) as input and return 2.

lambda (k,v): ... is an anonymous function which takes one argument -- a 2-tuple -- and unpacks it into k and v . So when the lambda function is applied to our item, k would be 'a2' and v would be ['e',2] .

lambda (k,v): operator.itemgetter(1)(v) applied to our item thus returns operator.itemgetter(1)(['e',2]) , which "itemgets" the second item in ['e',2] , which is 2.

Note that lambda (k,v): operator.itemgetter(1)(v) is not a good way to code in Python. As gnibbler points out, operator.itemgetter(1) is recomputed for each item . That's inefficient. The point of using operator.itemgetter(1) is to create a function that can be applied many times. You don't want to re-create the function each time. lambda (k,v): v[1] is more readable, and faster:

In [15]: %timeit sorted(mydict.iteritems(), key=lambda (k,v): v[1])
100000 loops, best of 3: 7.55 us per loop

In [16]: %timeit sorted(mydict.iteritems(), key=lambda (k,v): operator.itemgetter(1)(v))
100000 loops, best of 3: 11.2 us per loop

Answer 2

The answer is -- you can't. operator.itemgetter(i) returns a callable that returns the item i of its argument, that is

f = operator.itemgetter(i)
f(d) == d[i]

it will never return simething like d[i][j] . If you really want to do this in a purely functional style, you can write your own compose() function:

def compose(f, g):
    return lambda *args: f(g(*args))

and use

sorted(mydict.iteritems(), key=compose(operator.itemgetter(1),
                                       operator.itemgetter(1)))

Note that I did not recommend to do this :)

Answer 3

itemgetter doesn't support nesting ( although attrgetter does)

you'd need to flatten the dict like this

sorted(([k]+v for k,v in mydict.iteritems()), key=itemgetter(2))

Answer 4

Indexing normally a la kv[1][1] is faster:

>>> from timeit import timeit
>>> setup = 'import operator; g = operator.itemgetter(1); '
>>> setup += 'd = {i: list(range(i+2)) for i in range(100)}'
>>> kwargs = {'setup': setup, 'number': 10000}

>>> timeit('sorted(d.items(), key=lambda kv: kv[1][1])', **kwargs)
0.5251589557155967

>>> timeit('sorted(d.items(), key=lambda kv: g(kv[1]))', **kwargs)
0.7175205536186695

>>> timeit('sorted(d.items(), key=lambda kv: g(kv)[1])', **kwargs)
0.7915238151326776

>>> timeit('sorted(d.items(), key=lambda kv: g(g(kv)))', **kwargs)
0.9781978335231543

Answer 5

The ability to unpack tuple parameters was removed in Python 3: See PEP 3113 .

So the accepted answer will not work for people who run python 3.x :

An equivalent solution would be

sorted(mydict.items(),key=lambda kv:operator.itemgetter(1)(kv[1]) )