"Multi-key" dictionary

So, I came across this issue earlier today. Wasn't real thrilled with most of the solutions here, mostly because I wanted to be able to set normal keys, but also set a range of keys all at once when needed, so I came up with this:

class RangedDict(dict): """ A dictionary that supports setting items en masse by ranges, but also supports normal keys. The core difference between this and any other dict is that by passing a tuple of 2 to 3 numeric values, an inclusive range of keys will be set to that value. An example usage is: >>> d = RangedDict({ ... (1, 5): "foo" ... }) >>> print d[1] # prints "foo" >>> print d[4] # also prints "foo" >>> print d[5] # still prints "foo" because ranges are inclusive by default >>> d['bar'] = 'baz' >>> print d['bar'] # prints 'baz' because this also works like a normal dict Do note, ranges are inclusive by default, so 5 is also set. You can control inclusivity via the `exclusive` kwarg. The third, optional, parameter that can be given to a range tuple is a step parameter (analogous to the step parameter in xrange), like so: `(1, 5, 2)`, which would set keys 1, 3, and 5 only. For example: >>> d[(11, 15, 2)] = "bar" >>> print d[13] # prints "bar" >>> print d[14] # raises KeyError because of step parameter NOTE: ALL tuples are strictly interpreted as attempts to set a range tuple. This means that any tuple that does NOT conform to the range tuple definition above (e.g., `("foo",)`) will raise a ValueError. """ def __init__(self, data=None, exclusive=False): # we add data as a param so you can just wrap a dict literal in the class constructor and it works, instead of # having to use kwargs self._stop_offset = 0 if exclusive else 1 if data is None: data = {} for k, v in data.items(): if isinstance(k, tuple): self._store_tuple(k, v) else: self[k] = v def __setitem__(self, key, value): if isinstance(key, tuple): self._store_tuple(key, value) else: # let's go ahead and prevent that infinite recursion, mmmmmkay dict.__setitem__(self, key, value) def _store_tuple(self, _tuple, value): if len(_tuple) > 3 or len(_tuple) < 2: # eventually, it would be nice to allow people to store tuples as keys too. Make a new class like: RangeKey # to do this raise ValueError("Key: {} is invalid! Ranges are described like: (start, stop[, step])") step = _tuple[2] if len(_tuple) == 3 else 1 start = _tuple[0] stop = _tuple[1] # +1 for inclusivity for idx in xrange(start, stop + self._stop_offset, step): dict.__setitem__(self, idx, value) 

It uses tuples to describe ranges, which looks rather elegant, if I do say so myself. So, some sample usage is:

d = RangedDict() d[(1, 15)] = None d[(15, 25)] = "1d6x1000 cp" 

Now you can easily use d[4] and get what you want.

The astute reader will however notice that this implementation does not allow you to use tuples as keys at all in your dict. I don't see that as a common use case, or something elegant to do, in general, so I felt it was worth the tradeoff. However, a new class could be made named along the lines of RangeKey(1, 5, step=2) that could be used to key ranges, thus letting you key tuples as well.

I hope a future reader enjoys my code!

The main drawback to this arrangement is that it's wasteful. For a small case it's not a big deal but for a large range of values you're going to need an equally large range of keys, which will mean both a lot of searching for the right key and also expending memory to store all the keys.

For the specific application the python bisect module is handy. It's great for fast searching through sorted data, so its fast for this kind of lookup table:

import bisect # Set up the data. Don't do it inside the function, you don't # want to do it over and over in the function! xp_table = [(0, 0), (15, "1d6x1000 cp"), (30, "1d8x100 sp"), (53, "2d8x10 gp"), (96 ,"1d4x10 pp")] xp_table.sort() keys = [k[0] for k in xp_table] def get_reward(val): idx = bisect.bisect_right(keys, val) return xp_table[idx][1] 

A dictionary based solution will still be better for data that doesn't sort, or does not fall into neat ranges.

My attempt, keep in my mind that I'm not close to any of pro's around here.

for i in range(1, 101): if i < 15: my_coins[i] = None if 15 <= i < 30: my_coins[i] = '1d6x1000 cp' if 30 <= i < 53: my_coins[i] = '1d8x100 sp' if 53 <= i < 96: my_coins[i] = '2d8x10 gp' if i >= 96: my_coins[i] = '1d4x10 pp' 

Put it in a function and return my_coins.

If everything wanted with the datasctructure is to be able to generate random coin, it's much easier to do directly by generating random integer number from [1, 100] and then use if-statements to go through choices (ranges).

Another possibility is to have all the values in a list as many times as their range length and use random.choice() function to fetch one.

Also, I do not find the original code particularly bad. Write tests, experiment, and you are there.

To answer the original question: One drawback of a multi-key map is that more memory is used to store the second key.

However. here is a way to get your desired functionality:

d = { # key is max value 5: 'one', 10: 'two', 15: 'three', 20: 'four', 25: 'five', 30: 'six'} MINIMUM = 1 for i in range(10): d[[key for key in sorted(d) if key >=random.randint(MINIMUM, max(d))][0]] 'two' 'four' 'two' 'five' 'three' 'three' 'five' 'four' 'three' 'four' 

You could replace the part sorted(d) with one_off_pre_sorted_keys:

one_off_pre_sorted_keys = sorted(d)