python中1：1映射的数据结构？

Question

我有一个问题，需要将键与值进行可逆的 1:1 映射。

这意味着有时我想找到给定键的值，但有时我想找到给定值的键。键和值都保证是唯一的。

x = D[y]
y == D.inverse[x]

显而易见的解决方案是每次我想要反向查找时简单地反转字典：反转字典非常容易，there's a recipe here but for a large dictionary it can be very slow。

另一种选择是创建一个新类，它将两个字典联合起来，一个用于每种查找。这很可能会很快，但会消耗两倍于单个 dict 的内存。

那么我可以使用更好的结构吗？

• 我的应用程序要求它应该非常快并且使用尽可能少的内存。
• 结构必须是可变的，并且强烈希望改变对象不应该导致它变慢（例如强制完全重新索引）
• 我们可以保证键或值（或两者）都是整数
• 很可能需要该结构来存储数千甚至数百万个项目。
• 保证键和值是唯一的，即 len(set(x)) == len(x) for for x in [D.keys(), D.valueies()]

Answer 1

另一种选择是制作一个新的 联合两个字典的类， 一种用于每种查找。那 很可能会很快，但会 使用两倍的内存 单个字典。

不是真的。你测量过吗？由于两个字典都会使用对相同对象的引用作为键和值，因此所消耗的内存将只是字典结构。这比 两倍 少很多，而且无论您的数据大小如何，它都是一个固定数量。

我的意思是不会复制实际数据。因此，您几乎不会花费额外的内存。

例子：

a = "some really really big text spending a lot of memory"

number_to_text = {1: a}
text_to_number = {a: 1}

只存在一个“非常大”字符串的副本，因此您最终只花费了更多的内存。这通常是负担得起的。

如果您没有花费至少足够的内存来存储反向查找哈希表（其中这正是您的“联合两个dicts”解决方案中正在做的事情）。

Answer 2

class TwoWay:
    def __init__(self):
       self.d = {}
    def add(self, k, v):
       self.d[k] = v
       self.d[v] = k
    def remove(self, k):
       self.d.pop(self.d.pop(k))
    def get(self, k):
       return self.d[k]

Answer 3

另一种选择是创建一个新类，它将两个字典联合起来，每个字典对应一个 > 类型的查找。这很可能会消耗两倍于单个 dict 的内存。

不是真的，因为他们只是持有对相同数据的两个引用。在我看来，这不是一个糟糕的解决方案。

您是否考虑过内存数据库查找？我不确定它的速度会如何比较，但在关系数据库中的查找速度可能非常快。

Answer 4

这是我自己解决这个问题的方法：http://github.com/spenthil/pymathmap/blob/master/pymathmap.py

我们的目标是使其对用户尽可能透明。唯一引入的重要属性是partner。

OneToOneDict 的子类来自 dict - 我知道 isn't generally recommended，但我认为我已经涵盖了常见的用例。后端非常简单，它 (dict1) 为“合作伙伴”OneToOneDict (dict2) 保留一个弱引用，这是它的倒数。当dict1 被修改时，dict2 也会相应地更新，反之亦然。

来自文档字符串：

>>> dict1 = OneToOneDict()
>>> dict2 = OneToOneDict()
>>> dict1.partner = dict2
>>> assert(dict1 is dict2.partner)
>>> assert(dict2 is dict1.partner)
>>> dict1['one'] = '1'
>>> dict2['2'] = '1'
>>> dict1['one'] = 'wow'
>>> assert(dict1 == dict((v,k) for k,v in dict2.items()))
>>> dict1['one'] = '1'
>>> assert(dict1 == dict((v,k) for k,v in dict2.items()))
>>> dict1.update({'three': '3', 'four': '4'})
>>> assert(dict1 == dict((v,k) for k,v in dict2.items()))
>>> dict3 = OneToOneDict({'4':'four'})
>>> assert(dict3.partner is None)
>>> assert(dict3 == {'4':'four'})
>>> dict1.partner = dict3
>>> assert(dict1.partner is not dict2)
>>> assert(dict2.partner is None)
>>> assert(dict1.partner is dict3)
>>> assert(dict3.partner is dict1)
>>> dict1.setdefault('five', '5')
>>> dict1['five']
'5'
>>> dict1.setdefault('five', '0')
>>> dict1['five']
'5'

当我有空闲时间时，我打算制作一个不会两次存储东西的版本。不知道什么时候会这样:)

Answer 5

假设您有一个键来查找更复杂的可变对象，只需将该键设为该对象的属性即可。看起来你最好稍微考虑一下数据模型。

Answer 6

“我们可以保证键或值（或两者）都是整数”

这写得很奇怪——“键或值（或两者）”感觉不对。要么它们都是整数，要么它们不都是整数。

听起来他们都是整数。

或者，听起来您正在考虑用整数值替换目标对象，因此您只有一个整数引用的副本。这是一种虚假的经济。只保留目标对象。所有 Python 对象实际上都是引用。实际复制很少。

让我们假设您只有两个整数，并且可以查找其中任何一个整数。一种方法是使用堆队列或 bisect 模块来维护整数键值元组的有序列表。

见http://docs.python.org/library/heapq.html#module-heapq

见http://docs.python.org/library/bisect.html#module-bisect

你有一个 heapq (key,value) 元组。或者，如果你的底层对象更复杂，(key,object) 元组。

你有另一个 heapq (value,key) 元组。或者，如果你的底层对象更复杂，(otherkey,object) tuples。

一个“插入”变成两个插入，每个插入一个堆结构列表。

一个键查找在一个队列中；值查找在另一个队列中。使用bisect(list,item) 进行查找。

Answer 7

碰巧我发现自己一直在问这个问题（尤其是昨天）。我同意制作两本词典的方法。做一些基准测试，看看它占用了多少内存。我从来不需要让它可变，但如果它有任何用处，我是这样抽象它的：

class BiDict(list):
    def __init__(self,*pairs):
        super(list,self).__init__(pairs)
        self._first_access = {}
        self._second_access = {}
        for pair in pairs:
            self._first_access[pair[0]] = pair[1]
            self._second_access[pair[1]] = pair[0]
            self.append(pair)

    def _get_by_first(self,key):
        return self._first_access[key]

    def _get_by_second(self,key):
        return self._second_access[key]

    # You'll have to do some overrides to make it mutable
    # Methods such as append, __add__, __del__, __iadd__
    # to name a few will have to maintain ._*_access

class Constants(BiDict):
    # An implementation expecting an integer and a string
    get_by_name = BiDict._get_by_second
    get_by_number = BiDict._get_by_first

t = Constants(
        ( 1, 'foo'),
        ( 5, 'bar'),
        ( 8, 'baz'),
    )

>>> print t.get_by_number(5)
bar
>>> print t.get_by_name('baz')
8
>>> print t
[(1, 'foo'), (5, 'bar'), (8, 'baz')]

Answer 8

使用 sqlite 怎么样？只需创建一个带有两列表的 :memory: 数据库。您甚至可以添加索引，然后通过任一索引进行查询。如果您将经常使用它，请将其包装在一个类中。