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.
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.

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.
Table of contents
- Characteristics of dictionaries
- Creating a dictionary
- Accessing elements of a dictionary
- Find a length of a dictionary
- Adding items to the dictionary
- Modify the values of the dictionary keys
- Removing items from the dictionary
- Checking if a key exists
- Join two dictionary
- Copy a Dictionary
- Nested dictionary
- Sort dictionary
- Dictionary comprehension
- Python Built-in functions with dictionary
- Summary of dictionary operations
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 thedict()
. - 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.
- Retrieve value using the key name inside the
[]
square brackets - Retrieve value by passing key name as a parameter to the
get()
method of a dictionary.
Example
# create a dictionary named person
person = {"name": "Jessa", "country": "USA", "telephone": 1178}
# 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
person = {"name": "Jessa", "country": "USA", "telephone": 1178}
# 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.
person = {"name": "Jessa", "country": "USA", "telephone": 1178}
# 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.
person = {"name": "Jessa", "country": "USA", "telephone": 1178}
# 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 the updated dictionary
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 the updated dictionary
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 KeyErr or. |
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
# display updated dictionary
print(person)
# Output {'name': 'Jessa', 'country': 'USA', 'weight': 50}
# delete key 'weight'
del person['weight']
# display updated dictionary
print(person)
# Output {'name': 'Jessa', 'country': 'USA'}
# remove all item (key-values) from dict
person.clear()
# display updated dictionary
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)
# output {'Jessa': 70, 'Emma': 55}
# Copy dictionary using the output of items() methods
dict4 = dict(dict1.items())
print(dict4)
# output {'Jessa': 70, 'Emma': 55}
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 details\n")
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.
Python 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
dict2 = {0:'True',1:'False'}
#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
dict1 = {1:'True',1:'False'}
#dictionary with one false key
dict2 = {0:'True',1:'False'}
#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
I want to hear from you. What do you think of this guide on Python dictionaries? Let me know by leaving a comment below.
Also, try to solve the Python dictionary exercise and dictionary Quiz.
Below is the summary of all operations that we learned in this lesson
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 . |
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 |