Python dictionary keys besides strings and integers?

You can use a tuple as a key, for example if you want to create a multi-column index. Here's a simple example:

>>> index = {("John", "Smith", "1972/01/01"): 123, ("Bob", "Smith", "1972/01/02"): 124} >>> index {('Bob', 'Smith', '1972/01/02'): 124, ('John', 'Smith', '1972/01/01'): 123} >>> index.keys() [('Bob', 'Smith', '1972/01/02'), ('John', 'Smith', '1972/01/01')] >>> index['John', 'Smith', '1972/01/01'] 123 

For an example of how to use a dict as a key (a hashable dict) see this answer: Python hashable dicts

You left out the probably most important method for an object to be hashable: __hash__().

The shortest implementation of your own hashable type is this:

class A(object): pass 

Now you can use instances of A as dictionary keys:

d = {} a = A() b = A() d[a] = 7 d[b] = 8 

This is because user-defined classes are hashable by default, and their hash value is their id -- so they will only compare equal if they are the same object.

Note that instances of A are by no means immutable, and they can be used as dictionary keys nevertheless. The statement that dictionary keys must be immutable only holds for the built-in types.

Note that I've never really used this, but I've always thought using tuples as keys could let you do some interesting things. I would find it a convenient way to map grid coordinates, for example. You can think of this like a grid on a video game (maybe some kind of tactics game like Fire Emblem):

>>> Terrain = { (1,3):"Forest", (1,5):"Water", (3,4):"Land" } >>> print Terrain {(1, 5): 'Water', (1, 3): 'Forest', (3, 4): 'Land'} >>> print Terrain[(1,3)] Forest >>> print Terrain[(1,5)] Water >>> x = 3 >>> y = 4 >>> print Terrain[(x,y)] Land 

Something like that.

Edit: As Mark Rushakof pointed out in the comments, I'm basically intending this to be a sparse array.

I have no idea why you'd want to do it (and preferably, please don't do it)... but alongside strings and integers, you can also use both simultaneously. That is, as a beginner, I found it both powerful and surprising that:

foo = { 1:'this', 2:'that', 'more':'other', 'less':'etc' } 

is an entirely valid dictionary, which provides access to foo[2] as easily as it does to foo['more'].

I had to work with some JSON data that had duplicate keys. This is surprisingly difficult to work with in Python. Luckily, I didn't have to manipulate it too much, so most of the issues came around reading it in and writing it back out. You can use the very simple class below to have multiple keys with the same string representation in a dictionary that the json module won't throw an error about.

import json class DictKey(str): def __hash__(self): return id(self) temp = {DictKey('a'):1, DictKey('a'):2} print(json.dumps(temp)) # {"a": 1, "a": 2} 

I only overwrote the hash dunder and not the eq or cmp dunders and it works fine for what I needed. If you read this wiki page carefully you will see that it says "Thus a (very) desirable property of a hash function is that if two keys produce the same hash values, then the key objects are equivalent, ..." Very desirable is not the same as required. I think this is a very good example of when you need 2 different hashes for the same value.