Chp-11: Dictionaries

Chp-11: Dictionaries#

Chapter Objectives

By the end of this chapter, the student should be able to:

Explain the purpose and role of dictionaries.
Recognize the key-value pair structure of dictionaries.
Create and initialize dictionaries in different ways.
Implement dictionaries to efficiently organize and access data.
Apply dictionary methods.
Use loops to iterate through dictionary keys, values, and pairs.
Use dictionary comprehensions.
Apply dictionaries to solve real-world problems.

Dictionaries#

These are a more general form of lists. The indexes of lists are integers starting from 0, whereas the indexes, called keys in dictionaries, can be chosen from different types.

Its elements are pairs of the form key:value.
Dictionaries are created by using curly brackets, like sets, by using key:value pairs and : in between.
Keys are like indexes, and values can be accessed by using square brackets in the form of dictionary_name[key].
Keys must be immutable, like strings, numbers, and tuples.
- A list cannot be a key of a dictionary.
Values can be any type, including strings, numbers, booleans, tuples, lists, and dictionaries.
Dictionary pairs are ordered.
If there are two pairs with the same key, then the later pair will overwrite the former one.
Dictionaries are mutable, so they can be modified.
Since dictionaries can be modified, they have a large number of methods.
The len() function returns the number of pairs.
The built-in dict() function can be used to create dictionaries from structures that have pairs.
{} is an empty dictionary.
- An empty set is set().

Create Dictionaries#

# empty dictionary
empty_dict = {}

print(f'Empty dictionary   : {empty_dict}')
print(f'Type of empty_dict: {type(empty_dict)}')

Empty dictionary   : {}
Type of empty_dict: <class 'dict'>

# empty dictionary with dict()
empty_dict = dict()

print(f'Empty dictionary   : {empty_dict}')
print(f'Type of empty_dict: {type(empty_dict)}')

Empty dictionary   : {}
Type of empty_dict: <class 'dict'>

# three pairs
# keys: 'Math', 'Chemistry', 'History'
# values: 80, 70, 65

grades = {'Math':80, 'Chemistry':70, 'History':65}

print(grades)

{'Math': 80, 'Chemistry': 70, 'History': 65}

# overwrite first pair of math 

grades = {'Math':80, 'Chemistry':70, 'History':65, 'Math':100}

print(grades)    # The value of 'Math' key is 100 

{'Math': 100, 'Chemistry': 70, 'History': 65}

# values can be lists, tuples

grades = {'Math':[80, 90], 'Chemistry':(70, 100), 'History':65}

print(grades)     

{'Math': [80, 90], 'Chemistry': (70, 100), 'History': 65}

# lists can not be a key

grades = {['Math', 'Biology']:80, 'Chemistry':70, 'History':65}   # ERROR

dict()#

The built-in dict() function converts tuples, and lists consists of pairs into a dictionary.

# assignments ----> dict
grades = dict(Math=80, Chemistry=70, History=65)

print(grades)

{'Math': 80, 'Chemistry': 70, 'History': 65}

# tuples of pairs ----> dict

grades_tuple = ( ('Math', 80), ('Chemistry', 70), ('History', 6)) 
grades = dict(grades_tuple)

print(grades)

{'Math': 80, 'Chemistry': 70, 'History': 6}

# lists of pairs ----> dict

grades_list = [ ['Math', 80], ['Chemistry', 70], ['History', 6]] 
grades = dict(grades_list)

print(grades)

{'Math': 80, 'Chemistry': 70, 'History': 6}

len()#

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

grades = {'Math':80, 'Chemistry':70, 'History':65}

print(f'The number of pairs: {len(grades)}')

The number of pairs: 3

in & not in#

in tests whether a given term is a key of a dictionary.
not in tests whether a given term is not a key of a dictionary.
Both of them return boolean values, True or False.

grades = {'Math':80, 'Chemistry':70, 'History':65}

print(f' Math is     a key of grades: {"Math"  in grades}' )      # use " instead of ' in f-strings 
print(f' Math is not a key of grades: {"Math"  not in grades}' )

 Math is     a key of grades: True
 Math is not a key of grades: False

grades = {'Math':80, 'Chemistry':70, 'History':65}

print(f' Biology is     a key of grades: {"Biology"  in grades}' )      # use " instead of ' in f-strings 
print(f' Biology is not a key of grades: {"Biology"  not in grades}' )

 Biology is     a key of grades: False
 Biology is not a key of grades: True

Mutable#

Unlike strings and tuples, and like lists, dictionaries are mutable, which means they can be modified.

