Make ordered dict default?

Question

Is it possible to make default dict literal to create ordered dicts not unordered ones?

I would like to type complex nested configs like:

config = {
   'train': {
       'speed': 0.001,
       'initial_values': [1, 2, 3]
   },
   'model': {
...
   }
}

and an idea to write a mess of brackets

config = OrderedDict([(
    'train', OrderedDict([(
       'speed', 0.001), (
       'initial_values', [1, 2, 3])]),(
    'model', OrderedDict([(
...

is absolutely unaplicable.

Please no phylosophy about why my wish is bad.

Ok, currently I would write somethong like:

def od(*args):
   return OrderedDict([(args[i], args[i+1]) for i in range(0, len(args), 2)])

config = od(
    'train', od(
        'speed', 0.001,
        'initial_values', [1, 2, 3]
     ),
     'model', od(
    ...
     )
)

In short no... but read https://stackoverflow.com/questions/39980323/are-dictionaries-ordered-in-python-3-6 for what 3.6+ does along with caveats and more details. — Jon Clements, Nov 24 '18 at 14:25

Martijn Pieters · Answer 1 · 2018-11-24T14:36:43.253

No, you can't alter Python syntax, not without altering the CPython source code and recompiling, but then it would not be Python any more.

The best you can do is to upgrade to Python 3.6 or newer, where dictionaries retain insertion order by default. If you must have the full OrderedDict feature set (reordering, reversing, dict views with ordering), then convert those regular dictionaries to OrderedDict objects after the fact:

from collections import OrderedDict
from functools import singledispatch

@singledispatch
def to_ordered_dict(d):
    """Convert dictionaries to OrderedDict objects, recursively

    Assumes you want to use current dictionary iteration order; in Python 3.7
    and newer that's the same as insertion order (or earlier if on PyPy, or 
    when using CPython, 3.6 and newer).

    """
    return d

@to_ordered_dict.register(dict)
def _dict(d):
    return OrderedDict(
        (to_ordered_dict(k), to_ordered_dict(v))
        for k, v in d.items()
    )

@to_ordered_dict.register(list)
@to_ordered_dict.register(tuple)
def _sequence(s):
    return type(s)(map(to_ordered_dict, s))

# add additional type registrations for other compound or container types

and then stick to using {...} notation with a config = to_ordered_dict(config) line at the end.

Does this not imply that `class OrderedDict(dict):` is actually obsolete in 3.6+? It is still in https://github.com/python/cpython/blob/3.7/Lib/collections/__init__.py — Jongware, Nov 24 '18 at 14:29
@usr2564301: no, it does not! `OrderedDict` offers functionality above and beyond merely remembering insertion order. — Martijn Pieters, Nov 24 '18 at 14:30
Got it! The final paragraph ".. as it offers some additional functionality" in your referred answer — Jongware, Nov 24 '18 at 14:31

score 2 · Answer 2 · answered Nov 24 '18 at 14:28

2

There's no philosophical reason why you shouldn't get to do this, but you may not do it by altering fundamental Python syntax. As mentioned elsewhere Python dictionaries can retain order after 3.6, but if you must use OrderedDict

d = OrderedDict

config = d([(...)])

You can do the same with methods like .update

answered Nov 24 '18 at 14:28

Charles Landau

4,187
1
8
24

2

Even with a single-letter alias you can't avoid having to use a list and tuples for each key-value pair, though. – Martijn Pieters Nov 24 '18 at 14:29
True enough @MartijnPieters – Charles Landau Nov 24 '18 at 14:30

score 1 · Answer 3 · answered Nov 24 '18 at 15:29

Although this doesn't directly answer to your question the way you stated it, I guess you really want to have ability to process some configs. I usually prefer saving configs not in python files, but in some structured data format. So if you can admit usage of json you could do the following.

from collections import OrderedDict
import json

result = json.loads(
'''
    {
       "train": {
           "speed": 0.001,
           "initial_values": [1, 2, 3]
       },
       "model": {
            "name": "model_name",
            "wheight" : 128000
       }
    }
''', 
object_pairs_hook=lambda pairs: OrderedDict(pairs))

This should work even in python 2.7.

And if you have a dedicated file for config then you can do something like

from collections import OrderedDict
import json

with open('settings.conf', 'r') as f:
    settings_str = f.read()
    settings = json.loads(settings_str, object_pairs_hook=lambda pairs: OrderedDict(pairs))

Make ordered dict default?

3 Answers3