Question

I have some dozens of tuples each containing 2 strings and 1 integer. Ex:(str, str, int).
All these tuples are in a list (example below).
Each tuple is unique and each tuple’s strings and integer are also unique.

Ex.:

[('a','aA', 53),
 ('b','bb', 21),
 ('c','cc', 234),
 ('d','de', 76),
..]

What I want is, to use this data structure like a dictionary and retrieve the entire tuple for any of one of the 3 values I pass.

Ex.:

For value 'a' -> get the whole tuple of:('a', 'aA', 53)

For value 'cc' -> get the whole tuple of:('c', 'cc', 234)

For value '76' – > get the whole tuple of:('d', 'de', 76)

So far I have done:
Creating a simple function to iterate through the list of tuples, go through each tuple and its all 3 values to find a match and if there’s a match return the tuple, if not return False.

This sounds slow and seems like the very wrong way to do this task.

1. What would be the right way to achieve this?
2. Should I create 3 dictionaries and link them to each other?

Answer 1

You’d have to create separate indexes using dictionaries to allow looking up elements by contents:

from collections import defaultdict

index_on_1 = defaultdict(list)
index_on_2 = defaultdict(list)
index_on_3 = defaultdict(list)

for i, (val1, val2, val3) in enumerate(yourstructure):
    index_on_1[val1].append(i)
    index_on_2[val2].append(i)
    index_on_3[val3].append(i)

Now you can look up indices on strings:

from itertools import chain

def lookup(entry):
    if isinstance(entry, str):
        entries = chain(index_on_1.get(entry, []), index_on_2.get(entry, []))
        return [yourstructure[i] for i in entries]
    else:
        return [yourstructure[i] for i in index_on_3.get(entry, [])]

Note that this always returns a list, as your entries could match multiple tuples. If the lookup is a string, we only use the first two indexes, otherwise only the 3rd.

Alternatively, the more general solution that doesn’t care about entry type, would be to create a list of indexes, instead of 3 separate variables:

indexes = [defaultdict(list) for _ in range(3)]

for i, values in enumerate(yourstructure):
    for index, val in zip(indexes, values):
        index[val].append(i)

with the lookup becoming:

def lookup(entry):
    entries = chain(*[index.get(entry, []) for index in indexes])
    return [yourstructure[i] for i in entries]

You could bundle this all up in a class, where your indexes are kept up to date as you add or remove elements.