我猜它可能类似于 collections.namedtuple，但更像是一个冻结键的字典（半冻结字典）。不是吗？
一个“frozendict”应该是一个冻结的字典，它应该有keys，values，get等方法，并支持in，for等操作。
更新：
* 在这里链接到了：https://www.python.org/dev/peps/pep-0603
Python没有内置的frozendict类型。虽然它可能比frozenset更有用，但事实证明这种类型并不经常使用。
最常需要这种类型的原因是为了对具有未知参数的函数调用进行记忆化。存储一个可哈希等价的字典（其中值是可哈希的）的最常见解决方案是类似于tuple(sorted(kwargs.items()))的东西。
这取决于排序结果不会太疯狂。Python不能确保排序会产生合理的结果。 （但它也不能保证其他太多，所以不要太担心。）
你可以很容易地创建一些类似于字典的包装器。它可能看起来像下面这样：
import collections
class FrozenDict(collections.Mapping):
"""Don't forget the docstrings!!"""
def __init__(self, *args, **kwargs):
self._d = dict(*args, **kwargs)
self._hash = None
def __iter__(self):
return iter(self._d)
def __len__(self):
return len(self._d)
def __getitem__(self, key):
return self._d[key]
def __hash__(self):
# It would have been simpler and maybe more obvious to
# use hash(tuple(sorted(self._d.iteritems()))) from this discussion
# so far, but this solution is O(n). I don't know what kind of
# n we are going to run into, but sometimes it's hard to resist the
# urge to optimize when it will gain improved algorithmic performance.
if self._hash is None:
hash_ = 0
for pair in self.items():
hash_ ^= hash(pair)
self._hash = hash_
return self._hash
>>> x = FrozenDict(a=1, b=2)
>>> y = FrozenDict(a=1, b=2)
>>> x is y
False
>>> x == y
True
>>> x == {'a': 1, 'b': 2}
True
>>> d = {x: 'foo'}
>>> d[y]
'foo'
__hash__方法可以稍微改进一下。只需在计算哈希时使用一个临时变量，并在获得最终值后才设置self._hash。这样，当第一个线程正在计算时，另一个线程获取哈希值将仅执行冗余计算，而不是得到错误的值。 - Jeff DQ有趣的是，尽管我们有很少使用的frozenset，但仍然没有冻结映射。这个想法在PEP 416 -- 添加内置类型frozendict中被拒绝了。这个想法可能会在以后的Python版本中重新审视，请参见PEP 603 -- 在collections中添加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的更改将按预期更新DEFAULTS，但不能直接写入映射代理对象本身。
诚然，这并不是一个真正的“不可变、可散列字典”，但对于某些使用frozendict的情况可能是个不错的替代品。
def foo(config=MappingProxyType({'a': 1})):？你的示例仍然允许通过default_config进行全局修改。 - jpmc26>>> 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
dict(t)即可。 - codythecoder虽然不存在fronzedict，但您可以使用在Python 3.3中添加到标准库中的MappingProxyType ：
>>> 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})
TypeError: can't pickle mappingproxy objects。 - RaduMappingProxyType 仍然是不可哈希的。 - Jabpip install frozendict
使用它！
from frozendict import frozendict
def smth(param = frozendict({})):
pass
每当我编写像这样的函数时，我就会想到frozendict：
def do_something(blah, optional_dict_parm=None):
if optional_dict_parm is None:
optional_dict_parm = {}
如果optional_dict_parm为空，则将其设为一个空字典 {}。 - Emmanuelis None 检查可以捕获假值参数，例如 MappingProxyType({})，或者如果有人打错字，例如 0。 - wjandreaif 3 / 2 == 1:
version = 2
elif 3 / 2 == 1.5:
version = 3
def col(i):
''' For binding named attributes to spots inside subclasses of tuple.'''
g = tuple.__getitem__
@property
def _col(self):
return g(self,i)
return _col
class Item(tuple):
''' Designed for storing key-value pairs inside
a FrozenDict, which itself is a subclass of frozenset.
The __hash__ is overloaded to return the hash of only the key.
__eq__ is overloaded so that normally it only checks whether the Item's
key is equal to the other object, HOWEVER, if the other object itself
is an instance of Item, it checks BOTH the key and value for equality.
WARNING: Do not use this class for any purpose other than to contain
key value pairs inside FrozenDict!!!!
The __eq__ operator is overloaded in such a way that it violates a
fundamental property of mathematics. That property, which says that
a == b and b == c implies a == c, does not hold for this object.
Here's a demonstration:
[in] >>> x = Item(('a',4))
[in] >>> y = Item(('a',5))
[in] >>> hash('a')
[out] >>> 194817700
[in] >>> hash(x)
[out] >>> 194817700
[in] >>> hash(y)
[out] >>> 194817700
[in] >>> 'a' == x
[out] >>> True
[in] >>> 'a' == y
[out] >>> True
[in] >>> x == y
[out] >>> False
'''
__slots__ = ()
key, value = col(0), col(1)
def __hash__(self):
return hash(self.key)
def __eq__(self, other):
if isinstance(other, Item):
return tuple.__eq__(self, other)
return self.key == other
def __ne__(self, other):
return not self.__eq__(other)
def __str__(self):
return '%r: %r' % self
def __repr__(self):
return 'Item((%r, %r))' % self
class FrozenDict(frozenset):
''' Behaves in most ways like a regular dictionary, except that it's immutable.
It differs from other implementations because it doesn't subclass "dict".
Instead it subclasses "frozenset" which guarantees immutability.
FrozenDict instances are created with the same arguments used to initialize
regular dictionaries, and has all the same methods.
[in] >>> f = FrozenDict(x=3,y=4,z=5)
[in] >>> f['x']
[out] >>> 3
[in] >>> f['a'] = 0
[out] >>> TypeError: 'FrozenDict' object does not support item assignment
FrozenDict can accept un-hashable values, but FrozenDict is only hashable if its values are hashable.
[in] >>> f = FrozenDict(x=3,y=4,z=5)
[in] >>> hash(f)
[out] >>> 646626455
[in] >>> g = FrozenDict(x=3,y=4,z=[])
[in] >>> hash(g)
[out] >>> TypeError: unhashable type: 'list'
FrozenDict interacts with dictionary objects as though it were a dict itself.
[in] >>> original = dict(x=3,y=4,z=5)
[in] >>> frozen = FrozenDict(x=3,y=4,z=5)
[in] >>> original == frozen
[out] >>> True
FrozenDict supports bi-directional conversions with regular dictionaries.
[in] >>> original = {'x': 3, 'y': 4, 'z': 5}
[in] >>> FrozenDict(original)
[out] >>> FrozenDict({'x': 3, 'y': 4, 'z': 5})
[in] >>> dict(FrozenDict(original))
[out] >>> {'x': 3, 'y': 4, 'z': 5} '''
__slots__ = ()
def __new__(cls, orig={}, **kw):
if kw:
d = dict(orig, **kw)
items = map(Item, d.items())
else:
try:
items = map(Item, orig.items())
except AttributeError:
items = map(Item, orig)
return frozenset.__new__(cls, items)
def __repr__(self):
cls = self.__class__.__name__
items = frozenset.__iter__(self)
_repr = ', '.join(map(str,items))
return '%s({%s})' % (cls, _repr)
def __getitem__(self, key):
if key not in self:
raise KeyError(key)
diff = self.difference
item = diff(diff({key}))
key, value = set(item).pop()
return value
def get(self, key, default=None):
if key not in self:
return default
return self[key]
def __iter__(self):
items = frozenset.__iter__(self)
return map(lambda i: i.key, items)
def keys(self):
items = frozenset.__iter__(self)
return map(lambda i: i.key, items)
def values(self):
items = frozenset.__iter__(self)
return map(lambda i: i.value, items)
def items(self):
items = frozenset.__iter__(self)
return map(tuple, items)
def copy(self):
cls = self.__class__
items = frozenset.copy(self)
dupl = frozenset.__new__(cls, items)
return dupl
@classmethod
def fromkeys(cls, keys, value):
d = dict.fromkeys(keys,value)
return cls(d)
def __hash__(self):
kv = tuple.__hash__
items = frozenset.__iter__(self)
return hash(frozenset(map(kv, items)))
def __eq__(self, other):
if not isinstance(other, FrozenDict):
try:
other = FrozenDict(other)
except Exception:
return False
return frozenset.__eq__(self, other)
def __ne__(self, other):
return not self.__eq__(other)
if version == 2:
#Here are the Python2 modifications
class Python2(FrozenDict):
def __iter__(self):
items = frozenset.__iter__(self)
for i in items:
yield i.key
def iterkeys(self):
items = frozenset.__iter__(self)
for i in items:
yield i.key
def itervalues(self):
items = frozenset.__iter__(self)
for i in items:
yield i.value
def iteritems(self):
items = frozenset.__iter__(self)
for i in items:
yield (i.key, i.value)
def has_key(self, key):
return key in self
def viewkeys(self):
return dict(self).viewkeys()
def viewvalues(self):
return dict(self).viewvalues()
def viewitems(self):
return dict(self).viewitems()
#If this is Python2, rebuild the class
#from scratch rather than use a subclass
py3 = FrozenDict.__dict__
py3 = {k: py3[k] for k in py3}
py2 = {}
py2.update(py3)
dct = Python2.__dict__
py2.update({k: dct[k] for k in dct})
FrozenDict = type('FrozenDict', (frozenset,), py2)
Item的哈希值为键的哈希值是一个很巧妙的技巧！ - clackediff(diff({key})) 的运行时间仍然与 FrozenDict 的大小成线性关系，而常规字典的访问时间在平均情况下是恒定的。 - Dennisdict我在GitHub上看到了这种模式，想提一下：
class FrozenDict(dict):
def __init__(self, *args, **kwargs):
self._hash = None
super(FrozenDict, self).__init__(*args, **kwargs)
def __hash__(self):
if self._hash is None:
self._hash = hash(tuple(sorted(self.items()))) # iteritems() on py2
return self._hash
def _immutable(self, *args, **kws):
raise TypeError('cannot change object - object is immutable')
# makes (deep)copy alot more efficient
def __copy__(self):
return self
def __deepcopy__(self, memo=None):
if memo is not None:
memo[id(self)] = self
return self
__setitem__ = _immutable
__delitem__ = _immutable
pop = _immutable
popitem = _immutable
clear = _immutable
update = _immutable
setdefault = _immutable
示例用法：
d1 = FrozenDict({'a': 1, 'b': 2})
d2 = FrozenDict({'a': 1, 'b': 2})
d1.keys()
assert isinstance(d1, dict)
assert len(set([d1, d2])) == 1 # hashable
优点
get()、keys()、items()（在py2中为iteritems()）以及所有来自dict的好处，无需显式实现它们。dict，这意味着性能更好（dict在CPython中是用C语言编写的）。isinstance(my_frozen_dict, dict)返回True - 虽然Python鼓励鸭子类型，但许多软件包使用isinstance()，这可以节省许多调整和自定义。缺点
__hash__更快一些。您可以使用来自 utilspie 包的 frozendict，如下：
>>> from utilspie.collectionsutils import frozendict
>>> my_dict = frozendict({1: 3, 4: 5})
>>> my_dict # object of `frozendict` type
frozendict({1: 3, 4: 5})
# Hashable
>>> {my_dict: 4}
{frozendict({1: 3, 4: 5}): 4}
# Immutable
>>> my_dict[1] = 5
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "/Users/mquadri/workspace/utilspie/utilspie/collectionsutils/collections_utils.py", line 44, in __setitem__
self.__setitem__.__name__, type(self).__name__))
AttributeError: You can not call '__setitem__()' for 'frozendict' object
根据文档:
frozendict(dict_obj): 接受字典类型的obj并返回可哈希和不可变的字典
namedtuple 的主要缺点是需要在使用前指定，因此对于单次使用的情况不太方便。但是，有一个实用的解决方法可以处理许多这样的情况。假设您想要一个不可变的等效于以下字典的东西：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
getattr(fa, x) 而不是 fa[x]，因为没有 keys 方法在你的指尖上，并且所有其他映射可能需要的原因。 - Mad Physicist
frozenmap的O(log N)复杂度简直是疯了。这是个笑话吗？这可不是个笑话，对吧？仅凭这一点，PEP 603就应该被轻松地驳回。不需要进一步的同行评审。已经存在一个简单的纯Python实现的frozendict，保持着O(1)的复杂度。我叹气。 - undefined