Dictionaries in Python

You can define a dictionary by enclosing a comma-separated list of key-value pairs in curly braces ({}).

A colon (:) separates each key from its associated value:

The following defines a dictionary that maps countries to their capitals.

You can also construct a dictionary with the built-in dict() function. The argument to dict() should be a sequence of key-value pairs. A list of tuples works well for this...

world_map dictionary can then also be defined this way:

If the key values are simple strings, they can be specified as keyword arguments. So here is another way to define world_map dict.

Once you’ve defined a dictionary, you can display its contents, the same as you can do for a list.

As we see above, the entries in the dictionary appear in the order they were defined. But the order is not guaranteed when we retrieve these elements from the dictionary.

Accessing Python Dictionary Values

A value is retrieved from a dictionary by specifying its corresponding key in square brackets ([]) as shown below.

If you refer to a key that is not in the dictionary, Python raises an exception:

Also dictionary elements can not be accessed by numerical index.

Adding an entry to an existing dictionary is simply a matter of assigning a new key and value:

Python Update Dictionary

If you want to update an entry, you can just assign a new value to an existing key:

Python Remove Entry in Dictionary

To delete an entry, use the del statement as shown below.

Dictionary Keys vs List Indices

Note in the above snippets that Dictionary raises the same exception "KeyError" when a dictionary is accessed with either an undefined key or by a numeric index.

Note that both of the above errors are same. In both cases, it is "KeyError". [1] is not index but it is a key.

Look at below example where I am using integers as keys in Python dictionaries.

In the expressions world_map[1], fruits[0], and fruits[2], the numbers in square brackets are keys not indices. Also since these are keys, the order of items in the dictionary is not maintained. If we change the order of these keys, let us say in reverse order, you would still get the same values using the same keys:

The syntax may look similar, but you can’t treat a dictionary like a list:

Building a Python Dictionary Incrementally

In many cases, we dont know the content of Python dictionaries in advance and need to fill up the key,values as the need arises. For that we need to first define a empty dictionary and then you can add new keys and values one at a time. Let us go through an example to illusterate that.

Retrieving the values in the sublist or subdictionary requires an additional index or key:

Python Dictionary with Different Key Types

Python dictionaries are very robust, they can be of any type.

In restaurant dict, some of the values are strings, one is an integer, one is a list, and one is another dictionary.

Note in below example, our keys are of type integer, float, and Boolean.

You can even use built-in Python objects like types and functions.

Duplicate Keys in Python Dictionary

However, there are couple of things to watch for when we are dealing with Python dictionaries. Python dictionaries don't allow duplicate dictionaries. Every key in Python dictionary has a value. If we try to enter the same key in Python dictionary, the key value is overwritten. Let us show this with an example.

Also if you define the same key again while defining a Python dictionary. Dictionary key's value is overwritten by the latter. Checkout following code to learn this concept.

Note in the above example, 'Nigeria' key's value is 'Abuja' not 'Lagos'.

Tuple as Python Dictionary Keys

A tuple can also be a dictionary key, because tuples are immutable:

However, neither a list nor another dictionary can serve as a dictionary key, because lists and dictionaries are mutable:

Note: Why does the above error message say unhashable

Python keys should be hashable that means Python should be able to generate a fixed unique value using its built-in hash() function. If the key is not hashable, then Python throws an exception.

Restrictions on Dictionary Values

On the contrary, there are no restrictions on Python dictionary values. Dictionary values can be of any type and can have duplicate values. Let us understand using an example.

Below code checks if the key values are same.

Operators and Built-in Functions

For example, the "in" and "not in" operators return True or False according to whether the specified operand occurs as a key in the dictionary.

You can use the "in" operator to avoid raising an error when trying to access a key that is not in the dictionary.

The len() function returns the number of key-value pairs in a dictionary.

Built-in Dictionary Methods

There are many Python built-in dictioary methods available. In this section, we will go over the following methods.

• dict.clear()
• dict.get()
• dict.items()
• dict.keys()
• dict.values()
• dict.pop()
• dict.popitem()
• dict.update()

dict.clear()

clear() empties dictionary of all key-value pairs.

dict.get()

get() searches dictionary for 'key' and returns the associated value if it is found. If 'key' is not found, it returns None.

If 'key' is not found and the optional 'default' argument is specified, then default value is returned instead of None as shown below.

dict.items()

items() returns a list of tuples containing the key-value pairs. The first item in each tuple is the key, and the second item is the key’s value:

dict.keys()

keys() returns a list of all keys.

dict.values()

values() returns a list of all values.

dict.pop()

If 'key' is present in dictionary, pop('key') removes 'key' and returns its associated value.

pop('key') raises a KeyError exception if 'key' is not in dictionary:

If 'key' is not in dictionary, and the optional 'default' argument is specified, then default value is returned, and no exception is raised.

dict.popitem()

popitem() removes the last key-value pair added to dictionary and returns it as a tuple.

If dictionary is empty, popitem() raises a KeyError exception

dict.update()

'obj' can be sequence of key-value pairs or can be list of tuples.