Dictionaries

You can think of lists as a mapping from indices to values. The indices are always integers and go from 0 to len(the_list), and the values are the items.

Dictionaries are collections, just like lists, but they have important differences:

• lists map sequential numeric indices to items, whereas dictionaries can map most object types to any object,
• lists are ordered collections of items, whereas dictionaries have no ordering.

Since anything can be used as index for an item, indices must be always specified when creating a dictionary:

>>> d = {1: 0.5, 'excellent index': math.sin, 0.1: 2}
>>> d[1]
0.5
>>> d['excellent index']
<built-in function sin>
>>> d[0.1] = 3

The "indices" of a dictionary are called keys, and the things they map to are values. Together, each key-value pair is an item.

>>> d.keys()
[1, 0.1, 'excellent index']
>>> d.values()
[0.5, 2, <function math.sin>]
>>> d
{0.1: 2, 1: 0.5, 'excellent index': <function math.sin>}

As you can see, the values of a dictionary can be whatever we like, and need not be the same type of object.

You can see that the order of the keys, values and items we get back are not the same as the order we created the dictionary with. If you run the same example on your own you might get a different ordering. This is what we mean when we define dictionaries as unordered collections: when you iterate over its content, you cannot rely on the ordering.

It is however guaranteed that the n-th item returned by keys() corresponds to the n-th item returned by values(). This allows the following example to work flawlessly:

>>> for key, value in zip(d.keys(), d.values()):
...     print key, ':', value
...
1 : 0.5
0.1 : 3
excellent index : <built-in function sin>

Of course, this could be considerably simpler just by using items(), which gives us tuples of key-value pairs.

>>> for key, value in d.items():
...     print key, ':', value
...
1 : 0.5
0.1 : 3
excellent index : <built-in function sin>

We can create dictionaries from lists of 2-item lists.

>>> dict(enumerate(['a thing', 'another']))
{0: 'a thing', 1: 'another'}

And also with dictionary comprehensions, in a similar manner to list comprehensions, with the additional specification of the key.

>>> {i: i**i for i in range(5) if i != 3}
{0: 1, 1: 1, 2: 4, 4: 256, 5: 3125}

Note that dictionary comprehensions require at least Python 2.7 to work.

Dictionary keys

There’s no restriction on values a dictionary might hold, but there is on keys.

>>> l = [1, 4, 3]
>>> dd = {}
>>> dd[l] = 0
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

In essence, keys must not be mutable. This includes numbers, strings, and tuples, but not lists. This restriction is a trade-off that allows Python to make accessing values in a dictionary by key very fast.

>>> s = "a string"
>>> s.__hash__()
-8411828025894108412

Iteration over dictionaries is over their keys.

>>> for key in d:
...     print key, ':' d[key]
...
1 : 0.5
0.1 : 3
excellent index : <built-in function sin>

We have already seen how to iterate over values (using d.values()) or keys and values simultaneously (using d.items()).

>>> import string
>>> string.ascii_lowercase
'abcdefghijklmnopqrstuvwxyz'

>>> for character in string.ascii_lowercase:
...     print character
...
a
b
...
z

>>> alphabet_map = {i: c for i, c in enumerate(string.ascii_lowercase)}

>>> reverse_map = {c: i for i, c in alphabet_map.items()}