逻辑上合并物理上不同的字典

Question

我正在尝试为两个字典编写一个包装器，以使它们看起来像一个字典（仅供阅读；写作应该引发异常）。

我这样做是为了节省内存，因为其他地方需要原始字典之一。我还认为，如果要查找组合字典中不到一半的元素，它比合并字典要快。

这是我的尝试：

class LogicalMerge:
  def __init__(self, d1, d2):
    #d1 and d2 are dictionaries
    self.d1 = d1
    self.d2 = d2
  def __getitem__(self, x):
    if x in self.d1:
      return self.d1[x]
    else:
      return self.d2[x]

d1 = {1:2, 3:4}
d2 = {5:10}
d = LogicalMerge(d1, d2)
d[1] # == 2
d[5] # == 10

这种方法是否存在任何设计、技术或性能问题？

Answer 1

您可以通过将__getitem__ 重写为每次调用来节省一次查找

try:
    return self.d1[x]
except KeyError:
    return self.d2[x]

这遵循“请求宽恕，而不是许可”的蟒蛇习语。

我也觉得比合并字典快

我强烈怀疑这一点，但你应该确定。您的方法引入了额外的间接级别，并且需要对密钥进行多次散列。它也必然会占用更多内存。

编辑：这是另一种方法。用DictWithBackup 替换你的一个dicts，它的行为类似于dict，除了缺少一个键时，它会查看另一个dict。

class DictWithBackup(dict):
    def __init__(self, backup):
         self._backup = backup

    def __missing__(self, key):
         return self._backup[key]

这个版本避免了异常处理。

Answer 2

出于性能原因，我更喜欢以下内容。鉴于None 是一个永远不会有效发生的对象。

def __getitem__(self, k):
  v = self.d1.get(k, None)
  if v is None:
    v = self.d2[k] # if you're going to raise an error anyway ...
  return v

否则，您可以默认获取自定义对象。请注意，您要么需要一个实现__eq__ 的对象来测试值相等性（o1 == o2），要么——性能方面甚至更好——你使用一个不可变对象，即某个字符串"error_key_not_found_string"，这不是每次都新创建的。然后你甚至可以通过对象身份id(o1) == id(o2) 进行比较，即使用is 运算符。 （您也不需要提供__eq__。）

def __getitem__(self, k):
  v = self.d1.get(k, "error_key_not_found_string")
  # if id(v) == id("error_key_not_found_string":
  if v is "error_key_not_found_string": 
    v = self.d2[k] # if you're going to raise an error anyway ...
  return v

您是否考虑过这个项目在两个词典中的位置？

总之，从设计的角度来看，我觉得这有点令人困惑。性能提升真的证明了额外的错误和混乱来源是合理的吗？另外，您将失去所有其他 dict 功能...... 这可以像d1.update(d2) 一样简单。鉴于d1 是您在其他地方不使用的字典（那么您可以使用deepcopy）。