[5] Python Dictionaries

December 15, 2020

1 Dictionaries
Concept: A dictionary is an object that stores a collection of data. Each element in a dictionary
has two parts: a key and a value. You use a key to locate a specific value.
When you hear the word “dictionary,” you probably think about a large book such as the Merriam-
Webster dictionary, containing words and their definitions. If you want to know the meaning of a
particular word, you locate it in the dictionary to find its definition.
In Python, a dictionary is an object that stores a collection of data. Each element that is stored in
a dictionary has two parts: a key and a value. In fact, dictionary elements are commonly referred
to as key-value pairs. When you want to retrieve a specific value from a dictionary, you use the
key that is associated with that value. This is similar to the process of looking up a word in the
Merriam-Webster dictionary, where the words are keys and the definitions are values.
For example, suppose each employee in a company has an ID number, and we want to write a
program that lets us look up an employee’s name by entering that employee’s ID number. We
could create a dictionary in which each element contains an employee ID number as the key and
that employee’s name as the value. If we know an employee’s ID number, then we can retrieve that
employee’s name.
Another example would be a program that lets us enter a person’s name and gives us that person’s
phone number. The program could use a dictionary in which each element contains a person’s
name as the key and that person’s phone number as the value. If we know a person’s name, then
we can retrieve that person’s phone number.
Note: Key-value pairs are often referred to as mappings because each key is mapped to a value.

1.1 Creating a Dictionary

You can create a dictionary by enclosing the elements inside a set of curly braces ( {} ).An element
consists of a key, followed by a colon, followed by a value. The elements are separated by commas.
The following statement shows an example:

[1]: phonebook = {'Chris':'555−1111', 'Katie':'555−2222', 'Joanne':'555-3333'}

This statement creates a dictionary and assigns it to the phonebook variable. The dictionary
contains the following three elements:
• The first element is ‘Chris’:‘555−1111’. In this element the key is ‘Chris’ and the value is
‘555−1111’.

1
 • The second element is ‘Katie’:‘555−2222’. In this element the key is ‘Katie’ and the value is
‘555−2222’.
• The third element is ‘Joanne’:‘555−3333’. In this element the key is ‘Joanne’ and the value
is ‘555−3333’.
In this example the keys and the values are strings. The values in a dictionary can be objects of
any type, but the keys must be immutable objects. For example, keys can be strings, integers,
floating-point values, or tuples. Keys cannot be lists or any other type of immutable object.

1.2 Retrieving a Value from a Dictionary

The elements in a dictionary are not stored in any particular order. For example, look at the
following interactive session in which a dictionary is created and its elements are displayed:

[2]: phonebook

[2]: {'Chris': '555−1111', 'Katie': '555−2222', 'Joanne': '555-3333'}

Notice that the order in which the elements are displayed is different than the order in which they
were created. This illustrates how dictionaries are not sequences, like lists, tuples, and strings.
As a result, you cannot use a numeric index to retrieve a value by its position from a dictionary.
Instead, you use a key to retrieve a value.
To retrieve a value from a dictionary, you simply write an expression in the following general format:
dictionary_name[key]
KeyError: If the key exists in the dictionary, the expression returns the value that is associated
with the key. If the key does not exist, a KeyError exception is raised. The following interactive
session demonstrates:

[4]: phonebook['Chris']

[4]: '555−1111'

[5]: phonebook['Joanne']

[5]: '555-3333'

[6]: phonebook['Katie']

[6]: '555−2222'

[7]: phonebook['Kathryn']

---------------------------------------------------------------------------
KeyError Traceback (most recent call last)
<ipython-input-7-df7a314d232f> in <module>
----> 1 phonebook['Kathryn']

2
 KeyError: 'Kathryn'

When the expression phonebook[‘Kathryn’] is entered. There is no such key as ‘Kathryn’ in

the phonebook dictionary, so a KeyError exception is raised.
Note: Remember that string comparisons are case sensitive. The expression phonebook[‘katie’]
will not locate the key ‘Katie’ in the dictionary.

1.3 Using the in and not in Operators to Test for a Value in a Dictionary
As previously demonstrated, a KeyError exception is raised if you try to retrieve a value from a
dictionary using a nonexistent key. To prevent such an exception, you can use the in operator to
determine whether a key exists before you try to use it to retrieve a value. The following interactive
session demonstrates:

[8]: if 'Chris' in phonebook:

print(phonebook['Chris'])

555−1111
You can also use the not in operator to determine whether a key does not exist, as demonstrated
in the following session:

[9]: if 'Jhon' not in phonebook:

print("Jhon is not found")

Jhon is not found

1.4 Adding Elements to an Existing Dictionary

Dictionaries are mutable objects. You can add new key-value pairs to a dictionary with an assign-
ment statement in the following general format:
dictionary_name[key] = value
In the general format, dictionary_name is the variable that references the dictionary, and key is
a key. If key already exists in the dictionary, its associated value will be changed to value. If the
key does not exist, it will be added to the dictionary, along with value as its associated value. The
following interactive session demonstrates:

[10]: phonebook['Joe'] = '555−0123'

[11]: phonebook['Chris'] = '555−4444'

[12]: phonebook

[12]: {'Chris': '555−4444',

'Katie': '555−2222',
'Joanne': '555-3333',
'Joe': '555−0123'}

3
 1.5 Deleting Elements