New pairs can be added, and existing pairs can be modified.

Add a new pair#

Use square brackets in the form of dictionary_name[new_key] = new_value.

grades = {'Math':80, 'Chemistry':70, 'History':65}
print(f'grades dictionary before adding a new pair: {grades}')

# add the pair 'Eglish':99
grades['English'] = 99

print(f'grades dictionary after  adding a new pair: {grades}')

grades dictionary before adding a new pair: {'Math': 80, 'Chemistry': 70, 'History': 65}
grades dictionary after  adding a new pair: {'Math': 80, 'Chemistry': 70, 'History': 65, 'English': 99}

Change a Value#

Use square brackets in the form of dictionary_name[key] = new_value.

grades = {'Math':80, 'Chemistry':70, 'History':65}
print(f'grades dictionary before changing a value: {grades}')

# change the value of 'Chemistry'
grades['Chemistry'] = 85

print(f'grades dictionary after adding a new pair: {grades}')

grades dictionary before changing a value: {'Math': 80, 'Chemistry': 70, 'History': 65}
grades dictionary after adding a new pair: {'Math': 80, 'Chemistry': 85, 'History': 65}

Delete a pair#

Use del in the form of del dictionary_name[key].

grades = {'Math':80, 'Chemistry':70, 'History':65}
print(f'grades dictionary before deleting a value: {grades}')

# delete 'Chemistry':70 pair
del grades['Chemistry'] 

print(f'grades dictionary after  deleting a  pair: {grades}')

grades dictionary before deleting a value: {'Math': 80, 'Chemistry': 70, 'History': 65}
grades dictionary after  deleting a  pair: {'Math': 80, 'History': 65}

Dictionary Methods#

Except for the magic methods (the ones with underscores), there are 11 methods for dictionaries.

You can run help(dict) for more details.

# methods of dictionaries
# dir() returns a list

print(dir(dict))

['__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__ior__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__ror__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']

# non magic methods by using slicing
print(dir(dict)[-11:])

['clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']

clear()#

It removes all pairs from the dictionary, making it an empty dictionary.

grades = {'Math':80, 'Chemistry':70, 'History':65}
print(f'grades dictionary before using clear(): {grades}')

# remove all elements of grades dictionary
grades.clear()

print(f'grades dictionary after  using clear(): {grades}')

grades dictionary before using clear(): {'Math': 80, 'Chemistry': 70, 'History': 65}
grades dictionary after  using clear(): {}

copy()#

It returns a new dictionary with the same pairs.

grades = {'Math':80, 'Chemistry':70, 'History':65}
print(f'grades dictionary     : {grades}')

# copy all elements of grades dictionary
grades_copy = grades.copy()

print(f'grades_copy dictionary: {grades}')

grades dictionary     : {'Math': 80, 'Chemistry': 70, 'History': 65}
grades_copy dictionary: {'Math': 80, 'Chemistry': 70, 'History': 65}

get()#

It takes a key and a default value.

If the given key exists in the dictionary, get() returns the corresponding value; otherwise, it returns the default value.
Its purpose is to prevent errors for non-existing key-value pairs.

grades = {'Math':80, 'Chemistry':70, 'History':65}
print(f'grades dictionary    : {grades}')

# value corresponding to 'Math' key 
val =  grades.get('Math', 'Does Not Exist')    # Math key exist so get returns 80 not 'Does Not Exist'

print(f'The value of Math key: {val}')

grades dictionary    : {'Math': 80, 'Chemistry': 70, 'History': 65}
The value of Math key: 80

In the following code, since the key ‘Biology’ does not exist get() returns the default value ‘Does Not Exist’.

grades = {'Math':80, 'Chemistry':70, 'History':65}
print(f'grades dictionary       : {grades}')

# value corresponding to the key 'Biology'  
val =  grades.get('Biology', 'Does Not Exist')  

print(f'The value of Biology key: {val}')

grades dictionary       : {'Math': 80, 'Chemistry': 70, 'History': 65}
The value of Biology key: Does Not Exist

items()#

It returns the pairs of a dictionary as a tuple in a data structure called dict_items.

grades = {'Math':80, 'Chemistry':70, 'History':65}

print(f'Items: {grades.items()}')
print(f'Type : {type(grades.items())}')

Items: dict_items([('Math', 80), ('Chemistry', 70), ('History', 65)])
Type : <class 'dict_items'>

keys()#

It returns the keys of a dictionary in a data structure called dict_keys.

grades = {'Math':80, 'Chemistry':70, 'History':65}

