Dictionaries in Python programming for btech students

Dictionaries
Dictionaries are ordered collections of unique values stored in (Key-Value) pairs.
In Python version 3.7 and onwards, dictionaries are ordered. In Python 3.6 and earlier,
dictionaries are unordered.
Python dictionary represents a mapping between a key and a value. In simple terms, a
Python dictionary can store pairs of keys and values. Each key is linked to a specific
value. Once stored in a dictionary, you can later obtain the value using just the key.
Characteristics of dictionaries
 Unordered (In Python 3.6 and lower version): The items in dictionaries are stored
without any index value, which is typically a range of numbers. They are stored
as Key-Value pairs, and the keys are their index, which will not be in any
sequence.
 Ordered (In Python 3.7 and higher version): dictionaries are ordered, which
means that the items have a defined order, and that order will not change. A
simple Hash Table consists of key-value pair arranged in pseudo-random order
based on the calculations from Hash Function.

 Unique: As mentioned above, each value has a Key; the Keys in Dictionaries
should be unique. If we store any value with a Key that already exists, then the
most recent value will replace the old value.
 Mutable: The dictionaries are changeable collections, which implies that we can
add or remove items after the creation.
Creating a dictionary
There are following three ways to create a dictionary.
 Using curly brackets: The dictionaries are created by enclosing the comma-
separated Key: Value pairs inside the {} curly brackets. The colon ‘:‘ is used to
separate the key and value in a pair.
 Using dict() constructor: Create a dictionary by passing the comma-
separated key: value pairs inside the dict().
 Using sequence having each item as a pair (key-value)
Let’s see each one of them with an example.
Example:
# create a dictionary using {}
person = {"name": "Jessa", "country": "USA", "telephone": 1178}
print(person)
# output {'name': 'Jessa', 'country': 'USA', 'telephone': 1178}
# create a dictionary using dict()
person = dict({"name": "Jessa", "country": "USA", "telephone": 1178})
print(person)
# output {'name': 'Jessa', 'country': 'USA', 'telephone': 1178}
# create a dictionary from sequence having each item as a pair
person = dict([("name", "Mark"), ("country", "USA"), ("telephone", 1178)])
print(person)
# create dictionary with mixed keys keys

# first key is string and second is an integer
sample_dict = {"name": "Jessa", 10: "Mobile"}
print(sample_dict)
# output {'name': 'Jessa', 10: 'Mobile'}
# create dictionary with value as a list
person = {"name": "Jessa", "telephones": [1178, 2563, 4569]}
print(person)
# output {'name': 'Jessa', 'telephones': [1178, 2563, 4569]}
Empty Dictionary
When we create a dictionary without any elements inside the curly brackets then it will
be an empty dictionary.
emptydict = {}
print(type(emptydict))
# Output class 'dict'
Note:
 A dictionary value can be of any type, and duplicates are allowed in that.
 Keys in the dictionary must be unique and of immutable types like string,
numbers, or tuples.
Accessing elements of a dictionary
There are two different ways to access the elements of a dictionary.
1. Retrieve value using the key name inside the [] square brackets
2. Retrieve value by passing key name as a parameter to the get() method of a
dictionary.

Example
# create a dictionary named person
# access value using key name in []
print(person['name'])
# Output 'Jessa'
# get key value using key name in get()
print(person.get('telephone'))
# Output 1178
As we can see in the output, we retrieved the value ‘Jessa’ using key ‘name” and value
1178 using its Key ‘telephone’.
Get all keys and values
Use the following dictionary methods to retrieve all key and values at once
Method Description
keys() Returns the list of all keys present in the dictionary.
values() Returns the list of all values present in the dictionary
items() Returns all the items present in the dictionary. Each item will be inside a tuple as a key-value pair.
We can assign each method’s output to a separate variable and use that for further
computations if required.

Example
# Get all keys
print(person.keys())
# output dict_keys(['name', 'country', 'telephone'])
print(type(person.keys()))
# Output class 'dict_keys'
# Get all values
print(person.values())
# output dict_values(['Jessa', 'USA', 1178])
print(type(person.values()))
# Output class 'dict_values'
# Get all key-value pair
print(person.items())
# output dict_items([('name', 'Jessa'), ('country', 'USA'), ('telephone', 1178)])
print(type(person.items()))
# Output class 'dict_items'
Iterating a dictionary
We can iterate through a dictionary using a for-loop and access the individual keys
and their corresponding values. Let us see this with an example.

# Iterating the dictionary using for-loop
print('key', ':', 'value')
for key in person:
print(key, ':', person[key])
# using items() method
print('key', ':', 'value')
for key_value in person.items():
# first is key, and second is value
print(key_value[0], key_value[1])
Output
key : value
name : Jessa
country : USA
telephone : 1178
key : value
name Jessa
country USA
telephone 1178
Find a length of a dictionary
In order to find the number of items in a dictionary, we can use the len() function.
Let us consider the personal details dictionary which we created in the above example
and find its length.

# count number of keys present in a dictionary
print(len(person))
# output 3
Adding items to the dictionary
We can add new items to the dictionary using the following two ways.
 Using key-value assignment: Using a simple assignment statement where
value can be assigned directly to the new key.
 Using update() Method: In this method, the item passed inside the update()
method will be inserted into the dictionary. The item can be another dictionary
or any iterable like a tuple of key-value pairs.
Now, Let’s see how to add two new keys to the dictionary.
Example
person = {"name": "Jessa", 'country': "USA", "telephone": 1178}
# update dictionary by adding 2 new keys
person["weight"] = 50
person.update({"height": 6})
# print the updated dictionary
print(person)
# output {'name': 'Jessa', 'country': 'USA', 'telephone': 1178, 'weight': 50, 'height': 6}
Note: We can also add more than one key using the update() method.
Example
person = {"name": "Jessa", 'country': "USA"}
# Adding 2 new keys at once
# pass new keys as dict

person.update({"weight": 50, "height": 6})
print(person)
# output {'name': 'Jessa', 'country': 'USA', 'weight': 50, 'height': 6}
# pass new keys as as list of tuple
person.update([("city", "Texas"), ("company", "Google",)])
print(person)
# output {'name': 'Jessa', 'country': 'USA', 'weight': 50, 'height': 6, 'city': 'Texas',
'company': 'Google'}
Set default value to a key
Using the setdefault() method default value can be assigned to a key in the
dictionary. In case the key doesn’t exist already, then the key will be inserted into the
dictionary, and the value becomes the default value, and None will be inserted if a
value is not mentioned.
In case the key exists, then it will return the value of a key.
Example
person_details = {"name": "Jessa", "country": "USA", "telephone": 1178}
# set default value if key doesn't exists
person_details.setdefault('state', 'Texas')
# key doesn't exists and value not mentioned. default None
person_details.setdefault("zip")
# key exists and value mentioned. doesn't change value
person_details.setdefault('country', 'Canada')
# Display dictionary

for key, value in person_details.items():
print(key, ':', value)
Output
name : Jessa
country : USA
telephone : 1178
state : Texas
zip : None
Note: As seen in the above example the value of the setdefault() method has no effect
on the ‘country’ as the key already exists.
Modify the values of the dictionary keys
We can modify the values of the existing dictionary keys using the following two ways.
 Using key name: We can directly assign new values by using its key name. The
key name will be the existing one and we can mention the new value.
 Using update() method: We can use the update method by passing the key-
value pair to change the value. Here the key name will be the existing one, and
the value to be updated will be new.
Example
person = {"name": "Jessa", "country": "USA"}
# updating the country name
person["country"] = "Canada"
# print the updated country
print(person['country'])
# Output 'Canada'
# updating the country name using update() method

person.update({"country": "USA"})
# print the updated country
print(person['country'])
# Output 'USA'
Removing items from the dictionary
There are several methods to remove items from the dictionary. Whether we want to
remove the single item or the last inserted item or delete the entire dictionary, we can
choose the method to be used.
Use the following dictionary methods to remove keys from a dictionary.
Method Description
pop(key[,d])
Return and removes the item with the key and return its value. If the key is not found, it
raises KeyError.
popitem()
Return and removes the last inserted item from the dictionary. If the dictionary is empty, it
raises KeyError.
del key The del keyword will delete the item with the key that is passed
clear() Removes all items from the dictionary. Empty the dictionary
del
dict_name
Delete the entire dictionary
Now, Let’s see how to delete items from a dictionary with an example.
Example
person = {'name': 'Jessa', 'country': 'USA', 'telephone': 1178, 'weight': 50, 'height': 6}
# Remove last inserted item from the dictionary
deleted_item = person.popitem()

print(deleted_item) # output ('height', 6)
# display updated dictionary
print(person)
# Output {'name': 'Jessa', 'country': 'USA', 'telephone': 1178, 'weight': 50}
# Remove key 'telephone' from the dictionary
deleted_item = person.pop('telephone')
print(deleted_item) # output 1178
print(person)
# Output {'name': 'Jessa', 'country': 'USA', 'weight': 50}
# delete key 'weight'
del person['weight']
print(person)
# Output {'name': 'Jessa', 'country': 'USA'}
# remove all item (key-values) from dict
person.clear()
print(person) # {}
# Delete the entire dictionary
del person

Checking if a key exists
In order to check whether a particular key exists in a dictionary, we can use
the keys() method and in operator. We can use the in operator to check whether
the key is present in the list of keys returned by the keys() method.
In this method, we can just check whether our key is present in the list of keys that will
be returned from the keys() method.
Let’s check whether the ‘country’ key exists and prints its value if found.
person = {'name': 'Jessa', 'country': 'USA', 'telephone': 1178}
# Get the list of keys and check if 'country' key is present
key_name = 'country'
if key_name in person.keys():
print("country name is", person[key_name])
else:
print("Key not found")
# Output country name is USA
Join two dictionary
We can add two dictionaries using the update() method or unpacking arbitrary
keywords operator **. Let us see each one with an example.
 Using update() method
In this method, the dictionary to be added will be passed as the argument to the
update() method and the updated dictionary will have items of both the dictionaries.
Let’s see how to merge the second dictionary into the first dictionary

Example
dict1 = {'Jessa': 70, 'Arul': 80, 'Emma': 55}
dict2 = {'Kelly': 68, 'Harry': 50, 'Olivia': 66}
# copy second dictionary into first dictionary
dict1.update(dict2)
# printing the updated dictionary
print(dict1)
# output {'Jessa': 70, 'Arul': 80, 'Emma': 55, 'Kelly': 68, 'Harry': 50, 'Olivia': 66}
As seen in the above example the items of both the dictionaries have been updated
and the dict1 will have the items from both the dictionaries.
 Using **kwargs to unpack
We can unpack any number of dictionary and add their contents to another dictionary
using **kwargs. In this way, we can add multiple length arguments to one dictionary
in a single statement.
student_dict1 = {'Aadya': 1, 'Arul': 2, }
student_dict2 = {'Harry': 5, 'Olivia': 6}
student_dict3 = {'Nancy': 7, 'Perry': 9}
# join three dictionaries
student_dict = {**student_dict1, **student_dict2, **student_dict3}
# printing the final Merged dictionary
print(student_dict)
# Output {'Aadya': 1, 'Arul': 2, 'Harry': 5, 'Olivia': 6, 'Nancy': 7, 'Perry': 9}
As seen in the above example the values of all the dictionaries have been merged into
one.

Join two dictionaries having few items in common
Note: One thing to note here is that if both the dictionaries have a common key then
the first dictionary value will be overridden with the second dictionary value.
Example
dict1 = {'Jessa': 70, 'Arul': 80, 'Emma': 55}
dict2 = {'Kelly': 68, 'Harry': 50, 'Emma': 66}
# join two dictionaries with some common items
dict1.update(dict2)
# printing the updated dictionary
print(dict1['Emma'])
# Output 66
As mentioned in the case of the same key in two dictionaries the latest one will override
the old one.
In the above example, both the dictionaries have the key ‘Emma’ So the value
of the second dictionary is used in the final merged dictionary dict1.
Copy a Dictionary
We can create a copy of a dictionary using the following two ways
 Using copy() method.
 Using the dict() constructor
dict1 = {'Jessa': 70, 'Emma': 55}
# Copy dictionary using copy() method
dict2 = dict1.copy()
# printing the new dictionary

print(dict2)
# output {'Jessa': 70, 'Emma': 55}
# Copy dictionary using dict() constructor
dict3 = dict(dict1)
print(dict3)
# Copy dictionary using the output of items() methods
dict4 = dict(dict1.items())
print(dict4)
 Copy using the assignment operator
We can simply use the '=' operator to create a copy.
Note: When you set dict2 = dict1, you are making them refer to the same dict
object, so when you modify one of them, all references associated with that object
reflect the current state of the object. So don’t use the assignment operator to copy
the dictionary instead use the copy() method.
Example
dict1 = {'Jessa': 70, 'Emma': 55}
# Copy dictionary using assignment = operator
dict2 = dict1
# modify dict2
dict2.update({'Jessa': 90})
print(dict2)
# Output {'Jessa': 90, 'Emma': 55}
print(dict1)

# Output {'Jessa': 90, 'Emma': 55}
Nested dictionary
Nested dictionaries are dictionaries that have one or more dictionaries as their
members. It is a collection of many dictionaries in one dictionary.
Let us see an example of creating a nested dictionary ‘Address’ inside a ‘person’
dictionary.
Example
# address dictionary to store person address
address = {"state": "Texas", 'city': 'Houston'}
# dictionary to store person details with address as a nested dictionary
person = {'name': 'Jessa', 'company': 'Google', 'address': address}
# Display dictionary
print("person:", person)
# Get nested dictionary key 'city'
print("City:", person['address']['city'])
# Iterating outer dictionary
print("Person details")
for key, value in person.items():
if key == 'address':
# Iterating through nested dictionary
print("Person Address")
for nested_key, nested_value in value.items():
print(nested_key, ':', nested_value)
else:

print(key, ':', value)
Output
person: {'name': 'Jessa', 'company': 'Google', 'address': {'state': 'Texas', 'city':
'Houston'}}
City: Houston
Person details
name: Jessa
company: Google
Person Address
state: Texas
city : Houston
As we can see in the output we have added one dictionary inside another dictionary.
Add multiple dictionaries inside a single dictionary
Let us see an example of creating multiple nested dictionaries inside a single
dictionary.
In this example, we will create a separate dictionary for each student and in the end,
we will add each student to the ‘class_six’ dictionary. So each student is nothing but a
key in a ‘class_six’ dictionary.
In order to access the nested dictionary values, we have to pass the outer dictionary
key, followed by the individual dictionary key.
For example, class_six['student3']['name']
We can iterate through the individual member dictionaries using nested for-loop with
the outer loop for the outer dictionary and inner loop for retrieving the members of
the collection.
Example
# each dictionary will store data of a single student
jessa = {'name': 'Jessa', 'state': 'Texas', 'city': 'Houston', 'marks': 75}

emma = {'name': 'Emma', 'state': 'Texas', 'city': 'Dallas', 'marks': 60}
kelly = {'name': 'Kelly', 'state': 'Texas', 'city': 'Austin', 'marks': 85}
# Outer dictionary to store all student dictionaries (nested dictionaries)
class_six = {'student1': jessa, 'student2': emma, 'student3': kelly}
# Get student3's name and mark
print("Student 3 name:", class_six['student3']['name'])
print("Student 3 marks:", class_six['student3']['marks'])
# Iterating outer dictionary
print("nClass detailsn")
for key, value in class_six.items():
# Iterating through nested dictionary
# Display each student data
print(key)
for nested_key, nested_value in value.items():
print(nested_key, ':', nested_value)
print('n')
Output
Student 3 name: Kelly
Student 3 marks: 85
Class details
student1
name: Jessa
state: Texas
city: Houston

marks: 75
student2
name: Emma
state: Texas
city: Dallas
marks: 60
student3
name: Kelly
state: Texas
city: Austin
marks : 85
As seen in the above example, we are adding three individual dictionaries inside a
single dictionary.
Sort dictionary
The built-in method sorted() will sort the keys in the dictionary and returns a sorted
list. In case we want to sort the values we can first get the values using
the values() and then sort them.
Example
dict1 = {'c': 45, 'b': 95, 'a': 35}
# sorting dictionary by keys
print(sorted(dict1.items()))
# Output [('a', 35), ('b', 95), ('c', 45)]
# sort dict eys
print(sorted(dict1))

# output ['a', 'b', 'c']
# sort dictionary values
print(sorted(dict1.values()))
# output [35, 45, 95]
As we can see in the above example the keys are sorted in the first function call and in
the second the values are sorted after the values() method call.
Dictionary comprehension
Dictionary comprehension is one way of creating the dictionary where the values of
the key values are generated in a for-loop and we can filter the items to be added to
the dictionary with an optional if condition. The general syntax is as follows.
output_dictionary = {key : value for key,value in iterable [if key,value condition1]}
Let us see this with a few examples.
# calculate the square of each even number from a list and store in dict
numbers = [1, 3, 5, 2, 8]
even_squares = {x: x ** 2 for x in numbers if x % 2 == 0}
print(even_squares)
# output {2: 4, 8: 64}
Here in this example, we can see that a dictionary is created with an input list (any
iterable can be given), the numbers from the list being the key and the value is the
square of a number.
We can even have two different iterables for the key and value and zip them inside
the for loop to create a dictionary.
telephone_book = [1178, 4020, 5786]
persons = ['Jessa', 'Emma', 'Kelly']
telephone_Directory = {key: value for key, value in zip(persons, telephone_book)}
print(telephone_Directory)

