Use a Dict :
m = {"A1" : [], "B3" : []}
m["A1"].append(1)
m["A1"].append(2)
m["B3"].append(3)
Note that you need to insert the key first in the dictionary, otherwise it would show KeyError. If you want to add a new key, suppose "A2" here, simply do :
m["A2"] = []
To sort the dictionary according to its keys, use an OrderedDict :
m = OrderedDict(sorted(m.items(), key = lambda t : t[0]))
One more thing, only non-mutable items such as strings, tuples, int, etc. are allowed as keys in a python dictionary, you can't have a dictionary with a list like [1,2,3] as one of the keys.
c++ - python data structure: map - Stack Overflow
A data-structure for 1:1 mappings in python? - Stack Overflow
are dictionary/maps the core data structure of any programming language?
Lack of TreeMap equivalent in Python
Videos
Use a Dict :
m = {"A1" : [], "B3" : []}
m["A1"].append(1)
m["A1"].append(2)
m["B3"].append(3)
Note that you need to insert the key first in the dictionary, otherwise it would show KeyError. If you want to add a new key, suppose "A2" here, simply do :
m["A2"] = []
To sort the dictionary according to its keys, use an OrderedDict :
m = OrderedDict(sorted(m.items(), key = lambda t : t[0]))
One more thing, only non-mutable items such as strings, tuples, int, etc. are allowed as keys in a python dictionary, you can't have a dictionary with a list like [1,2,3] as one of the keys.
In Python, the equivalent of a hashmap is a Dict (in fact, most implementation of Dict are hashmaps). To ensure ordering across implementations, you will want to use an OrderedDict. A List is equivalent to a vector. Therefore, what you want is an OrderedDict of Lists.
from collections import OrderedDict
// Create the dictionary
d = {'A1': [1, 2], 'B2': [2, 3]}
// Order it by key
m = OrderedDict(sorted(d.items(), key=lambda t: t[0]))
// Example of appending to one of the lists
m['A1'].append(3)
print(m)
This will print:
OrderedDict([('A1', [1, 2, 3]), ('B2', [2, 3])])
You can also add additional keys containing Lists like this:
m["B2"] = [2, 3, 5, 7]
You will then need to re-sort the OrderedDict.
A minor note: Dicts in Python aren't ordered; they happen to be ordered in very new versions of CPython 3, but that's an implementation detail. Therefore, OrderedDict is the most applicable datastructure here, to ensure that your code is portable. I'm mentioning this because many people are very excited about this feature of CPython, but it's not guaranteed to work everywhere.
The other alternative is to make a new class which unites two dictionaries, one for each kind of lookup. That would most likely be fast but would use up twice as much memory as a single dict.
Not really. Have you measured that? Since both dictionaries would use references to the same objects as keys and values, then the memory spent would be just the dictionary structure. That's a lot less than twice and is a fixed ammount regardless of your data size.
What I mean is that the actual data wouldn't be copied. So you'd spend little extra memory.
Example:
a = "some really really big text spending a lot of memory"
number_to_text = {1: a}
text_to_number = {a: 1}
Only a single copy of the "really big" string exists, so you end up spending just a little more memory. That's generally affordable.
I can't imagine a solution where you'd have the key lookup speed when looking by value, if you don't spend at least enough memory to store a reverse lookup hash table (which is exactly what's being done in your "unite two dicts" solution).
class TwoWay:
def __init__(self):
self.d = {}
def add(self, k, v):
self.d[k] = v
self.d[v] = k
def remove(self, k):
self.d.pop(self.d.pop(k))
def get(self, k):
return self.d[k]