Переопределить нотацию {}, чтобы я получил OrderedDict() вместо dict()?

Вот хак, который почти дает вам нужный синтаксис:

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 ordereddict

menu = ordereddict[
   "about" : "about",
   "login" : "login",
   'signup': "signup"
]

Изменить: кто-то другой обнаружил это независимо и опубликовал odictliteral пакет на PyPI, обеспечивающий чуть более полную реализацию — вместо него используйте этот пакет

Чтобы буквально получить то, что вы просите, вам нужно повозиться с синтаксическим деревом вашего файла. Я не думаю, что это целесообразно делать, но я не мог устоять перед искушением попробовать. Итак, поехали.

Во-первых, мы создаем модуль с функцией my_execfile(), которая работает так же, как встроенная execfile(), за исключением того, что все вхождения словаря отображаются, например. {3: 4, "a": 2} заменяются явными вызовами конструктора dict(), например dict([(3, 4), ('a', 2)]). (Конечно, мы могли бы напрямую заменить их вызовами collections.OrderedDict(), но мы не хотим быть слишком навязчивыми.) Вот код:

import ast

class 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

С помощью этой модификации мы можем изменить поведение отображения словаря, перезаписав dict. Вот пример:

# test.py
from collections import OrderedDict
print {3: 4, "a": 2}
dict = OrderedDict
print {3: 4, "a": 2}

Теперь мы можем запустить этот файл, используя my_execfile("test.py"), что приведет к выводу

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

Обратите внимание, что для простоты приведенный выше код не затрагивает включение словаря, которое должно быть преобразовано в выражения генератора, переданные конструктору dict(). Вам нужно добавить метод visit_DictComp() в класс DictDisplayTransformer. Учитывая приведенный выше пример кода, это должно быть прямолинейно.

Опять же, я не рекомендую возиться с семантикой языка. Вы заглянули в модуль ConfigParser?

OrderedDict не является «стандартным синтаксисом Python», однако упорядоченный набор пар ключ-значение (в стандартном синтаксисе Python) просто:

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

Чтобы явно получить OrderedDict:

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

Другой альтернативой является сортировка dictname.items(), если это все, что вам нужно:

sorted(dictname.items())

Начиная с python 3.6, все словари будут упорядочены по по умолчанию. На данный момент это деталь реализации dict, и на нее нельзя полагаться, но, вероятно, она станет стандартной после версии 3.6.

Порядок вставки всегда сохраняется в новой реализации dict:

>>>x = {'a': 1, 'b':2, 'c':3 }
>>>list(x.keys())
['a', 'b', 'c']

Начиная с python 3.6 **kwargs порядок [PEP468] и порядок атрибутов класса [PEP520]. Новая компактная, упорядоченная реализация словаря используется для реализации упорядочения для обоих из них.

То, о чем вы просите, невозможно, но если файла конфигурации в синтаксисе JSON достаточно, вы можете что-то сделать аналогично с модулем json:

>>> import json, collections
>>> d = json.JSONDecoder(object_pairs_hook = collections.OrderedDict)
>>> d.decode('{"a":5,"b":6}')
OrderedDict([(u'a', 5), (u'b', 6)])

Единственное решение, которое я нашел, - это исправить сам python, заставив объект dict запомнить порядок вставки.

Затем это работает для всех видов синтаксисов:

x = {'a': 1, 'b':2, 'c':3 }
y = dict(a=1, b=2, c=3)

и Т. Д.

Я взял реализацию ordereddict C с сайта https://pypi.python.org/pypi/ruamel.ordereddict/ и снова влился в основной код Python.

Если вы не возражаете против пересборки интерпретатора Python, вот патч для Python 2.7.8: https://github.com/fwyzard/cpython/compare/2.7.8...ordereddict-2.7.8.diff .A

Если то, что вы ищете, — это способ получить простой в использовании синтаксис инициализации — рассмотрите возможность создания подкласса OrderedDict и добавления к нему операторов, которые обновляют dict, например:

from collections import OrderedDict

class OrderedMap(OrderedDict):
    def __add__(self,other):
        self.update(other)
        return self

d = OrderedMap()+{1:2}+{4:3}+{"key":"value"}

d будет OrderedMap([(1, 2), (4, 3), ('ключ','значение')])

Другой возможный пример синтаксического сахара с использованием синтаксиса нарезки:

class OrderedMap(OrderedDict):
    def __getitem__(self, index):
        if isinstance(index, slice):
            self[index.start] = index.stop 
            return self
        else:
            return OrderedDict.__getitem__(self, index)

d = OrderedMap()[1:2][6:4][4:7]["a":"H"]