Hello, if you’ve worked with dictionaries before, you already know they’re excellent for storing key-value pairs. But what if you need to organize data in layers or hierarchies? That’s where nested dictionaries come in!

In this article, we’ll cover:

  • What a nested dictionary is and when to use it
  • How to create, access, and update nested dictionaries in Python
  • Common operations you can perform on nested dictionaries

By the end of this guide, you’ll be able to create and work with nested dictionaries confidently. Let’s get started!

What is a Nested Dictionary in Python?

In Python, a dictionary is a data structure that holds key-value pairs. A nested dictionary is simply a dictionary within a dictionary. This allows you to store more complex, hierarchical data structures. Think of it as a way to organize information into levels.

For instance, let’s say you’re building a program to keep track of employees at a company. You could use a nested dictionary to store information by department, with each department containing dictionaries for individual employees:

company = {
    "Sales": {
        "Alice": {"age": 25, "role": "Sales Executive"},
        "Bob": {"age": 30, "role": "Sales Manager"}
    },
    "Engineering": {
        "Carol": {"age": 28, "role": "Software Engineer"},
        "Dave": {"age": 35, "role": "CTO"}
    }
}
Java webinar

In this example, company is a dictionary that contains two departments: Sales and Engineering. Each department is itself a dictionary with employee names as keys, and each employee has another dictionary holding their details.

How to Access Data in a Nested Dictionary

Accessing values in a nested dictionary is straightforward once you know how. You simply chain the keys, one after the other, to reach deeper levels. Here’s how it works:

# Accessing Alice's role in the Sales department
print(company["Sales"]["Alice"]["role"])  # Output: Sales Executive

In this example, we start with company, then go to Sales, then Alice, and finally retrieve the value of "role". Easy, right?

What if a Key Doesn’t Exist?

Python will throw a KeyError if you try to access a key that doesn’t exist. To handle this gracefully, you can use the get() method:

print(company.get("Marketing", {}).get("Alice", {}).get("role", "Role not found"))  # Output: Role not found

This method allows us to specify a default value (like "Role not found") if any key is missing along the way.

Adding and Updating Data in a Nested Dictionary

Adding new entries or updating existing data in a nested dictionary is very similar to accessing it. You specify the keys and assign a value at the target level:

Adding a New Department

# Adding a new department
company["HR"] = {
    "Eve": {"age": 29, "role": "HR Manager"}
}

This code creates a new HR department with one employee, Eve.

Updating Existing Data

# Updating Bob's role in the Sales department
company["Sales"]["Bob"]["role"] = "Senior Sales Manager"

Here, we update Bob’s role to “Senior Sales Manager” in the Sales department.

Removing Data from a Nested Dictionary

You can use del to remove specific entries from a nested dictionary. Be careful with this operation, as removing a key that doesn’t exist will raise a KeyError unless you check first.

Deleting an Employee

# Removing Carol from Engineering
del company["Engineering"]["Carol"]

Now, Carol’s data is removed from the Engineering department.

Using pop() for Safe Deletion

Using pop() allows you to specify a default value if the key isn’t found:

company["Sales"].pop("Charlie", "Employee not found")  # Output: Employee not found

If “Charlie” doesn’t exist in Sales, this code won’t throw an error but will instead return "Employee not found".

Looping Through a Nested Dictionary

There may be times when you need to loop through a nested dictionary to display or process its data. Let’s go over a couple of common ways to do this.

Looping Through Departments and Employees

Here’s an example that iterates over each department and employee:

for department, employees in company.items():
    print(f"Department: {department}")
    for employee, details in employees.items():
        print(f"  Employee: {employee}, Role: {details['role']}")

This code will display each department, employee name, and role. You can customize it to include other details as well.

Looping with nested for Loops

If you need even finer control, you can use nested for loops to reach deeper levels:

for department, employees in company.items():
    for employee, details in employees.items():
        for detail, value in details.items():
            print(f"{employee} - {detail}: {value}")

This approach gives you access to each individual detail within every employee record.

Common Operations and Tips for Nested Dictionaries

Nested dictionaries offer a lot of flexibility, and there are several operations that can simplify your work:

Java university
  • Check if a key exists: Use in or get() to avoid errors.
  • Use defaultdict: From the collections module, this can simplify nested dictionary creation.
  • Copying nested dictionaries: Use copy.deepcopy() from the copy module to avoid unintentional modifications.
from collections import defaultdict
from copy import deepcopy

# Using defaultdict for nested dictionaries
company = defaultdict(lambda: defaultdict(dict))

# Deep copy example
new_company = deepcopy(company)

These tools are especially useful when working with large or complex nested dictionaries.

Summary

Congratulations! You’ve covered a lot of ground on nested dictionaries. Here’s a quick recap of what we learned:

  • A nested dictionary is a dictionary within a dictionary, perfect for organizing hierarchical data.
  • You can create, access, update, and delete data within nested dictionaries using chained keys.
  • Looping through nested dictionaries lets you process multiple layers of data efficiently.

With a bit of practice, you’ll be using nested dictionaries like a pro. Keep experimenting, and enjoy coding with Python!