You can delete an existing key-value pair from a dictionary with the del statement. Here is the
general format:
del dictionary_name[key]

[13]: phonebook

[13]: {'Chris': '555−4444',

'Katie': '555−2222',
'Joanne': '555-3333',
'Joe': '555−0123'}

[14]: del phonebook['Chris']

[15]: phonebook

[15]: {'Katie': '555−2222', 'Joanne': '555-3333', 'Joe': '555−0123'}

1.6 Getting the Number of Elements in a Dictionary

You can use the built-in len function to get the number of elements in a dictionary.

[16]: num_items = len(phonebook)

[17]: print("Number of items in the dictionary : ",num_items)

Number of items in the dictionary : 3

1.7 Mixing Data Types in a Dictionary

As previously mentioned, the keys in a dictionary must be immutable objects, but their associated
values can be any type of object. For example, the values can be lists, as demonstrated below:

[18]: test_scores = { 'Kayla' : [88, 92, 100],

'Luis' : [95, 74, 81],
'Sophie' : [72, 88, 91],
'Ethan' : [70, 75, 78] }

[20]: test_scores

[20]: {'Kayla': [88, 92, 100],

'Luis': [95, 74, 81],
'Sophie': [72, 88, 91],
'Ethan': [70, 75, 78]}

[21]: test_scores['Sophie']

[21]: [72, 88, 91]

4
[22]: kayla_scores = test_scores['Kayla']

[23]: print(kayla_scores)

[88, 92, 100]

1.8 Using the for Loop to Iterate over a Dictionary

You can use the for loop in the following general format to iterate over all the keys in a dictionary:
for var in dictionary:
statement

statement

etc.

[24]: phonebook

[24]: {'Katie': '555−2222', 'Joanne': '555-3333', 'Joe': '555−0123'}

[25]: # printing keys

for key in phonebook:
print(key)

Katie
Joanne
Joe

[26]: #printing keys with their values

for key in phonebook:
print(key,phonebook[key])

Katie 555−2222
Joanne 555-3333
Joe 555−0123

1.9 Some Dictionary Methods

Fig:1 Dictionary Methods

1.9.1 The clear Method

The clear method deletes all the elements in a dictionary, leaving the dictionary empty. The
method’s general format is
dictionary.clear()

[27]: #clear all the elements of the dictionary

phonebook.clear()

5
[28]: phonebook

[28]: {}

1.9.2 The get Method

You can use the get method as an alternative to the [] operator for getting a value from a dictionary.
The get method does not raise an exception if the specified key is not found. Here is the method’s
general format:
dictionary.get(key, default)

[29]: phonebook = {'Chris':'555−1111', 'Katie':'555−2222'}

value = phonebook.get('Katie', 'Entry not found')
print(value)

555−2222

[30]: value = phonebook.get('Andy', 'Entry not found')

print(value)

Entry not found

1.9.3 The items Method

The items method returns all of a dictionary’s keys and their associated values. They are returned
as a special type of sequence known as a dictionary view. Each element in the dictionary view is
a tuple, and each tuple contains a key and its associated value.

[31]: phonebook.items()

[31]: dict_items([('Chris', '555−1111'), ('Katie', '555−2222')])

1.9.4 The keys Method

The keys method returns all of a dictionary’s keys as a dictionary view, which is a type of sequence.

[32]: phonebook

[32]: {'Chris': '555−1111', 'Katie': '555−2222'}

[33]: phonebook.keys()

[33]: dict_keys(['Chris', 'Katie'])

1.9.5 The pop Method

The pop method returns the value associated with a specified key and removes that keyvalue pair
from the dictionary. If the key is not found, the method returns a default value. Here is the
method’s general format:

6
 dictionary.pop(key, default)

[34]: phonebook = {'Chris':'555−1111',

'Katie':'555−2222',
'Joanne':'555−3333'}

[35]: phone_num = phonebook.pop('Chris', 'Entry not found')

[36]: phone_num

[36]: '555−1111'

[37]: phonebook # Elements after removing Chris

[37]: {'Katie': '555−2222', 'Joanne': '555−3333'}

[38]: phone_num = phonebook.pop('Andy', 'Element not found')

[39]: phone_num

[39]: 'Element not found'

[40]: phonebook

[40]: {'Katie': '555−2222', 'Joanne': '555−3333'}

1.9.6 The popitem Method

The popitem method returns a randomly selected key-value pair, and it removes that keyvalue pair
from the dictionary. The key-value pair is returned as a tuple. Here is the method’s general format:
dictionary.popitem()
You can use an assignment statement in the following general format to assign the returned key
and value to individual variables:
k, v = dictionary.popitem()

[41]: phonebook = {'Chris':'555−1111',

'Katie':'555−2222',
'Joanne':'555−3333'}

[42]: phonebook

[42]: {'Chris': '555−1111', 'Katie': '555−2222', 'Joanne': '555−3333'}

[43]: key, value = phonebook.popitem()

[44]: print(key,value)

Joanne 555−3333

7
[45]: phonebook

[45]: {'Chris': '555−1111', 'Katie': '555−2222'}

1.9.7 The values Method

The values method returns all a dictionary’s values (without their keys) as a dictionary view, which
is a type of sequence.

[46]: phonebook = {'Chris':'555−1111', 'Katie':'555−2222', 'Joanne':'555−3333'}

[47]: phonebook.values()

[47]: dict_values(['555−1111', '555−2222', '555−3333'])

[ ]: