namedtuple的主要缺点是需要在使用之前指定它，因此对于单一用例来说不太方便。

然而，有一种实用的变通方法可以用来处理许多此类情况。让我们假设你想有一个不可变的等价物如下dict:

MY_CONSTANT = {
    'something': 123,
    'something_else': 456
}

可以这样模拟:

from collections import namedtuple

MY_CONSTANT = namedtuple('MyConstant', 'something something_else')(123, 456)

甚至还可以编写一个辅助函数来实现自动化:

def freeze_dict(data):
    from collections import namedtuple
    keys = sorted(data.keys())
    frozen_type = namedtuple(''.join(keys), keys)
    return frozen_type(**data)

a = {'foo':'bar', 'x':'y'}
fa = freeze_dict(data)
assert a['foo'] == fa.foo

当然，这只适用于平面字典，但实现递归版本应该不会太难。

奇怪的是，尽管我们有很少有用的frozenset，但仍然没有冻结映射。这个想法在PEP 416中被否决了——添加一个frozendict内置类型。这个想法可能会在后面的Python版本中重新讨论，请参阅PEP 603—向集合添加frozenmap类型。

所以Python 2的解决方案是:

def foo(config={'a': 1}):
    ...

这似乎仍是常态:

def foo(config=None):
    if config is None:
        config = {'a': 1}  # default config
    ...

在Python 3中，你可以这样做:

from types import MappingProxyType

default_config = {'a': 1}
DEFAULTS = MappingProxyType(default_config)

def foo(config=DEFAULTS):
    ...

现在，默认配置可以动态更新，但在您希望它不可变的地方保持不变，只需传递代理即可。

因此，default_config中的更改将按预期更新默认值，但不能写入映射代理对象本身。

诚然，它与“不可变的、可哈希的字典”不是一回事，但它可能是frozendict某些用例的体面替代品。

假设字典的键和值本身是不可变的(例如字符串)，那么:

>>> d
{'forever': 'atones', 'minks': 'cards', 'overhands': 'warranted', 
 'hardhearted': 'tartly', 'gradations': 'snorkeled'}
>>> t = tuple((k, d[k]) for k in sorted(d.keys()))
>>> hash(t)
1524953596

没有fronzedict，但你可以使用MappingProxyType，它被添加到Python 3.3的标准库中:

>>> from types import MappingProxyType
>>> foo = MappingProxyType({'a': 1})
>>> foo
mappingproxy({'a': 1})
>>> foo['a'] = 2
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'mappingproxy' object does not support item assignment
>>> foo
mappingproxy({'a': 1})

在没有本地语言支持的情况下，您可以自己动手，也可以使用现有的解决方案。幸运的是，Python使得扩展它们的基本实现变得非常简单。

class frozen_dict(dict):
    def __setitem__(self, key, value):
        raise Exception('Frozen dictionaries cannot be mutated')

frozen_dict = frozen_dict({'foo': 'FOO' })
print(frozen['foo']) # FOO
frozen['foo'] = 'NEWFOO' # Exception: Frozen dictionaries cannot be mutated

# OR

from types import MappingProxyType

frozen_dict = MappingProxyType({'foo': 'FOO'})
print(frozen_dict['foo']) # FOO
frozen_dict['foo'] = 'NEWFOO' # TypeError: 'mappingproxy' object does not support item assignment

我需要在某一时刻访问某个固定键用于某种全局常量类型的东西我确定了这样的东西:

class MyFrozenDict:
    def __getitem__(self, key):
        if key == 'mykey1':
            return 0
        if key == 'mykey2':
            return "another value"
        raise KeyError(key)

像这样使用它

a = MyFrozenDict()
print(a['mykey1'])

警告:对于大多数用例，我不建议这样做，因为它需要进行一些相当严重的权衡。