Nested Dictionaries: Complete Guide for Beginners

In the previous lesson, you learned how to create dictionaries using dictionary comprehension. While a standard dictionary stores a single level of key-value pairs, many real-world applications require storing more complex and structured information. For example, a school may store multiple students, each with their own name, marks, course, and city. Python supports this type of data organization through nested dictionaries.

A nested dictionary is simply a dictionary whose values are themselves dictionaries. This allows you to organize related information in a hierarchical structure, making it easier to represent real-world data such as employee records, product catalogs, customer profiles, JSON data, and API responses.

In this lesson, you will learn what nested dictionaries are, why they are useful, how to create them, access nested values, understand their characteristics, and explore practical examples from real-world programming.

Learning Objectives

After completing this lesson, you will be able to:

• Understand nested dictionaries.
• Create nested dictionaries.
• Access values stored inside nested dictionaries.
• Understand the characteristics of nested dictionaries.
• Apply nested dictionaries in real-world applications.
• Avoid common beginner mistakes.

Understanding Nested Dictionaries

A nested dictionary is a dictionary in which one or more values are themselves dictionaries. Each inner dictionary contains its own set of key-value pairs.

Nested dictionaries are useful when storing structured or hierarchical data because they allow multiple related records to be grouped together.

Why Use Nested Dictionaries?

Nested dictionaries make it possible to organize complex information without creating multiple separate variables.

Common applications include:

• Student management systems.
• Employee databases.
• Customer profiles.
• Hospital records.
• Inventory management.
• JSON and API responses.

Characteristics of Nested Dictionaries

• Each value can itself be another dictionary.
• Each inner dictionary has its own unique keys.
• Nested dictionaries are mutable.
• Values are accessed using multiple keys.
• They can contain lists, tuples, sets, and other data types.
• They are ideal for representing hierarchical data.

Creating Nested Dictionaries

A nested dictionary is created by placing dictionaries inside another dictionary.

Creating Your First Nested Dictionary

students = {
    "student1": {
        "name": "Rahul",
        "course": "BCA",
        "marks": 92
    },
    "student2": {
        "name": "Priya",
        "course": "BSc",
        "marks": 88
    }
}

print(students)

Output

{
 'student1': {
     'name': 'Rahul',
     'course': 'BCA',
     'marks': 92
 },
 'student2': {
     'name': 'Priya',
     'course': 'BSc',
     'marks': 88
 }
}

Each student is represented by an inner dictionary containing personal information.

Creating a Product Catalog

products = {
    "P101": {
        "name": "Laptop",
        "price": 55000,
        "stock": 20
    },
    "P102": {
        "name": "Mouse",
        "price": 800,
        "stock": 100
    }
}

print(products)

Output

{
 'P101': {
     'name': 'Laptop',
     'price': 55000,
     'stock': 20
 },
 'P102': {
     'name': 'Mouse',
     'price': 800,
     'stock': 100
 }
}

Accessing Nested Values

To access a value inside a nested dictionary, use multiple keys.

Example

students = {
    "student1": {
        "name": "Rahul",
        "marks": 92
    }
}

print(students["student1"]["name"])

print(students["student1"]["marks"])

Output

Rahul

92

Python first accesses the outer dictionary and then retrieves the required value from the inner dictionary.

Real-World Examples

Example 1: Employee Records

employees = {
    "E101": {
        "name": "Neha",
        "department": "HR",
        "salary": 50000
    },
    "E102": {
        "name": "Amit",
        "department": "IT",
        "salary": 65000
    }
}

print(employees["E102"]["department"])

Output

IT

Example 2: Customer Information

customers = {
    "C001": {
        "name": "Riya",
        "city": "Delhi"
    },
    "C002": {
        "name": "Arjun",
        "city": "Mumbai"
    }
}

print(customers["C001"]["city"])

Output

Delhi

Execution Flow

Consider the following program.

student = {
    "student1": {
        "name": "Rahul",
        "marks": 92
    }
}

print(student["student1"]["marks"])

Execution Steps

