Override the {...} notation so i get an OrderedDict() instead of a dict()?

Here's a hack that almost gives you the syntax you want:

class _OrderedDictMaker(object):    def __getitem__(self, keys):        if not isinstance(keys, tuple):            keys = (keys,)        assert all(isinstance(key, slice) for key in keys)        return OrderedDict([(k.start, k.stop) for k in keys])ordereddict = _OrderedDictMaker()

from nastyhacks import ordereddictmenu = ordereddict[   "about" : "about",   "login" : "login",   'signup': "signup"]

Edit: Someone else discovered this independently, and has published the odictliteral package on PyPI that provides a slightly more thorough implementation - use that package instead

To literally get what you are asking for, you have to fiddle with the syntax tree of your file. I don't think it is advisable to do so, but I couldn't resist the temptation to try. So here we go.

First, we create a module with a function my_execfile() that works like the built-in execfile(), except that all occurrences of dictionary displays, e.g. {3: 4, "a": 2} are replaced by explicit calls to the dict() constructor, e.g. dict([(3, 4), ('a', 2)]). (Of course we could directly replace them by calls to collections.OrderedDict(), but we don't want to be too intrusive.) Here's the code:

import astclass DictDisplayTransformer(ast.NodeTransformer):    def visit_Dict(self, node):        self.generic_visit(node)        list_node = ast.List(            [ast.copy_location(ast.Tuple(list(x), ast.Load()), x[0])             for x in zip(node.keys, node.values)],            ast.Load())        name_node = ast.Name("dict", ast.Load())        new_node = ast.Call(ast.copy_location(name_node, node),                            [ast.copy_location(list_node, node)],                            [], None, None)        return ast.copy_location(new_node, node)def my_execfile(filename, globals=None, locals=None):    if globals is None:        globals = {}    if locals is None:        locals = globals    node = ast.parse(open(filename).read())    transformed = DictDisplayTransformer().visit(node)    exec compile(transformed, filename, "exec") in globals, locals

With this modification in place, we can modify the behaviour of dictionary displays by overwriting dict. Here is an example:

# test.pyfrom collections import OrderedDictprint {3: 4, "a": 2}dict = OrderedDictprint {3: 4, "a": 2}

Now we can run this file using my_execfile("test.py"), yielding the output

{'a': 2, 3: 4}OrderedDict([(3, 4), ('a', 2)])

Note that for simplicity, the above code doesn't touch dictionary comprehensions, which should be transformed to generator expressions passed to the dict() constructor. You'd need to add a visit_DictComp() method to the DictDisplayTransformer class. Given the above example code, this should be straight-forward.

Again, I don't recommend this kind of messing around with the language semantics. Did you have a look into the ConfigParser module?

OrderedDict is not "standard python syntax", however, an ordered set of key-value pairs (in standard python syntax) is simply:

[('key1 name', 'value1'), ('key2 name', 'value2'), ('key3 name', 'value3')]

To explicitly get an OrderedDict:

OrderedDict([('key1 name', 'value1'), ('key2 name', 'value2'), ('key3 name', 'value3')])

Another alternative, is to sort dictname.items(), if that's all you need:

sorted(dictname.items())