If we have (a1, b1) and (a2, b2) it's easy to use a dictionary to store the correspondences:

dict[a1] = b1
dict[a2] = b2

And we can get (a1, b1) and (a2, b2) back no problem.

But, if we have (a1, b1, c1) and (a2, b2, c2), is it possible to get something like:

dict[a1] = (b1, c1)
dict[b1] = (a1, c1)

Where we can use either a1 or b1 to get the triplet (a1, b1, c2) back? Does that make sense? I'm not quite sure which datatype to use for this problem. The above would work but there would be duplicate data.

Basically, if I have a triplet, which data type could I use such that I can use either the first or second value to get the triplet back?

Solution

You can write your own mapping data-structure which allows to add triples, or groups of any size, and recover the group with __getitem__.

class GroupMap:
 def __init__(self):
 self.data = 

 def add(self, group):
 for item in group:
 self.data[item] = group

 def __getitem__(self, item):
 return self.data[item]

group = (1, 2, 3)
group_map = GroupMap()

group_map.add(group)

print(group_map[1]) # (1, 2, 3)

Notice that this GroupMap can be used for groups of any size, not only triples.

The next step in the above would be to extend the class to avoid collisions according to the behaviour you want when a collision occurs.

Theory

You might wonder if there is a better way to represent groups of connected objects. The answer is not really.

Suppose you have a graph containing n vertices. Then for the graph to be connected, you must have at least n - 1 edges. In the above data-structure, I used n entry in the dict, meaning the solution is nearly optimal.

Why not use n - 1 entries if it can be done? Because you would then need to traverse all your graph to recover the whole group. Thus using one more edge allows for O(1) lookup, which is a trade-off you probably want to take.

An alternative if you want to subclass dict (to get all other methods associated with dict like .get and whatnot) and only get the other elements when asked (for some reason). You can make a new dictionary that is all your own

class TupleDict(dict):

 def __setitem__(self, key, value):
 assert isinstance(key, tuple)
 for i, e in enumerate(key):
 dict.__setitem__(self, e, key[:i] + key[i+1:] + (value,))
 dict.__setitem__(self, value, key)

and then assign any key that is a tuple to a single value (not sure I like this syntax, but we can make it different or use a stand-alone method)

d = TriDict()
d[(1,2)] = 4

and you will have the result of __getitem__ return the rest of the tuple not present.

>>> print(d[1])
(2, 4)
>>> print(d[2])
(1, 4)
print(d[4])
>>> (1, 2)

Building on Olivier Melançons answer, I came up with this - in case the position of the value in the tuple matters:

class GroupMap:
 def __init__(self, data=None):
 self.data = 
 if data:
 self.add(data)

 def add(self, data):
 for idx, key in enumerate(data):
 self.data.setdefault(idx, )[key] = data

 def __getitem__(self, key):
 # lookup in first index
 return self.getby(0, key)

 def getby(self, idx, key):
 return self.data[idx].get(key)


data = ('a', 'b', 'c')
g = GroupMap(data)
more_data = ('b', 'a', 'z')
g.add(more_data)

assert g['a'] == data

assert g.getby(0, 'a') == data
assert g.getby(0, 'b') == more_data
assert g.getby(0, 'c') is None

assert g.getby(1, 'a') == more_data
assert g.getby(1, 'b') == data

assert g.getby(2, 'c') == data
assert g.getby(2, 'z') == more_data

assert id(data) == id(g['a']) == id(g.getby(1, 'b'))

Dictionaries can store key value pairs only.

You could make your own triplet dictionary however using operator overloading so that when you index with any member of the triplets you get back the other two, maybe something like this:

class trictionary:
 def __init__(self):
 self.data = []

 def add(self, group):
 self.data.append(group)

 def __getitem__(self, key):
 for group in data: #Find the set the key belongs to.
 if key in group:
 return tuple(group)

This avoids replicating the data and has the functionality you're looking for at the expense of performance. There may be a better way of doing the same.

Your question has examples that deviate from the main question:

Basically, if I have a triplet, which data type could I use such that I can use either the first or second value to get the triplet back?

A dict. Assign key-value pairs of element, triplet (see @Olivier Melançon's answer):

Code

d = 
for x in triplet:
 d[x] = triplet

Demo

d["a"]
# ('a', 'b', 'c')

d["b"]
# ('a', 'b', 'c')

d["c"]
# ('a', 'b', 'c')

The OP requires clarity on preferred behavior in:

• adding elements, e.g. d[a1] = (b1, c1) vs. f((a1, b1, c1))
  


• element ordering, e.g. (a1, b1, c1) vs. (b1, a1, c1)
  


• duplicate data, e.g. hold (a1, b1, c1) three times or combinations of 2-tuple subsets

With these items addressed, more elaborate solutions are possible.