1. Python creates the outer dictionary.
2. It creates the inner dictionary associated with student1.
3. The first key student1 accesses the inner dictionary.
4. The second key marks retrieves the required value.
5. The value is displayed.

Output

92

Common Beginner Mistakes

• Trying to access an inner key without first accessing the outer key.
• Confusing nested dictionaries with dictionaries containing lists.
• Using incorrect key names while accessing nested data.
• Expecting nested dictionaries to create missing keys automatically.
• Using too many nested levels, making the code difficult to read.

Chunk Summary

In this section, you learned what nested dictionaries are, why they are useful, how to create them, access nested values, and represent structured information efficiently. You also explored real-world examples, execution flow, and common beginner mistakes. In the next section, you will learn how to add, update, and remove data from nested dictionaries, iterate through nested structures, perform membership testing, and apply these techniques in practical Python programs.

In the previous section, you learned how to create nested dictionaries and access values using multiple keys. In real-world applications, nested dictionaries are rarely static. You often need to add new records, update existing information, remove data, and iterate through multiple levels of nested dictionaries. Python makes these operations straightforward using the same dictionary techniques that you already know.

In this section, you will learn how to add, update, and remove data from nested dictionaries, iterate through nested structures, perform membership testing, and explore practical examples from real-world applications.

Managing Nested Dictionaries

Nested dictionaries can be modified just like normal dictionaries. The only difference is that you first access the appropriate inner dictionary before performing the required operation.

Adding a New Record

You can add an entirely new nested dictionary by assigning a new key to the outer dictionary.

students = {
    "student1": {
        "name": "Rahul",
        "marks": 92
    }
}

students["student2"] = {
    "name": "Priya",
    "marks": 88
}

print(students)

Output

{
 'student1': {'name': 'Rahul', 'marks': 92},
 'student2': {'name': 'Priya', 'marks': 88}
}

Adding a New Field

You can also add new information to an existing inner dictionary.

students = {
    "student1": {
        "name": "Rahul",
        "marks": 92
    }
}

students["student1"]["city"] = "Dehradun"

print(students)

Output

{
 'student1': {
     'name': 'Rahul',
     'marks': 92,
     'city': 'Dehradun'
 }
}

Updating Nested Values

Updating a value requires accessing both the outer key and the inner key.

students = {
    "student1": {
        "name": "Rahul",
        "marks": 92
    }
}

students["student1"]["marks"] = 95

print(students)

Output

{
 'student1': {
     'name': 'Rahul',
     'marks': 95
 }
}

Removing a Nested Field

The del statement removes a specific key from an inner dictionary.

students = {
    "student1": {
        "name": "Rahul",
        "marks": 92,
        "city": "Dehradun"
    }
}

del students["student1"]["city"]

print(students)

Output

{
 'student1': {
     'name': 'Rahul',
     'marks': 92
 }
}

Removing an Entire Record

Removing the outer key deletes the complete nested dictionary.

students = {
    "student1": {
        "name": "Rahul"
    },
    "student2": {
        "name": "Priya"
    }
}

del students["student2"]

print(students)

Output

{
 'student1': {
     'name': 'Rahul'
 }
}

Looping Through Nested Dictionaries

You can use nested for loops to traverse every level of a nested dictionary.

students = {
    "student1": {
        "name": "Rahul",
        "marks": 92
    },
    "student2": {
        "name": "Priya",
        "marks": 88
    }
}

for student_id, details in students.items():
    print(student_id)

    for key, value in details.items():
        print(key, ":", value)

Output

student1
name : Rahul
marks : 92

student2
name : Priya
marks : 88

Membership Testing

The in operator checks whether a key exists in either the outer or inner dictionary.

students = {
    "student1": {
        "name": "Rahul",
        "marks": 92
    }
}

print("student1" in students)

print("marks" in students["student1"])

Output

True

True

Practical Examples

Example 1: Employee Database

employees = {
    "E101": {
        "name": "Neha",
        "salary": 50000
    }
}

