是否存在不可变的类字典对象？ [复制]

Question

我想要一个 Python 对象，它可以灵活地获取任何键，并且我可以像字典一样通过键访问，但它是不可变的。一种选择可能是灵活地生成namedtuple，但这样做是不好的做法吗？在下面的示例中，例如，linter 不会期望 nt 具有属性 a。

例子：

from collections import namedtuple

def foo(bar):
    MyNamedTuple = namedtuple("MyNamedTuple", [k for k in bar.keys()])
    d = {k: v for k, v in bar.items()}
    return MyNamedTuple(**d)

>>> nt = foo({"a": 1, "b": 2})

Answer 1

我在 cmets 中提到过，我不确定为什么需要这样做。
但是可以简单地覆盖dictionary class 的__setitem__。尽管如此，这可能（很可能）会导致问题发生。一个最小的例子是：

class autodict(dict):
    def __init__(self, *args, **kwargs):
        super(autodict, self).__init__(*args, **kwargs)

    def __getitem__(self, key):
        val = dict.__getitem__(self, key)
        return val

    def __setitem__(self, key, val):
        pass

x = autodict({'a' : 1, 'b' : 2})
x['c'] = 3
print(x)

这将产生{'a': 1, 'b': 2}，从而忽略x['c'] = 3 集。

---

一些好处

与命名元组相比，使用字典继承的速度差异在 40-1000 倍之间。 （粗略的速度测试见下文）

in 运算符适用于字典，但像这样使用命名元组时效果不佳：

'a' in nt == False
'a' in x == True

您可以使用键访问字典样式代替 （因为没有更好的术语） JavaScript 样式

x['a'] == nt.a

虽然这是一个品味问题。

您也不必对键挑剔，因为字典基本上支持任何键标识符：

x[1] = 'a number'
nt = foo({1 : 'a number'})

命名元组将产生Type names and field names must be valid identifiers: '1'

---

优化（定时）

现在，这是一个粗略的例子，它会根据系统、月亮在天空中的位置等而有很大差异。但作为一个粗略的例子：

import time
from collections import namedtuple

class autodict(dict):
    def __init__(self, *args, **kwargs):
        super(autodict, self).__init__(*args, **kwargs)
        #self.update(*args, **kwargs)

    def __getitem__(self, key):
        val = dict.__getitem__(self, key)
        return val

    def __setitem__(self, key, val):
        pass

    def __type__(self, *args, **kwargs):
        return dict

def foo(bar):
    MyNamedTuple = namedtuple("MyNamedTuple", [k for k in bar.keys()])
    d = {k: v for k, v in bar.items()}
    return MyNamedTuple(**d)

start = time.time()
for i in range(1000000):
    nt = foo({'x'+str(i) : i})
end = time.time()
print('Named tuples:', end - start,'seconds.')

start = time.time()
for i in range(1000000):
    x = autodict({'x'+str(i) : i})
end = time.time()
print('Autodict:', end - start,'seconds.')

结果：

Named tuples: 59.21987843513489 seconds.
Autodict: 1.4844810962677002 seconds.

字典设置在我的书中，快得离谱。尽管这很可能与命名元组设置中的多个 for 循环有关，但可以通过某种方式轻松解决。但是对于基本的理解，这是一个很大的区别。该示例显然没有测试更大的一次性创建或访问时间。只是，“如果你使用这些选项在一段时间内创建数据集，你会浪费多少时间”:)

奖励：如果您有一个大型基础词典，并且想要冻结它怎么办？

base_dict = {'x'+str(i) : i for i in range(1000000)}

start = time.time()
nt = foo(base_dict)
end = time.time()
print('Named tuples:', end - start,'seconds.')

start = time.time()
x = autodict(base_dict)
end = time.time()
print('Autodict:', end - start,'seconds.')

嗯，差异比我预期的要大。x1038.5 快了几倍。
（我将 CPU 用于其他事情，但我认为这是公平的游戏） p>

Named tuples: 154.0662612915039 seconds.
Autodict: 0.1483476161956787 seconds.

Answer 2

您可以使用frozenset() 创建一个最小类来存储数据，然后添加自定义__getitem__() 方法。

class Idict:
    def __init__(self, d):
        self.d = frozenset(d.items())

    def __getitem__(self, k):
        return [v for _k,v in self.d if _k == k][0]


d = {'a':1, 'b':2}
a = Idict(d)
a['a'] #1
a['h'] = 0 #TypeError: 'Idict' object does not support item assignment