Multiples-keys字典，其中键顺序无关紧要

Question

I am trying to create a dictionary with two strings as a key and I want the keys to be in whatever order.

myDict[('A', 'B')] = 'something'
myDict[('B', 'A')] = 'something else'
print(myDict[('A', 'B')])

I want this piece of code to print 'something else'. Unfortunately, it seems that the ordering matters with tuples. What would be the best data structure to use as the key?

Answer 1

Use a frozenset

Instead of a tuple , which is ordered, you can use a frozenset , which is unordered , while still hashable as frozenset is immutable .

myDict = {}
myDict[frozenset(('A', 'B'))] = 'something'
myDict[frozenset(('B', 'A'))] = 'something else'
print(myDict[frozenset(('A', 'B'))])

Which will print:

something else

---

---

Unfortunately, this simplicity comes with a disadvantage, since frozenset is basically a “frozen” set. There will be no duplicate values in the frozenset , for example,

frozenset((1, 2)) == frozenset((1,2,2,1,1))

If the trimming down of values doesn't bother you, feel free to use frozenset

But if you're 100% sure that you don't want what was mentioned above to happen, there are however two alternates:

---

First method is to use a Counter , and make it hashable by using frozenset again: ( Note: everything in the tuple must be hashable )

from collections import Counter

myDict = {}
myDict[frozenset(Counter(('A', 'B')).items())] = 'something'
myDict[frozenset(Counter(('B', 'A')).items())] = 'something else'
print(myDict[frozenset(Counter(('A', 'B')).items())])

# something else

---

Second method is to use the built-in function sorted , and make it hashable by making it a tuple . This will sort the values before being used as a key: ( Note: everything in the tuple must be sortable and hashable )

myDict = {}
myDict[tuple(sorted(('A', 'B')))] = 'something'
myDict[tuple(sorted(('B', 'A')))] = 'something else'
print(myDict[tuple(sorted(('A', 'B')))])

# something else

But if the tuple elements are neither all hashable , nor are they all sortable , unfortunately, you might be out of luck and need to create your own dict structure... D:

Answer 2

You can build your own structure:

class ReverseDict:
   def __init__(self):
      self.d = {}
   def __setitem__(self, k, v):
      self.d[k] = v

   def __getitem__(self, tup):
      return self.d[tup[::-1]]

myDict = ReverseDict()
myDict[('A', 'B')] = 'something'
myDict[('B', 'A')] = 'something else'
print(myDict[('A', 'B')])

Output:

something else

Answer 3

I think the point here is that the elements of the tuple point to the same dictionary element regardless of their order. This can be done by making the hash function commutative over the tuple key elements:

class UnorderedKeyDict(dict):
    def __init__(self, *arg):
        if arg:
            for k,v in arg[0].items():
                self[k] = v

    def _hash(self, tup):
        return sum([hash(ti) for ti in tup])

    def __setitem__(self, tup, value):
        super().__setitem__(self._hash(tup), value)

    def __getitem__(self, tup):
      return super().__getitem__(self._hash(tup))

mydict = UnorderedKeyDict({('a','b'):12,('b','c'):13})
mydict[('b','a')]
    >> 12