employees["E101"]["salary"] = 55000

print(employees)

Output

{
 'E101': {
     'name': 'Neha',
     'salary': 55000
 }
}

Example 2: Product Inventory

products = {
    "P101": {
        "name": "Laptop",
        "stock": 20
    }
}

products["P101"]["stock"] = 18

print(products)

Output

{
 'P101': {
     'name': 'Laptop',
     'stock': 18
 }
}

Example 3: Customer Records

customers = {
    "C001": {
        "name": "Riya",
        "city": "Delhi"
    }
}

customers["C001"]["phone"] = "9876543210"

print(customers)

Output

{
 'C001': {
     'name': 'Riya',
     'city': 'Delhi',
     'phone': '9876543210'
 }
}

Execution Flow

Consider the following program.

students = {
    "student1": {
        "marks": 92
    }
}

students["student1"]["marks"] = 95

print(students)

Execution Steps

1. Python creates the outer dictionary.
2. The inner dictionary is stored under student1.
3. The first key accesses the inner dictionary.
4. The value associated with marks is updated.
5. The modified nested dictionary is displayed.

Output

{
 'student1': {
     'marks': 95
 }
}

Common Beginner Mistakes

• Trying to update an inner key before accessing the outer key.
• Using an incorrect outer key while updating data.
• Removing an outer key when only an inner field should be deleted.
• Using a single loop instead of nested loops to traverse nested dictionaries.
• Assuming missing nested keys are created automatically.

Chunk Summary

In this section, you learned how to add, update, and remove data from nested dictionaries, iterate through multiple levels using nested loops, perform membership testing, and apply these techniques in practical programs. You also explored execution flow and common beginner mistakes. In the next section, you will learn advanced techniques for working with nested dictionaries, including copying nested dictionaries, combining nested data, best practices, performance tips, and real-world applications.

In the previous section, you learned how to add, update, remove, and iterate through nested dictionaries. As applications become larger, nested dictionaries often contain hundreds or thousands of records. Python provides several techniques for managing these complex data structures efficiently while keeping your code readable and maintainable.

In this section, you will learn how to combine nested dictionaries, create copies, understand shallow and deep copying, explore best practices, improve performance, and apply nested dictionaries in real-world applications.

Advanced Nested Dictionary Operations

Nested dictionaries support most of the operations available for normal dictionaries. However, because they contain multiple levels, you should understand how copying and combining nested data works.

Combining Nested Dictionaries

You can combine multiple nested dictionaries using the update() method.

students = {
    "student1": {
        "name": "Rahul",
        "marks": 92
    }
}

new_students = {
    "student2": {
        "name": "Priya",
        "marks": 88
    }
}

students.update(new_students)

print(students)

Output

{
 'student1': {
     'name': 'Rahul',
     'marks': 92
 },
 'student2': {
     'name': 'Priya',
     'marks': 88
 }
}

Copying a Nested Dictionary

The copy() method creates a shallow copy of a nested dictionary.

students = {
    "student1": {
        "name": "Rahul",
        "marks": 92
    }
}

backup = students.copy()

print(backup)

Output

{
 'student1': {
     'name': 'Rahul',
     'marks': 92
 }
}

A shallow copy duplicates only the outer dictionary. The inner dictionaries are still shared.

Understanding Shallow Copy

students = {
    "student1": {
        "marks": 92
    }
}

backup = students.copy()

backup["student1"]["marks"] = 95

print(students)

print(backup)

Output

{
 'student1': {
     'marks': 95
 }
}

{
 'student1': {
     'marks': 95
 }
}

Both dictionaries change because they reference the same inner dictionary.

Creating a Deep Copy

Use the deepcopy() function from the copy module when you need a completely independent copy.

from copy import deepcopy

students = {
    "student1": {
        "marks": 92
    }
}

backup = deepcopy(students)

backup["student1"]["marks"] = 95

print(students)

print(backup)

Output

{
 'student1': {
     'marks': 92
 }
}

{
 'student1': {
     'marks': 95
 }
}

