In what case would I use a tuple as a dictionary key?

Question

I was studying the difference between lists and tuples (in Python). An obvious one is that tuples are immutable (the values cannot be changed after initial assignment), while lists are mutable.

A sentence in the article got me:

Only immutable elements can be used as dictionary keys, and hence only tuples and not lists can be used as keys.

I have a hard time thinking of a situation where I would like to use a tuple as a dictionary key. Can you provide an example problem where this would be the natural, efficient, elegant, or obvious solution?

Edit:

Thanks for your examples. So far I take that a very important application is the caching of function values.

Answer 1

a[("John", "Doe")] = "123 Fake Street"

Answer 2

salaries = {}
salaries[('John', 'Smith')] = 10000.0
salaries[('John', 'Parker')] = 99999.0

EDIT 1 Of course you can do salaries['John Smith'] = whatever, but then you'll have to do extra work to separate the key into first and last names. What about pointColor[(x, y, z)] = "red", here the benefit of tuple key is more prominent.

I must stress out that this is not the best practice. In many cases you better create special classes to handle situations like that, but Arrieta asked for examples, which I gave her (him).

EDIT 0

By the way, each tuple element has to be hashable too:

>>> d = {}
>>> t = (range(3), range(10, 13))
>>> d[t] = 11
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: list objects are unhashable
>>>

Answer 3

Classic Example: You want to store point value as tuple of (x, y)

Answer 4

I suppose in the case of sorting, there could be merit in using a tuple. For example, suppose the dictionary key represents a sort field (obviously there would be a default sort field to prevent the key from being None). If you needed multiple sort fields, such as the case of sorting by last name, then first name, wouldn't using a tuple as the dictionary key be a good idea?

Sure, such an idea might have limited use, but that doesn't mean it is completely useless.

Answer 5

I use tuple lots of time as dict key e.g.

• I do use them when I have to create a unique key from multiple values e.g.

  based on first_name, last_name key could be key = '%s_%s'%(first_name, last_name) but better way is key = (first_name, last_name) because

  1. It is more readable, shorter and less computation
  2. It is easier to retrieve the individual values
  3. Most importantly key = '%s_%s'%(first_name, last_name) is wrong and may not give unique keys for all values of first_name and last_name e.g. when values contain _

• Caching the results of a function

  def func(a1, b1): if (a1,b1) in cache: return cache[(a1,b1)] ...

Answer 6

I used tuples as dictionary keys in application that compares network devices by geographical location. Since the devices are named similarly for each location, it provides a natural way to know if a device matching that pairing has been seen yet while processing multiples.

i.e.

seen = {}
seen[('abc', 'lax')] = 1
seen[('xyz', 'nyc')] = 1