print(f'Keys: {grades.keys()}')
print(f'Type: {type(grades.keys())}')

Keys: dict_keys(['Math', 'Chemistry', 'History'])
Type: <class 'dict_keys'>

pop()#

It removes a key-value pair for a given key and returns the value removed.

grades = {'Math':80, 'Chemistry':70, 'History':65}
print(f'grades dictionary before using pop(): {grades}')

# remove the pair 'Chemistry':70 
val_removed = grades.pop('Chemistry')

print(f'grades dictionary after  using pop(): {grades}')
print(f'Removed value                       : {val_removed}')

grades dictionary before using pop(): {'Math': 80, 'Chemistry': 70, 'History': 65}
grades dictionary after  using pop(): {'Math': 80, 'History': 65}
Removed value                       : 70

popitem()#

It removes the last key-value pair and returns the key-value pair that is removed as a tuple.

grades = {'Math':80, 'Chemistry':70, 'History':65, 'English':100}
print(f'grades dictionary before using pop(): {grades}')

# remove the pair 'English':100
tuple_removed = grades.popitem()

print(f'grades dictionary after  using pop(): {grades}')
print(f'Removed pair                        : {tuple_removed}')

grades dictionary before using pop(): {'Math': 80, 'Chemistry': 70, 'History': 65, 'English': 100}
grades dictionary after  using pop(): {'Math': 80, 'Chemistry': 70, 'History': 65}
Removed pair                        : ('English', 100)

update()#

It adds pairs of the second dictionary to the first one.

dict1 = {'A':1, 'B':2, 'C':3}
dict2 = {'D':4, 'E':5, 'F':6}
print(f'dict1 before update: {dict1}')

dict1.update(dict2)

print(f'dict1 after  update: {dict1}')

dict1 before update: {'A': 1, 'B': 2, 'C': 3}
dict1 after  update: {'A': 1, 'B': 2, 'C': 3, 'D': 4, 'E': 5, 'F': 6}

values()#

It returns the values of a dictionary in a data structure called dict_values.

grades = {'Math':80, 'Chemistry':70, 'History':65}

print(f'Values: {grades.values()}')
print(f'Type  : {type(grades.items())}')

Values: dict_values([80, 70, 65])
Type  : <class 'dict_items'>

Iterations and Dictionaries#

You can use keys, values, or (keys, values) with for loops.

keys(), values(), and items() methods return the keys, values, and (keys, values) respectively.
Which one is better to use depends on what you need.

# use keys
grades = {'Math':80, 'Chemistry':70, 'History':65}

for key in grades.keys():          
    print(key)

Math
Chemistry
History

# use values
grades = {'Math':80, 'Chemistry':70, 'History':65}

for value in grades.values():          
    print(value)

80
70
65

# use items for (key,value) pairs
grades = {'Math':80, 'Chemistry':70, 'History':65}

for key,value in grades.items():          
    print(key,value)

Math 80
Chemistry 70
History 65

You can also access the values by using the keys.

# use keys to access values
grades = {'Math':80, 'Chemistry':70, 'History':65}

for key in grades.keys():          
    print(grades[key])

80
70
65

Dictionary Comprehension#

It is a fast and concise way of creating dictionaries in a single line using for loops and if statements.

It is similar to list comprehensions.
It is in the form of: {expression for item in sequence}
- Here, the expression represents the key:value pairs of the dictionary being constructed.
An if statement can also be included in a dictionary comprehension in the form of: [expression for item in sequence if condition]

Example

The following code constructs a dictionary with key:value pairs where keys are the numbers between 1 and 5, and values are the cubes of the keys.

cube_dict = {i:i**3 for i in range(1,6)}   # i is a key, i**3 is a value in the expression

print(cube_dict)

{1: 1, 2: 8, 3: 27, 4: 64, 5: 125}

The following code constructs a dictionary with key:value pairs where keys are the even numbers between 1 and 5, and values are the cubes of the keys.

cube_dict = {i:i**3 for i in range(1,6) if i%2==0}  

print(cube_dict)

{2: 8, 4: 64}

Examples#

Frequency#

Write a program that constructs a dictionary such that:

keys represent the unique letters in the given list below
values represent the number of occurrences of each unique letter.

letters = ['a','b','c','a','b','c','d','e','a']

Solution:

frequency = {}
for i in letters:
    frequency[i] = frequency.get(i,0)+1

frequency

{'a': 3, 'b': 2, 'c': 2, 'd': 1, 'e': 1}

Word Lengths#