A deep copy duplicates every level of the nested dictionary.

Real-World Applications

Example 1: School Database

school = {
    "Class10": {
        "Students": 45,
        "Teacher": "Anita"
    },
    "Class12": {
        "Students": 38,
        "Teacher": "Rajesh"
    }
}

print(school)

Output

{
 'Class10': {
     'Students': 45,
     'Teacher': 'Anita'
 },
 'Class12': {
     'Students': 38,
     'Teacher': 'Rajesh'
 }
}

Example 2: Product Inventory

inventory = {
    "Laptop": {
        "Price": 55000,
        "Stock": 20
    },
    "Mouse": {
        "Price": 800,
        "Stock": 120
    }
}

print(inventory)

Output

{
 'Laptop': {
     'Price': 55000,
     'Stock': 20
 },
 'Mouse': {
     'Price': 800,
     'Stock': 120
 }
}

Example 3: Employee Database

employees = {
    "E101": {
        "Name": "Neha",
        "Department": "HR"
    },
    "E102": {
        "Name": "Rahul",
        "Department": "IT"
    }
}

print(employees)

Output

{
 'E101': {
     'Name': 'Neha',
     'Department': 'HR'
 },
 'E102': {
     'Name': 'Rahul',
     'Department': 'IT'
 }
}

Best Practices

• Keep nesting levels as small as possible.
• Use meaningful outer and inner keys.
• Use deepcopy() when creating independent copies.
• Use nested dictionaries only when the data is naturally hierarchical.
• Document complex nested structures for easier maintenance.

Performance Tips

• Avoid unnecessary deep nesting.
• Use items() when iterating through nested dictionaries.
• Use deepcopy() only when required because it consumes additional memory.
• Avoid repeatedly searching the same nested keys inside loops.

Execution Flow

Consider the following program.

students = {
    "student1": {
        "marks": 92
    }
}

backup = students.copy()

print(backup)

Execution Steps

1. Python creates the nested dictionary.
2. The copy() method creates a shallow copy of the outer dictionary.
3. The inner dictionary is shared between both dictionaries.
4. The copied dictionary is stored in memory.
5. The copied dictionary is displayed.

Output

{
 'student1': {
     'marks': 92
 }
}

Common Beginner Mistakes

• Assuming copy() creates a deep copy.
• Creating unnecessary levels of nesting.
• Using unclear key names.
• Modifying a nested dictionary while iterating over it.
• Using nested dictionaries when a simpler structure would be sufficient.

Chunk Summary

In this section, you learned how to combine nested dictionaries, create shallow and deep copies, understand the difference between copy() and deepcopy(), apply best practices, improve performance, and use nested dictionaries in real-world applications. In the final section, you will review the complete lesson through a lesson summary, key takeaways, FAQs, coding exercises, interview questions, a mini project, and a preview of the next lesson on Dictionary vs List vs Tuple vs Set: Complete Guide for Beginners.

Lesson Summary

In this lesson, you learned how to use nested dictionaries in Python to organize and manage hierarchical data. A nested dictionary is a dictionary that contains one or more dictionaries as its values, making it ideal for storing structured information such as student records, employee databases, product catalogs, customer profiles, and JSON data.

You began by understanding what nested dictionaries are, why they are useful, and how to create them. You learned how to access nested values using multiple keys and explored several real-world examples.

Next, you learned how to add new records, insert new fields, update existing values, remove nested data, and iterate through nested dictionaries using nested for loops. You also learned how to perform membership testing with nested dictionaries.

Finally, you explored advanced operations such as combining nested dictionaries, creating shallow and deep copies, and learned the differences between copy() and deepcopy(). You also reviewed best practices, performance tips, and common beginner mistakes.

Nested dictionaries are one of the most commonly used data structures in Python because they closely represent real-world hierarchical data and are widely used in APIs, JSON files, web applications, automation, machine learning, and data analysis.

Key Takeaways

