二维字典或其他数据结构，其中键的顺序无关紧要

Question

我想创建一个数据结构，它可以接收一对键（字符串）并返回一个值（也可以是字符串）。无论输入 2 个键的顺序如何，我都想返回相同的值（例如 data[key1][key2] 返回与 data[key2][key1] 相同的值）。此描述是否有术语/概念？

我目前的实现是像这样创建一个 2D 字典：

my_dict = {'key1': {'key1': None,
                    'key2': 'foo',
                    ...
                    'keyn': 'bar'},
           'key2': {'key1': 'foo',
                    'key2': None,
                    ...
                    'keyn': 'baz'},
           ...
           'keyn': {'key1': 'bar',
                    'key2': 'baz',
                    ...
                    'keyn': None}}

# Calling my_dict['key1']['key2'] and my_dict['key2']['key1'] both return 'foo', which is what I want and expect.

这对我来说似乎不对。我正在复制数据，当我只需要 (n * (n - 1))/2 时，我正在创建 n * n 个条目。

所以，我尝试创建一个键是元组的一维字典：

my_dict = {('key1', 'key2'): 'foo'}

但这不起作用，因为调用 my_dict[('key2', 'key1')] 会给我一个 KeyError

一维元组字典的一种解决方法是创建一个 try/except。

def get_value(my_dict, key1, key2):
    try:
        return my_dict[key1][key2]
    except KeyError:
        return my_dict[key2][key1]

这似乎不直观，感觉更像是解决问题的“创可贴”。

我没有测试过的一种方法是一维字典，其中键使用一个自定义类的实例，该类包含key1 和key2 作为属性。为此，对象必须是不可变且可散列的，其中散列函数将使用对象的属性并生成相同的“散列键”，而不管属性的顺序如何。我以前从未这样做过，也不知道该怎么做。这是正确的方法吗？我无法弄清楚这一点，我感到非常愚蠢，因为这似乎有一个简单的答案。

Answer 1

如果您希望键比较相等而不考虑顺序，您可以使用 frozensets 作为符合您的自定义类想法的键：

my_dict = {frozenset(['key1', 'key2']): 'foo'}

无论您添加密钥的顺序是什么：

In [44]: my_dict = {frozenset(['key1', 'key2']): 'foo'}

In [45]: k = frozenset(["key1","key2"])

In [46]: k2 = frozenset(["key2","key1"])

In [47]: my_dict[k]
Out[47]: 'foo'

In [48]: my_dict[k2]
Out[48]: 'foo'

您可以在frozenset 中拥有任意数量的值，但它们仍然比较相等，使用frozen set 对查找也很有效：

In [55]: timeit my_dict[k]
10000000 loops, best of 3: 103 ns per loop

In [56]: timeit get_value(my_dict, 'key1', 'key2')
1000000 loops, best of 3: 455 ns per loop

In [57]: timeit get_value(my_dict, 'key2', 'key1')
1000000 loops, best of 3: 455 ns per loop

即使对 freezeet 创建和查找两个元素的时间安排也更快：

In [5]: my_dict = {frozenset(['key1', 'key2']): 'foo'}

In [6]: timeit my_dict[frozenset(["key1","key2"])]
1000000 loops, best of 3: 380 ns per loop

只需 3 个字符串，您就有 3 个！要检查的 perms，对于 6，您有 720，因此对于超过一对检查每个可能的排列的任何东西都是不现实的或远程有效的。

Answer 2

您可以按照您的建议使用hashable 对象。要实现这一点，您需要实现 __hash__ 和 __eq__ 或 __cmp__（两者之一）方法，如下所示：

class Key:

   def __init__(self, key1, key2):
      self.key1 = key1
      self.key2 = key2

   def __hash__(self):

      # XORing two hash values is usually fine. Besides, the operation is symmetric, which is what you want
      return hash(self.key1) ^ hash(self.key2)

   def __eq__(self, other):

      if self == other:
         return True

      if self.key1 == other.key1 and self.key2 == other.key2:
         return True

      if self.key1 == other.key2 and self.key2 == other.key1:
         return True

      return False

Answer 3

怎么样

my_dict = {('key1', 'key2'): 'foo'}

def get_value(my_dict, key1, key2):
    return my_dict.get((key2, key1) , my_dict.get((key1, key2)))

这样，你输入的条目就更少了，而且比try/except更好

例子

In [11]: my_dict = {('key1', 'key2'): 'foo'}

In [12]: def get_value(my_dict, key1, key2):
   ....:     return my_dict.get((key2, key1) , my_dict.get((key1, key2)))

In [13]: get_value(my_dict, 'key1', 'key2')
Out[13]: 'foo'

Answer 4

这是我发现的。列表的维度必须相同。

my_dict = {}
sub_dict = {}

ks = ['key1','key2','key3','keyn']
kks = ['key1','key2','key3','keyn']
vals = [None,'foo','bar','baz']

for val in vals:    
    for kk in kks:
        sub_dict[kk] = val

print sub_dict

for k in ks:
    my_dict[k] = sub_dict

print my_dict

Frozenset 可能更好。