# Output {'Jessa': 1178, 'Emma': 4020, 'Kelly': 5786}
In the above example, we are creating a telephone directory with separate tuples for
the key which is the name, and the telephone number which is the value. We are
zipping both the tuples together inside the for a loop.
Built-in functions with dictionary
 max() and min()
As the name suggests the max() and min() functions will return the keys with
maximum and minimum values in a dictionary respectively. Only the keys are
considered here not their corresponding values.
dict = {1:'aaa',2:'bbb',3:'AAA'}
print('Maximum Key',max(dict)) # 3
print('Minimum Key',min(dict)) # 1
As we can see max() and min() considered the keys to finding the maximum and
minimum values respectively.
 all()
When the built-in function all() is used with the dictionary the return value will be
true in the case of all – true keys and false in case one of the keys is false.
Few things to note here are
 Only key values should be true
 The key values can be either True or 1 or ‘0’
 0 and False in Key will return false
 An empty dictionary will return true.
#dictionary with both 'true' keys
dict1 = {1:'True',1:'False'}
#dictionary with one false key

#empty dictionary
dict3= {}
#'0' is true actually
dict4 = {'0':False}
print('All True Keys::',all(dict1))
print('One False Key',all(dict2))
print('Empty Dictionary',all(dict3))
print('With 0 in single quotes',all(dict4))
Output
All True Keys:: True
One False Key False
Empty Dictionary True
With 0 in single quotes True
 any()
any() function will return true if dictionary keys contain anyone false which could be
0 or false. Let us see what any() method will return for the above cases.
#dictionary with both 'true' keys
#dictionary with one false key
#empty dictionary
dict3= {}
#'0' is true actually
dict4 = {'0':False}

#all false
dict5 = {0:False}
print('All True Keys::',any(dict1))
print('One False Key ::',any(dict2))
print('Empty Dictionary ::',any(dict3))
print('With 0 in single quotes ::',any(dict4))
print('all false :: ',any(dict5))
Output
All True Keys:: True
One False Key :: True
Empty Dictionary :: False
With 0 in single quotes :: True
all false :: False
As we can see this method returns true even if there is one true value and one thing
to note here is that it returns false for empty dictionary and all false dictionary.
When to use dictionaries?
Dictionaries are items stored in Key-Value pairs that actually use the mapping format
to actually store the values. It uses hashing internally for this. For retrieving a value
with its key, the time taken will be very less as O(1).
For example, consider the phone lookup where it is very easy and fast to find the phone
number (value) when we know the name (key) associated with it.
So to associate values with keys in a more optimized format and to retrieve them
efficiently using that key, later on, dictionaries could be used.

Summary of dictionary operations
Assume d1 and d2 are dictionaries with following items.
d1 = {'a': 10, 'b': 20, 'c': 30}
d2 = {'d': 40, 'e': 50, 'f': 60}
Operations Description
dict({'a': 10, 'b': 20}) Create a dictionary using a dict() constructor.
d2 = {} Create an empty dictionary.
d1.get('a') Retrieve value using the key name a.
d1.keys() Returns a list of keys present in the dictionary.
d1.values() Returns a list with all the values in the dictionary.
d1.items()
Returns a list of all the items in the dictionary with each key-value pair inside
a tuple.
len(d1) Returns number of items in a dictionary.
d1['d'] = 40 Update dictionary by adding a new key.
d1.update({'e': 50, 'f':
60})
Add multiple keys to the dictionary.
d1.setdefault('g', 70) Set the default value if a key doesn’t exist.
d1['b'] = 100 Modify the values of the existing key.
d1.pop('b') Remove the key b from the dictionary.
d1.popitem() Remove any random item from a dictionary.
d1.clear() Removes all items from the dictionary.
'key' in d1.keys() Check if a key exists in a dictionary.
d1.update(d2) Add all items of dictionary d2 into d1.

Operations Description
d3= {**d1, **d2} Join two dictionaries.
d2 = d1.copy() Copy dictionary d1 into d2.
max(d1) Returns the key with the maximum value in the dictionary d1
min(d1) Returns the key with the minimum value in the dictionary d1

Dictionaries in Python programming for btech students

More Related Content

Similar to Dictionaries in Python programming for btech students (20)

Recently uploaded (20)

Dictionaries in Python programming for btech students