• A nested dictionary is a dictionary containing other dictionaries.
• Nested dictionaries organize hierarchical data efficiently.
• Access nested values using multiple dictionary keys.
• Inner dictionaries can be updated independently.
• Use nested for loops to iterate through nested dictionaries.
• Use update() to combine nested dictionaries.
• copy() creates a shallow copy.
• deepcopy() creates a completely independent copy.
• Use meaningful key names for better readability.
• Avoid excessive nesting whenever possible.

Frequently Asked Questions (FAQs)

1. What is a nested dictionary?

A nested dictionary is a dictionary that contains one or more dictionaries as its values.

2. Why are nested dictionaries useful?

They help organize structured and hierarchical information efficiently.

3. How do you access a nested value?

Use multiple dictionary keys, such as students["student1"]["marks"].

4. Can nested dictionaries be modified?

Yes. You can add, update, and remove nested data.

5. How do you loop through nested dictionaries?

Use nested for loops with the items() method.

6. What is the difference between copy() and deepcopy()?

copy() creates a shallow copy, while deepcopy() copies every nested level independently.

7. Can nested dictionaries contain lists?

Yes. Inner dictionaries can contain lists, tuples, sets, and other data types.

8. Can dictionaries be nested multiple levels?

Yes. However, excessive nesting can reduce readability and increase complexity.

9. Where are nested dictionaries commonly used?

They are commonly used in JSON data, APIs, databases, configuration files, and management systems.

10. What is the biggest advantage of nested dictionaries?

They allow complex real-world data to be stored in a clear and organized structure.

Coding Exercises

1. Create a nested dictionary containing information for three students.
2. Access and display a student’s marks using nested keys.
3. Add a new student to an existing nested dictionary.
4. Add a new field such as city to an existing student.
5. Update the salary of an employee in a nested dictionary.
6. Delete a field from an inner dictionary.
7. Remove an entire nested record.
8. Loop through a nested dictionary using nested for loops.
9. Create a shallow copy and observe the changes.
10. Create a deep copy using deepcopy() and compare the results.

Interview Questions

1. What is a nested dictionary?
2. How does a nested dictionary differ from a normal dictionary?
3. How do you access values inside a nested dictionary?
4. How do you add and update nested data?
5. How do you remove nested values?
6. How do you iterate through a nested dictionary?
7. What is the difference between a shallow copy and a deep copy?
8. When should you use nested dictionaries?
9. What are the advantages of nested dictionaries?
10. Give two real-world examples where nested dictionaries are useful.

Mini Project: School Management System Using Nested Dictionaries

Create a Python program that stores and manages school records using nested dictionaries.

Your program should:

• Create a nested dictionary containing multiple students.
• Store each student’s name, class, marks, city, and phone number.
• Add a new student record.
• Update an existing student’s marks.
• Display all student records using nested loops.
• Remove one field from a student record.
• Create a backup using deepcopy().
• Display the original and copied dictionaries.

Sample Output

========== SCHOOL MANAGEMENT SYSTEM ==========

Student Records

{
 'student1': {
     'name': 'Rahul',
     'class': 'BCA',
     'marks': 92,
     'city': 'Dehradun'
 },
 'student2': {
     'name': 'Priya',
     'class': 'BSc',
     'marks': 88,
     'city': 'Delhi'
 }
}

After Updating Marks

Rahul -> 95

After Adding Student

student3 Added Successfully

Displaying All Records

student1
name : Rahul
class : BCA
marks : 95
city : Dehradun

student2
name : Priya
class : BSc
marks : 88
city : Delhi

student3
name : Amit
class : BCom
marks : 90
city : Jaipur

Backup Created Successfully

==============================================

What’s Next?

Congratulations! You have successfully learned how to create, manage, and work with nested dictionaries in Python. You can now organize hierarchical data, update nested records, iterate through multiple dictionary levels, and create safe copies using deepcopy().

In the next lesson, you will learn Dictionary vs List vs Tuple vs Set: Complete Guide for Beginners. You will compare Python’s four major collection data types, understand their differences, advantages, limitations, performance characteristics, and learn when to use each one in real-world programming.