Question

I have 20 strings which match 20 integers. All integers and strings are unique. I am considering but would like to avoid creating two dictionaries. One dictionary will be indexed by the string, and one dictionary will be indexed by the integer.

• How should I handle this situation?

I created two lists. One containing strings, the other containing integers. I am thinking of building two functions. One function will produce a string. The other function will produce an integer. Another alternative is to combine these into one function by branching if produced argument is an integer or a string.

• How is this comparable to a dictionary? Will it consume a lot of cpu?
  (this function will run millions of times everyday)
• Should I just create a list of tuples which are (string, int) and then
  create two dictionaries, one mapping int to list position and other
  string to list position? Will it be the best way?

I don’t have many items so I can sacrifice some memory.

Please explain the best method with an explanation of why it is the best.

Thank you.

Answer 1

Whatever solution you go with, if you want it to be robust, you should probably wrap a class around it that automatically updates the other direction when you update one. For instance, here’s a start at a basic bidirectional dictionary using @mgilson’s technique (which means it won’t work if there’s any overlap between the two sets of items you’re mapping to each other; having different types works great, though):

class BiDict(dict):
  """Bidirectional Dictionary - setting 'key' to 'value' also
     sets 'value' to 'key' (so don't use overlapping mappings)
  """

  def __init__(self, *args):
    super(BiDict, self).__init__(*args)

    # After regular dict initialization, loop over any items
    # and add their reverse.  Note that we can't use any of the
    # iter* methods here since we're adding items in the body
    # of the loop.
    for key in self.keys():
      super(BiDict, self).__setitem__(self[key], key);


  def __setitem__(self, key, val):
    # If the key has an old value, delete its reverse
    if key in self:
      super(BiDict, self).__delitem__(self[key])

    # Then add both forward and reverse for the new value
    super(BiDict, self).__setitem__(key, val);
    super(BiDict, self).__setitem__(val, key);

  def __delitem__(self, key):
    # delete both directions
    if key in self:
      super(BiDict, self).__delitem__(self[key]);
      super(BiDict, self).__delitem__(key);

You can use it like this:

>>> from bidict import BiDict
>>> d = BiDict({'a':1,'b':2})
>>> d['a']
1
>>> d[2]
'b'
>>> d['c']=3
>>> d[3]
'c'
>>> del d['a']
>>> d['a']
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'a'
>>> d[1]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 1