python – Can I get JSON to load into an OrderedDict?

The Question :

437 people think this question is useful

Ok so I can use an OrderedDict in json.dump. That is, an OrderedDict can be used as an input to JSON.

But can it be used as an output? If so how? In my case I’d like to load into an OrderedDict so I can keep the order of the keys in the file.

If not, is there some kind of workaround?

The Question Comments :
  • Never tried to maintain order, although I can certainly see how it would be useful.
  • Yes, in my case I am bridging the gap between different languages and applications, and JSON works very well. But the ordering of keys is a bit of an issue. Would be awesome to have a simple to tick in json.load to use OrderedDicts instead of Dicts in Python.
  • JSON spec defines object type as having unordered keys… expecting specific key order is a mistake
  • Key ordering isn’t usually for any sort of functional requirements. It’s mainly just for human readability. If I just want my json to be pretty-printed, I do not expect any of the document order to change at all.
  • It also helps avoid large git diffs!

The Answer 1

627 people think this answer is useful

Yes, you can. By specifying the object_pairs_hook argument to JSONDecoder. In fact, this is the exact example given in the documentation.

>>> json.JSONDecoder(object_pairs_hook=collections.OrderedDict).decode('{"foo":1, "bar": 2}')
OrderedDict([('foo', 1), ('bar', 2)])

You can pass this parameter to json.loads (if you don’t need a Decoder instance for other purposes) like so:

>>> import json
>>> from collections import OrderedDict
>>> data = json.loads('{"foo":1, "bar": 2}', object_pairs_hook=OrderedDict)
>>> print json.dumps(data, indent=4)
    "foo": 1,
    "bar": 2

Using json.load is done in the same way:

>>> data = json.load(open('config.json'), object_pairs_hook=OrderedDict)

The Answer 2

128 people think this answer is useful

Simple version for Python 2.7+

my_ordered_dict = json.loads(json_str, object_pairs_hook=collections.OrderedDict)

Or for Python 2.4 to 2.6

import simplejson as json
import ordereddict

my_ordered_dict = json.loads(json_str, object_pairs_hook=ordereddict.OrderedDict)

The Answer 3

41 people think this answer is useful

Some great news! Since version 3.6 the cPython implementation has preserved the insertion order of dictionaries ( This means that the json library is now order preserving by default. Observe the difference in behaviour between python 3.5 and 3.6. The code:

import json
data = json.loads('{"foo":1, "bar":2, "fiddle":{"bar":2, "foo":1}}')
print(json.dumps(data, indent=4))

In py3.5 the resulting order is undefined:

    "fiddle": {
        "bar": 2,
        "foo": 1
    "bar": 2,
    "foo": 1

In the cPython implementation of python 3.6:

    "foo": 1,
    "bar": 2,
    "fiddle": {
        "bar": 2,
        "foo": 1

The really great news is that this has become a language specification as of python 3.7 (as opposed to an implementation detail of cPython 3.6+):

So the answer to your question now becomes: upgrade to python 3.6! 🙂

The Answer 4

7 people think this answer is useful

You could always write out the list of keys in addition to dumping the dict, and then reconstruct the OrderedDict by iterating through the list?

The Answer 5

5 people think this answer is useful

In addition to dumping the ordered list of keys alongside the dictionary, another low-tech solution, which has the advantage of being explicit, is to dump the (ordered) list of key-value pairs ordered_dict.items(); loading is a simple OrderedDict(<list of key-value pairs>). This handles an ordered dictionary despite the fact that JSON does not have this concept (JSON dictionaries have no order).

It is indeed nice to take advantage of the fact that json dumps the OrderedDict in the correct order. However, it is in general unnecessarily heavy and not necessarily meaningful to have to read all JSON dictionaries as an OrderedDict (through the object_pairs_hook argument), so an explicit conversion of only the dictionaries that must be ordered makes sense too.

The Answer 6

4 people think this answer is useful

The normally used load command will work if you specify the object_pairs_hook parameter:

import json
from  collections import OrderedDict
with open('foo.json', 'r') as fp:
    metrics_types = json.load(fp, object_pairs_hook=OrderedDict)

Add a Comment