6.3 Dictionaries
Besides lists, dictionaries are
perhaps the most flexible built-in data type in Python. If you think
of lists as ordered collections of objects, dictionaries are
unordered collections; their chief distinction is that items are
stored and fetched in dictionaries by key,
instead of positional offset.
Being a built-in type, dictionaries can replace many of the searching
algorithms and data structures you might have to implement manually
in lower-level languages—indexing a dictionary is a very fast
search operation. Dictionaries also sometimes do the work of records
and symbol tables used in other languages, can represent sparse
(mostly empty) data structures, and much more. In terms of their main
properties, dictionaries are:
- Accessed by key, not offset
-
Dictionaries are sometimes called associative arrays or hashes. They
associate a set of values with keys, so that you can fetch an item
out of a dictionary using the key that stores it. You use the same
indexing operation to get components in a dictionary, but the index
takes the form of a key, not a relative offset.
- Unordered collections of arbitrary objects
-
Unlike lists, items stored in a dictionary aren't
kept in any particular order; in fact, Python randomizes their order
in order to provide quick lookup. Keys provide the symbolic (not
physical) location of items in a dictionary.
- Variable length, heterogeneous, arbitrarily nestable
-
Like lists, dictionaries can grow and shrink in place (without making
a copy), they can contain objects of any type, and support nesting to
any depth (they can contain lists, other dictionaries, and so on).
- Of the category mutable mapping
-
Dictionaries can be changed in place by assigning to indexes, but
don't support the sequence operations that work on
strings and lists. Because dictionaries are unordered collections,
operations that depend on a fixed order (e.g., concatenation,
slicing) don't make sense. Instead, dictionaries are
the only built-in representative of the mapping type
category—objects that map keys to values.
- Tables of object references (hash tables)
-
If lists are arrays of object references, dictionaries are unordered
tables of object references. Internally, dictionaries are implemented
as hash tables (data structures that support very fast retrieval),
which start small and grow on demand. Moreover, Python employs
optimized hashing algorithms to find keys, so retrieval is very fast.
Dictionaries store object references (not copies), just like lists.
Table 6-2 summarizes some of the most common
dictionary operations (see the library manual for a complete list).
Dictionaries are written as a series of key:value
pairs, separated by commas, and enclosed in curly braces. An empty dictionary is an empty set of
braces, and
dictionaries can be
nested by writing one as a value inside another dictionary, or within
a list or tuple.
Table 6-2. Common dictionary
literals and operations|
D1 = { }
|
Empty dictionary
|
D2 = {'spam': 2, 'eggs': 3}
|
Two-item dictionary
|
D3 = {'food': {'ham': 1, 'egg': 2}}
|
Nesting
|
D2['eggs']d3['food']['ham']
|
Indexing by key
|
D2.has_key('eggs'), 'eggs' in D2D2.keys( )D2.values(
)D2.copy( )D2.get(key, default)D2.update(D1)
|
Methods: membership test, keys list, values list, copies, defaults,
merge, etc.
|
len(d1)
|
Length (number stored entries)
|
D2[key] = 42del d2[key]
|
Adding/changing, deleting
|
D4 = dict(zip(keyslist, valslist))
|
Construction (Chapter 10)
|
|