Mastering Python Nested Dictionary [Basics to Advanced]


Getting started with Python Nested Dictionary

A Python dictionary is a built-in data structure that allows you to store key-value pairs. While dictionaries are incredibly useful on their own, sometimes you may face scenarios where you need to nest dictionaries within dictionaries. This is what we call a "Python Nested Dictionary."


Syntax and Example of a Nested Dictionary

The syntax for creating a Python Nested Dictionary is similar to creating standard dictionaries. The only difference is that the value in a key-value pair can be another dictionary.

# Example of Python Nested Dictionary
nested_dict = {
    'person1': {'name': 'Alice', 'age': 30},
    'person2': {'name': 'Bob', 'age': 25},
    'person3': {'name': 'Charlie', 'age': 40}

In this example, each person is represented by a dictionary that holds details like name and age. These dictionaries are then stored in a parent dictionary, making it a Python Nested Dictionary.


How is a Nested Dictionary Different from a Normal Dictionary?

A Python dictionary is a collection of key-value pairs, where each key maps to a specific value. The values in a standard dictionary can be of any data type like numbers, strings, lists, or even another dictionary. When a dictionary contains another dictionary as its value, it becomes a "Python Nested Dictionary."

Here's a table that compares normal dictionaries with nested dictionaries in Python:

Feature Normal Dictionary Nested Dictionary
Structure Consists of simple key-value pairs. Contains dictionaries as values for some or all of its keys.
Example {'name': 'Alice', 'age': 30, 'email': ''} {'person1': {'name': 'Alice', 'age': 30}, 'person2': {'name': 'Bob', 'age': 25}}
Complexity Easier to read and manage due to its flat structure. More complex to navigate and manage due to multiple levels.
Accessing Values Directly accessed using their keys. Requires multiple keys to access inner values.
Use-Cases Best for straightforward data representation with no hierarchical relationships. Ideal for representing complex data structures or hierarchical relationships.
Operations Basic CRUD (Create, Read, Update, Delete) operations are simpler. CRUD operations involve additional steps for navigating through the nested dictionaries.


Creating a Nested Dictionary

Creating a nested dictionary in Python can be done in multiple ways. Below are some common methods to create a Python Nested Dictionary.


1. Using {} Literal Syntax

The most straightforward way to create a nested dictionary is to use the {} literal syntax, where you manually specify both the keys and the values in the dictionary. Nested dictionaries can be created by specifying a dictionary as a value within another dictionary.


# Using {} literal syntax to create a nested dictionary
nested_dict_literal = {
    'person1': {'name': 'Alice', 'age': 30},
    'person2': {'name': 'Bob', 'age': 25},
    'person3': {'name': 'Charlie', 'age': 40}


2. Using the dict() Constructor

Another way to create a nested dictionary is to use Python's built-in dict() constructor. This method is useful when you are creating dictionaries dynamically or from existing data.


# Using dict() constructor to create a nested dictionary
person1 = dict(name='Alice', age=30)
person2 = dict(name='Bob', age=25)
person3 = dict(name='Charlie', age=40)

nested_dict_constructor = dict(person1=person1, person2=person2, person3=person3)


Accessing Elements in a Nested Dictionary

Once you've created a nested dictionary, accessing its elements can be a bit different than working with a flat dictionary. Here are some ways you can access elements in a nested dictionary:


1. Accessing Outer Keys

To access the values associated with outer keys, you simply use the key name.


nested_dict = {
    'person1': {'name': 'Alice', 'age': 30},
    'person2': {'name': 'Bob', 'age': 25},

# Accessing outer key to get inner dictionary
# Output: {'name': 'Alice', 'age': 30}


2. Accessing Nested Keys

To get to the values deep within the nested dictionary, you'll need to chain keys.


# Accessing nested key to get a specific value
# Output: Alice


3. Using the get() Method for Nested Dictionaries

The get() method can also be used to safely access keys. If the key doesn't exist, it returns None or a default value that you can specify.


# Using get() to access an outer key
outer_value = nested_dict.get('person1')
# Output: {'name': 'Alice', 'age': 30}

# Using get() in a nested fashion to access inner keys
inner_value = nested_dict.get('person1', {}).get('name', 'Unknown')
# Output: Alice

# Using get() with a default value for a non-existing key
non_existent_value = nested_dict.get('person4', {}).get('name', 'Unknown')
# Output: Unknown


Modifying Nested Dictionaries

After you've created a nested dictionary and accessed its elements, you may also want to modify it. Here's how you can add, update, and delete key-value pairs in a nested dictionary.


1. Adding New Key-Value Pairs

To add a new key-value pair to a nested dictionary, you specify the keys leading to the inner dictionary where you want to insert the new key-value pair.


nested_dict = {
    'person1': {'name': 'Alice', 'age': 30},
    'person2': {'name': 'Bob', 'age': 25},

# Adding a new key-value pair to an inner dictionary
nested_dict['person1']['email'] = ''

# Adding a completely new inner dictionary
nested_dict['person3'] = {'name': 'Charlie', 'age': 40}



2. Updating Existing Key-Value Pairs

Updating a value in a nested dictionary is similar to adding a new one—you specify the keys to navigate to the inner dictionary and then set the new value.


# Updating an existing value
nested_dict['person1']['age'] = 31

# Output: 31


3. Deleting Keys from a Nested Dictionary

To delete a key-value pair from a nested dictionary, you can use Python's del keyword. You need to specify the keys that lead to the key-value pair you want to remove.


# Deleting a key-value pair from an inner dictionary
del nested_dict['person1']['age']

# Deleting an entire inner dictionary
del nested_dict['person2']

# Output: {'person1': {'name': 'Alice', 'email': ''}, 'person3': {'name': 'Charlie', 'age': 40}}


Iterating Through a Nested Dictionary

Once you're familiar with how to access and modify elements in a nested dictionary, you might find it necessary to iterate through it. Here are some techniques to iterate through both outer and inner dictionaries.


1. Using Basic For Loops

You can use a basic for loop to iterate through the keys of the outer dictionary.


nested_dict = {
    'person1': {'name': 'Alice', 'age': 30},
    'person2': {'name': 'Bob', 'age': 25},

# Iterating through outer keys
for key in nested_dict:
    print(key, nested_dict[key])


2. Using items() for Key-Value Pair Iteration

The items() method can be used to iterate through the key-value pairs of a dictionary.


# Iterating through outer key-value pairs
for key, value in nested_dict.items():
    print(f"Key: {key}, Value: {value}")


3. Using Nested Loops for Nested Dictionaries

When dealing with nested dictionaries, nested loops can be used to iterate through both the outer and inner dictionaries.


# Iterating through both outer and inner dictionaries
for outer_key, inner_dict in nested_dict.items():
    print(f"Outer key: {outer_key}")
    for inner_key, value in inner_dict.items():
        print(f"\tInner key: {inner_key}, Value: {value}")


Nested Dictionary Comprehensions

Dictionary comprehensions provide a compact and readable way to create dictionaries. They can also be extended to create nested dictionaries, making them a powerful feature for efficiently constructing complex data structures.

You can create nested dictionaries by using nested dictionary comprehensions. The basic structure involves nesting one comprehension inside another.


Let's say you want to create a nested dictionary to represent a matrix where the keys are the row and column indices.

# Creating a 3x3 matrix using nested dictionary comprehension
matrix = {(row, col): row * col for row in range(3) for col in range(3)}

# Output: {(0, 0): 0, (0, 1): 0, (0, 2): 0, (1, 0): 0, (1, 1): 1, (1, 2): 2, (2, 0): 0, (2, 1): 2, (2, 2): 4}

Nested dictionary comprehensions can be particularly useful when you need to initialize a nested data structure with some default values or when you want to transform an existing data structure into a nested dictionary.


Suppose you have a list of students, and you want to create a nested dictionary where the outer keys are student names and the inner keys are subjects, initialized to a default grade.

students = ['Alice', 'Bob', 'Charlie']
subjects = ['Math', 'Science', 'History']

# Using nested dictionary comprehension to initialize grades
student_grades = {student: {subject: 'Not Graded' for subject in subjects} for student in students}

# Output: {'Alice': {'Math': 'Not Graded', 'Science': 'Not Graded', 'History': 'Not Graded'}, 
#          'Bob': {'Math': 'Not Graded', 'Science': 'Not Graded', 'History': 'Not Graded'}, 
#          'Charlie': {'Math': 'Not Graded', 'Science': 'Not Graded', 'History': 'Not Graded'}}


Common Operations with Nested Dictionaries

Working with nested dictionaries often requires performing specific operations such as merging, searching, or flattening. Here's how to accomplish these tasks.


1. Merging Nested Dictionaries

You can merge two nested dictionaries using nested loops or by using the update() method if the structure is not too deep.


dict1 = {'A': {'x': 1, 'y': 2}, 'B': {'z': 3}}
dict2 = {'A': {'y': 4, 'z': 5}, 'C': {'x': 6}}

# Merging dict2 into dict1
for key, value in dict2.items():
    if key in dict1:
        dict1[key] = value

# Output: {'A': {'x': 1, 'y': 4, 'z': 5}, 'B': {'z': 3}, 'C': {'x': 6}}


2. Searching in a Nested Dictionary

Searching for a key or a value in a nested dictionary typically involves using nested loops to go through each level.


# Searching for a key in a nested dictionary
def search_key(nested_dict, target_key):
    for key, value in nested_dict.items():
        if key == target_key:
            return True
        elif isinstance(value, dict):
            if search_key(value, target_key):
                return True
    return False

nested_dict = {'A': {'x': 1}, 'B': {'y': 2}, 'C': {'z': {'a': 3}}}
print(search_key(nested_dict, 'z'))  # Output: True


3. Flattening a Nested Dictionary

Flattening involves converting a multi-level dictionary into a single-level dictionary.


# Flattening a nested dictionary
def flatten_dict(d, parent_key='', sep='.'):
    items = {}
    for k, v in d.items():
        new_key = f"{parent_key}{sep}{k}" if parent_key else k
        if isinstance(v, dict):
            items.update(flatten_dict(v, new_key, sep=sep))
            items[new_key] = v
    return items

nested_dict = {'A': {'x': 1, 'y': 2}, 'B': {'z': {'a': 3, 'b': 4}}}
flat_dict = flatten_dict(nested_dict)
# Output: {'A.x': 1, 'A.y': 2, 'B.z.a': 3, 'B.z.b': 4}


Common Mistakes and How to Avoid Them

Working with nested dictionaries can be a complex task, and there are some common pitfalls that developers often encounter. Here's how to avoid them:

1. Key Errors: One of the most common errors when working with (nested) dictionaries is trying to access keys that do not exist. This will raise a KeyError.

How to Avoid:

Use the get() method to access keys, which will return None or a default value if the key does not exist.

value = nested_dict.get("non_existent_key", "Default Value")

You can also use in to check whether a key exists before trying to access it.

if 'key' in nested_dict:


2. Accidental Overwriting: One common mistake when working with nested dictionaries is accidental overwriting of keys or entire sub-dictionaries. This can happen when merging nested dictionaries or adding new keys.

How to Avoid: Always check if a key already exists before adding it. If the key does exist, then decide whether you want to overwrite it or merge it.

if 'key' in nested_dict:
    # Handle the existing key: either merge or make a decision to overwrite
    nested_dict['key'] = 'new_value'


3. Incorrect Assumptions About Data Types: Sometimes, developers assume that a nested structure will always contain dictionaries, but it might also contain lists, tuples, or even other custom objects.

How to Avoid: Use isinstance() checks when iterating over nested items to make sure you're working with the data type that you expect.

if isinstance(nested_dict['key'], dict):
    # Handle dictionary
elif isinstance(nested_dict['key'], list):
    # Handle list


Performance Considerations

Nested dictionaries can have implications on the performance of your Python application, both in terms of speed and memory usage. Let's explore how they compare with flat dictionaries and when you should opt for one over the other.

Nested dictionaries inherently have a slightly more complex structure than flat dictionaries, which may incur a slight overhead in terms of memory and speed, especially when you are dealing with a very large set of data.

Examples and Output Data:

import time
import sys

# Measuring speed for accessing keys in flat vs nested dictionaries
flat_dict = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
nested_dict = {'key1': {'subkey1': 'value1'}, 'key2': {'subkey2': 'value2'}}

# Running the tests multiple times to get a more accurate measure
N = 100000

# For flat dictionary
start_time = time.time()
for _ in range(N):
    value = flat_dict['key1']
end_time = time.time()
flat_dict_speed = (end_time - start_time) / N

# For nested dictionary
start_time = time.time()
for _ in range(N):
    value = nested_dict['key1']['subkey1']
end_time = time.time()
nested_dict_speed = (end_time - start_time) / N

print(f"Average access time for flat dictionary: {flat_dict_speed}")
print(f"Average access time for nested dictionary: {nested_dict_speed}")

# Measuring memory usage
flat_dict_memory = sys.getsizeof(flat_dict)
nested_dict_memory = sys.getsizeof(nested_dict)

print(f"Memory usage for flat dictionary: {flat_dict_memory} bytes")
print(f"Memory usage for nested dictionary: {nested_dict_memory} bytes")


Average access time for flat dictionary: 1.0160446166992187e-07
Average access time for nested dictionary: 1.1440038681030273e-07
Memory usage for flat dictionary: 240 bytes
Memory usage for nested dictionary: 240 bytes

The test results show that the average access time for nested dictionaries is marginally higher than for flat dictionaries, which is expected due to the additional key lookups in nested structures. However, the difference in time is still very small, on the order of nanoseconds, and thus unlikely to have a meaningful impact in most real-world applications.

The memory usage for both flat and nested dictionaries remains the same in your tests, which is also expected. Python dictionaries store references to keys and values, so the top-level dictionary object would have similar memory footprints in both cases.



In this article, we explored the nuanced world of Python Nested Dictionaries. From basic operations like creating and accessing elements to more advanced techniques like dictionary comprehensions and merging, nested dictionaries offer a versatile way to manage complex data structures. While there are some performance considerations and common mistakes to keep in mind, the flexibility and organizational benefits often outweigh the minor drawbacks.


Additional Resources


Views: 345
Deepak Prasad

Deepak Prasad

He is the founder of GoLinuxCloud and brings over a decade of expertise in Linux, Python, Go, Laravel, DevOps, Kubernetes, Git, Shell scripting, OpenShift, AWS, Networking, and Security. With extensive experience, he excels in various domains, from development to DevOps, Networking, and Security, ensuring robust and efficient solutions for diverse projects. You can connect with him on his LinkedIn profile.

Can't find what you're searching for? Let us assist you.

Enter your query below, and we'll provide instant results tailored to your needs.

If my articles on GoLinuxCloud has helped you, kindly consider buying me a coffee as a token of appreciation.

Buy GoLinuxCloud a Coffee

For any other feedbacks or questions you can send mail to

Thank You for your support!!

Leave a Comment