Dictionaries in Python

5 min read
Arya Sarkar

Python is a versatile and powerful programming language that is widely used for a variety of applications, from web development to scientific computing. One of the key features of Python is its built-in support for data structures such as lists, tuples, and dictionaries. In particular, dictionaries are a powerful tool for managing and manipulating data in Python.

In this article, we will explore the basics of using dictionaries in Python. We will begin by discussing what dictionaries are and how they work, and then we will delve into the various operations we can perform on them.

We will cover topics such as creating and accessing dictionaries, adding and deleting items, iterating over dictionaries, and more.

Creating and Modifying Dictionaries in Python

Dictionaries are a powerful data structure in Python that allows us to store key-value pairs.

They are incredibly flexible and can be used to represent complex data structures such as databases, graphs, and more.

In Python, we can create and modify dictionaries using a variety of techniques.

To create a dictionary in Python, we can use the curly braces {} notation or the dict() function.

For example, to create a simple dictionary with two key-value pairs, you can do:

my_dict = {'name': 'John', 'age': 30}

We can also create an empty dictionary and add items to it using the square bracket notation.

For example:

my_dict = {}
my_dict['name'] = 'John'
my_dict['age'] = 30

To modify an existing dictionary, we can simply update its key-value pairs.

For example, to change the value of the ‘age’ key in the dictionary above, we can do:

my_dict['age'] = 31
my_dict['address'] = '123 Main St'

To delete a key-value pair from the dictionary, we can use the del keyword.

For example, to remove the ‘address’ key from the dictionary above, we can do:

del my_dict['address']

Operations in Dictionaries in Python

Here are some of the most common operations you can perform on dictionaries in Python:

  • Iterating over items: We can iterate over the key-value pairs in a dictionary using a for loop.

For example:

my_dict = {'name': 'John', 'age': 30}
for key, value in my_dict.items():
    print(key, value)
# Output:
# name John
# age 30
  • Checking if a key exists: We can check if a key exists in a dictionary using the ‘in‘ keyword.

For example:

my_dict = {'name': 'John', 'age': 30}
if 'name' in my_dict:
    print('Name is in the dictionary')
# Output: Name is in the dictionary
  • Length of a dictionary: We can get the number of key-value pairs in a dictionary using the ‘len()function.

For example:

my_dict = {'name': 'John', 'age': 30}
print(len(my_dict)) # Output: 2
  • Merging dictionaries: We can merge two dictionaries together using the ‘update()‘ method.

For example:

dict1 = {'name': 'John'}
dict2 = {'age': 30}
print(dict1) # Output: {'name': 'John', 'age': 30}

These are just a few of the many operations we can perform on dictionaries in Python.

With these techniques, we can easily manipulate and extract information from dictionaries to suit our needs.

Different types of Python Dictionary Methods

Here are some of the most common dictionary methods in Python:

  • clear(): The ‘clear()‘ method removes all the key-value pairs from the dictionary, leaving it empty.
  • copy(): The ‘copy()‘ method returns a shallow copy of the dictionary. This means that the method returns a new dictionary with the same key-value pairs as the original, but the key-value pairs themselves are not copied.
  • get(): The ‘get()‘ method returns the value associated with a given key in the dictionary. If the key does not exist in the dictionary, it returns the default value passed as the second argument to the method (or None if no default value is passed).
  • items(): The ‘items()‘ method returns a list of key-value pairs as tuples.
  • keys(): The ‘keys()‘ method returns a list of all the keys in the dictionary.
  • values(): The ‘values()‘ method returns a list of all the values in the dictionary.

Advantages and Disadvantages of Python Dictionaries


  • Fast lookups: Dictionaries use a hash table to store key-value pairs, which allows for very fast lookups. This makes dictionaries ideal for tasks that require frequent lookups or searches.
  • Flexible: Dictionaries are very flexible and can store any type of data as both the key and the value. This makes them well-suited to a wide range of tasks, including storing complex data structures such as graphs and databases.
  • Easy to use: Dictionaries are easy to use and manipulate in Python, with a wide range of built-in functions and methods to help us work with them.
  • Memory efficient: Dictionaries are memory efficient, as they only store the key-value pairs we need. This means that they can be used to store large amounts of data without taking up too much memory.


  • Unordered: Dictionaries are unordered, which means that the order in which we add key-value pairs is not preserved. This can make them difficult to use in situations where we need to maintain a specific order.
  • Not easily searchable by value: While dictionaries are great for searching by key, they are not easily searchable by value. If we need to search a dictionary by value, we may need to create a separate data structure to do so.
  • Can be slow with large datasets: While dictionaries are fast for small datasets, they can be slow for very large datasets. This is because the hash table used to store key-value pairs can become large and slow down the lookups.
  • Overhead: Dictionaries have some overhead associated with them, such as the memory required to store the hash table and the time needed to compute hash values for keys. This can make them less efficient than other data structures in some situations.


Arya Sarkar

Sign up for our Newsletter

Join our newsletter and get tips, tricks and coding tutorials delivered straight to your inbox.