Using Dictionary Methods and Nested Dictionaries

Course: Python Training

Topic: Using Dictionary Methods and Nested Dictionaries

Course Link: Python Training Course

Demo Link: Register for a Course Demo

Website: JustAcademy

1. Introduction to Python Dictionaries

A dictionary is a built-in Python data type used to store information as key-value pairs. Each key identifies a corresponding value, making dictionaries useful for organizing, retrieving, updating, and managing structured data.

Dictionaries are commonly used in student records, employee databases, product catalogs, configuration settings, API responses, and other applications that require meaningful labels for stored values.

A dictionary is written using curly braces {}, with each key-value pair separated by a colon.

student = {
    "name": "Rahul",
    "age": 21,
    "course": "Python",
    "marks": 88
}

print(student)

Output:

{'name': 'Rahul', 'age': 21, 'course': 'Python', 'marks': 88}

2. Learning Objectives

After completing this topic, you will be able to:

• Understand dictionary structure and key-value pairs.
• Create, access, update, and delete dictionary entries.
• Use built-in dictionary methods effectively.
• Understand the difference between get(), setdefault(), update(), and other methods.
• Create and manipulate nested dictionaries.
• Traverse dictionaries using loops.
• Apply dictionaries to practical Python programming problems.
• Handle missing keys and avoid common dictionary errors.

3. Understanding Dictionary Characteristics

3.1 Key-Value Pairs

Each dictionary entry contains a key and its associated value. Keys must be unique and hashable, while values can be of almost any Python data type.

employee = {
    "id": 101,
    "name": "Priya",
    "salary": 45000,
    "is_active": True
}

print(employee["name"])
print(employee["salary"])

Output:

Priya
45000

3.2 Important Characteristics

• Mutable: You can add, update, and remove dictionary entries.
• Unique keys: Each key can appear only once in a dictionary.
• Insertion order: Python dictionaries preserve insertion order.
• Flexible values: Values may be strings, numbers, lists, tuples, dictionaries, or other objects.
• Hashable keys: Common keys include strings, integers, and suitable tuples.
• Fast lookups: Key-based access is typically efficient.

3.3 Creating Dictionaries

There are several ways to create a dictionary in Python.

# Using curly braces
person = {"name": "Amit", "age": 25}

# Using the dict() constructor
employee = dict(name="Neha", department="IT")

# Creating an empty dictionary
empty_data = {}

# Creating a dictionary with dict.fromkeys()
subjects = dict.fromkeys(["Math", "Science"], 0)

print(person)
print(employee)
print(empty_data)
print(subjects)

Output:

{'name': 'Amit', 'age': 25}
{'name': 'Neha', 'department': 'IT'}
{}
{'Math': 0, 'Science': 0}

Note: When using dict() with keyword arguments, the keys must be valid Python identifiers. Use curly braces when keys contain spaces or other special characters.

4. Accessing Dictionary Values

4.1 Accessing Values Using Square Brackets

You can access a value by placing its key inside square brackets.

student = {
    "name": "Riya",
    "age": 22,
    "grade": "A"
}

print(student["name"])
print(student["grade"])

Output:

Riya
A

If the requested key does not exist, square-bracket access raises a KeyError.

4.2 Using the get() Method

The get() method retrieves a value without raising a KeyError when the key is missing. By default, it returns None, but you can specify a default value.

student = {
    "name": "Riya",
    "age": 22
}

print(student.get("name"))
print(student.get("grade"))
print(student.get("grade", "Not assigned"))

Output:

Riya
None
Not assigned

When to use: Use get() when a key might be absent and you want to provide a fallback instead of stopping the program with an exception.

5. Important Python Dictionary Methods

5.1 keys() Method

The keys() method returns a dynamic view of all keys in the dictionary. The view reflects changes made to the dictionary.

student = {
    "name": "Amit",
    "age": 20,
    "course": "Python"
}

print(student.keys())

Output:

dict_keys(['name', 'age', 'course'])

You can convert the view into a list if a separate list of keys is required.

keys_list = list(student.keys())
print(keys_list)

Output:

['name', 'age', 'course']

5.2 values() Method

The values() method returns a dynamic view of all values stored in a dictionary.

product = {
    "name": "Laptop",
    "price": 55000,
    "brand": "Dell"
}

print(product.values())

Output:

dict_values(['Laptop', 55000, 'Dell'])

This method is useful when you need to process or inspect the values without needing their keys.

5.3 items() Method

The items() method returns a dynamic view of the dictionary's key-value pairs. Each item behaves like a two-element tuple containing a key and its value.

student = {
    "name": "Priya",
    "age": 21,
    "marks": 90
}

print(student.items())

Output:

dict_items([('name', 'Priya'), ('age', 21), ('marks', 90)])

The items() method is especially useful when iterating through both keys and values.

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

Output:

name : Priya
age : 21
marks : 90

5.4 update() Method

The update() method adds new key-value pairs or updates existing ones. It modifies the original dictionary and returns None.

student = {
    "name": "Amit",
    "age": 20
}

student.update({
    "age": 21,
    "course": "Python"
})

print(student)

Output:

{'name': 'Amit', 'age': 21, 'course': 'Python'}

You can also pass keyword arguments when the keys are valid identifiers.

student.update(city="Mumbai", active=True)
print(student)

5.5 pop() Method

The pop() method removes the specified key and returns its associated value. If the key is missing, it raises a KeyError unless a default value is supplied.

student = {
    "name": "Neha",
    "age": 22,
    "course": "Python"
}

removed_course = student.pop("course")

print(removed_course)
print(student)

Output:

Python
{'name': 'Neha', 'age': 22}

You can safely supply a default for a potentially missing key.

result = student.pop("grade", "Not found")
print(result)

Output:

Not found

5.6 popitem() Method

The popitem() method removes and returns the last inserted key-value pair as a tuple. It raises a KeyError if the dictionary is empty.

employee = {
    "name": "Rahul",
    "department": "IT",
    "salary": 50000
}

removed_item = employee.popitem()

print(removed_item)
print(employee)

Output:

('salary', 50000)
{'name': 'Rahul', 'department': 'IT'}

5.7 setdefault() Method

The setdefault() method returns the value associated with a key. If the key does not exist, it inserts the key with the supplied default value and returns that value.

student = {
    "name": "Amit",
    "age": 20
}

print(student.setdefault("name", "Unknown"))
print(student.setdefault("city", "Mumbai"))
print(student)

Output:

Amit
Mumbai
{'name': 'Amit', 'age': 20, 'city': 'Mumbai'}

Unlike get(), which does not modify the dictionary when a key is missing, setdefault() inserts the missing key.

5.8 copy() Method

The copy() method creates a shallow copy of a dictionary. A shallow copy creates a new outer dictionary but does not recursively copy nested mutable objects.

original = {
    "name": "Priya",
    "skills": ["Python", "SQL"]
}

copied = original.copy()

copied["name"] = "Riya"
copied["skills"].append("Power BI")

print(original)
print(copied)

Output:

{'name': 'Priya', 'skills': ['Python', 'SQL', 'Power BI']}
{'name': 'Riya', 'skills': ['Python', 'SQL', 'Power BI']}

The outer dictionaries are separate, so changing copied["name"] does not change the original name. However, both dictionaries reference the same nested skills list, so modifying that list affects both.

5.9 clear() Method

The clear() method removes every key-value pair from a dictionary.

data = {
    "a": 10,
    "b": 20
}

data.clear()

print(data)

Output:

{}

5.10 fromkeys() Method

The fromkeys() class method creates a new dictionary from an iterable of keys, assigning the same value to each key.

subjects = ["Math", "Science", "English"]

marks = dict.fromkeys(subjects, 0)

print(marks)

Output:

{'Math': 0, 'Science': 0, 'English': 0}

Important: Avoid using the same mutable object as the default value when you intend each key to have an independent object.

# Avoid this pattern for independent lists
bad_data = dict.fromkeys(["A", "B"], [])

bad_data["A"].append(10)
print(bad_data)

Output:

{'A': [10], 'B': [10]}

Both keys refer to the same list. Use a dictionary comprehension to create a separate list for each key.

good_data = {key: [] for key in ["A", "B"]}

good_data["A"].append(10)

print(good_data)

Output:

{'A': [10], 'B': []}

5.11 Dictionary Methods Summary

6. Introduction to Nested Dictionaries

6.1 What Is a Nested Dictionary?

A nested dictionary is a dictionary that contains another dictionary as one of its values. This structure allows related information to be grouped into multiple levels.

Nested dictionaries are useful for storing multiple student records, employee details, product information, company departments, configuration settings, and structured JSON-like data.

students = {
    "student1": {
        "name": "Amit",
        "age": 20,
        "marks": 85
    },
    "student2": {
        "name": "Priya",
        "age": 21,
        "marks": 92
    }
}

print(students)

6.2 Accessing Values in Nested Dictionaries

To access an inner value, use the outer key followed by the key inside the nested dictionary.

students = {
    "student1": {
        "name": "Amit",
        "age": 20,
        "marks": 85
    },
    "student2": {
        "name": "Priya",
        "age": 21,
        "marks": 92
    }
}

print(students["student1"]["name"])
print(students["student2"]["marks"])
print(students["student1"]["age"])

Output:

Amit
92
20

Explanation:

• students["student1"] returns the first student's dictionary.
• students["student1"]["name"] retrieves the student's name.
• students["student2"]["marks"] retrieves the second student's marks.

6.3 Adding a New Nested Dictionary

You can add a new record by assigning a dictionary to a new outer key.

students = {
    "student1": {"name": "Amit", "marks": 85}
}

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

print(students)

Output:

{'student1': {'name': 'Amit', 'marks': 85}, 'student2': {'name': 'Priya', 'marks': 92}}

6.4 Updating Nested Dictionary Values

Access the relevant inner dictionary and update its value using the corresponding inner key.

employee = {
    "employee1": {
        "name": "Rahul",
        "salary": 40000,
        "department": "IT"
    }
}

employee["employee1"]["salary"] = 45000
employee["employee1"]["department"] = "Development"

print(employee)

Output:

{'employee1': {'name': 'Rahul', 'salary': 45000, 'department': 'Development'}}

6.5 Adding New Fields to a Nested Dictionary

employee = {
    "employee1": {
        "name": "Rahul",
        "salary": 45000
    }
}

employee["employee1"]["email"] = "[email protected]"
employee["employee1"]["city"] = "Mumbai"

print(employee["employee1"])

Output:

{'name': 'Rahul', 'salary': 45000, 'email': '[email protected]', 'city': 'Mumbai'}

6.6 Removing Values from Nested Dictionaries

You can use del or pop() to remove a particular field from an inner dictionary. You can also remove an entire nested record from the outer dictionary.

employees = {
    "emp1": {
        "name": "Amit",
        "salary": 40000,
        "department": "IT"
    },
    "emp2": {
        "name": "Neha",
        "salary": 45000,
        "department": "HR"
    }
}

# Remove one field from a nested record
del employees["emp1"]["department"]

# Remove an entire nested record
employees.pop("emp2")

print(employees)

Output:

{'emp1': {'name': 'Amit', 'salary': 40000}}

7. Iterating Through Nested Dictionaries

7.1 Using a for Loop

You can iterate through the outer dictionary to access each record and then retrieve individual fields.

students = {
    "S101": {"name": "Amit", "marks": 85},
    "S102": {"name": "Priya", "marks": 92},
    "S103": {"name": "Neha", "marks": 88}
}

for student_id, details in students.items():
    print("Student ID:", student_id)
    print("Name:", details["name"])
    print("Marks:", details["marks"])
    print()

Output:

Student ID: S101
Name: Amit
Marks: 85

Student ID: S102
Name: Priya
Marks: 92

Student ID: S103
Name: Neha
Marks: 88

7.2 Iterating Through All Inner Key-Value Pairs

Nested loops are useful when you need to display every field in every record.

employees = {
    "emp1": {"name": "Rahul", "department": "IT"},
    "emp2": {"name": "Priya", "department": "HR"}
}

for employee_id, details in employees.items():
    print(employee_id)

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

    print()

Output:

emp1
name : Rahul
department : IT

emp2
name : Priya
department : HR

8. Practical Example: Student Management System

This example demonstrates how dictionary methods and nested dictionaries can be used together to manage student records.

students = {
    "S101": {
        "name": "Amit",
        "marks": 85,
        "course": "Python"
    },
    "S102": {
        "name": "Priya",
        "marks": 92,
        "course": "Data Analytics"
    }
}

# Access an existing student's information
print("Student Name:", students["S101"]["name"])

# Update marks
students["S101"]["marks"] = 90

# Add a new field
students["S101"]["city"] = "Mumbai"

# Add a new student
students["S103"] = {
    "name": "Neha",
    "marks": 88,
    "course": "Web Development"
}

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

# Calculate the average marks
total_marks = sum(
    details["marks"] for details in students.values()
)

average_marks = total_marks / len(students)

print("Average Marks:", average_marks)

Output:

Student Name: Amit
S101 {'name': 'Amit', 'marks': 90, 'course': 'Python', 'city': 'Mumbai'}
S102 {'name': 'Priya', 'marks': 92, 'course': 'Data Analytics'}
S103 {'name': 'Neha', 'marks': 88, 'course': 'Web Development'}
Average Marks: 90.0

What this example demonstrates:

• Accessing nested values.
• Updating existing student marks.
• Adding a new field to a nested dictionary.
• Adding a complete student record.
• Iterating over records using items().
• Calculating an average using values from nested dictionaries.

9. Practical Example: Product Inventory

A product inventory system can use a nested dictionary to organize products by their unique IDs and store their names, prices, and quantities.

inventory = {
    "P101": {
        "name": "Laptop",
        "price": 55000,
        "quantity": 5
    },
    "P102": {
        "name": "Mouse",
        "price": 700,
        "quantity": 20
    },
    "P103": {
        "name": "Keyboard",
        "price": 1500,
        "quantity": 10
    }
}

# Update the quantity of a product
inventory["P102"]["quantity"] += 5

# Add a new product
inventory["P104"] = {
    "name": "Monitor",
    "price": 12000,
    "quantity": 8
}

# Display product information
for product_id, details in inventory.items():
    print(
        product_id,
        details["name"],
        details["price"],
        details["quantity"]
    )

# Calculate total inventory value
total_value = sum(
    details["price"] * details["quantity"]
    for details in inventory.values()
)

print("Total Inventory Value:", total_value)

Output:

P101 Laptop 55000 5
P102 Mouse 700 25
P103 Keyboard 1500 10
P104 Monitor 12000 8
Total Inventory Value: 451500

This approach keeps related product information together and makes inventory updates straightforward.

10. Handling Missing Keys Safely

When working with nested dictionaries, a key may be missing at the outer or inner level. Accessing a missing key with square brackets raises a KeyError.

10.1 Using get() for Nested Data

student = {
    "name": "Amit",
    "address": {
        "city": "Mumbai",
        "country": "India"
    }
}

city = student.get("address", {}).get("city", "Unknown")

print(city)

Output:

Mumbai

The empty dictionary supplied as the default allows the second get() call to work if the address key is missing.

Important: This pattern assumes that address is either a dictionary or missing. If it exists but contains a different type, additional validation may be needed.

10.2 Checking Whether a Key Exists

Use the in operator to check whether a key exists in a dictionary.

employee = {
    "name": "Riya",
    "department": "IT"
}

if "department" in employee:
    print("Department:", employee["department"])
else:
    print("Department not found")

Output:

Department: IT

For nested dictionaries, check each level before accessing deeper values if the structure is not guaranteed.

data = {
    "employee": {
        "name": "Riya"
    }
}

if "employee" in data and "salary" in data["employee"]:
    print(data["employee"]["salary"])
else:
    print("Salary information is unavailable")

Output:

Salary information is unavailable

11. Dictionary Comprehensions

A dictionary comprehension is a concise way to create a dictionary from an iterable. It is useful for transforming data, filtering entries, and generating nested structures.

11.1 Basic Dictionary Comprehension

squares = {number: number ** 2 for number in range(1, 6)}

print(squares)

Output:

{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

11.2 Filtering Dictionary Entries

marks = {
    "Amit": 85,
    "Priya": 92,
    "Neha": 68,
    "Rahul": 75
}

passed_students = {
    name: score
    for name, score in marks.items()
    if score >= 75
}

print(passed_students)

Output:

{'Amit': 85, 'Priya': 92, 'Rahul': 75}

11.3 Creating a Nested Dictionary with a Comprehension

students = ["Amit", "Priya", "Neha"]

student_records = {
    name: {"marks": 0, "status": "Not graded"}
    for name in students
}

print(student_records)

Output:

{'Amit': {'marks': 0, 'status': 'Not graded'}, 'Priya': {'marks': 0, 'status': 'Not graded'}, 'Neha': {'marks': 0, 'status': 'Not graded'}}

Each comprehension iteration creates a new inner dictionary, so the student records do not share the same nested dictionary object.

12. Common Mistakes and Troubleshooting

Mistake 1: Accessing a Missing Key

student = {"name": "Amit"}

# Raises KeyError:
# print(student["age"])

# Safer alternative:
print(student.get("age", "Not available"))

Solution: Use get() or check for the key before accessing it.

Mistake 2: Confusing Keys and Values

data = {"name": "Priya", "age": 22}

print(data.keys())
print(data.values())
print(data.items())

Solution: Remember that keys() returns keys, values() returns values, and items() returns key-value pairs.

Mistake 3: Updating the Wrong Dictionary Level

student = {
    "details": {
        "name": "Amit",
        "marks": 80
    }
}

student["details"]["marks"] = 95

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

Solution: Follow the dictionary structure and access the appropriate inner key.

Mistake 4: Using Mutable Dictionary Keys

# Invalid: lists cannot be dictionary keys
# data = {[1, 2]: "value"}

# Valid: tuple of hashable integers
data = {(1, 2): "value"}

print(data[(1, 2)])

Solution: Use hashable keys such as strings, integers, or suitable tuples.

Mistake 5: Assuming copy() Deep-Copies Nested Data

original = {"scores": [80, 90]}
copied = original.copy()

copied["scores"].append(100)

print(original["scores"])

Output:

[80, 90, 100]

Solution: Use copy.deepcopy() from Python's copy module when a recursive independent copy of nested mutable objects is required.

import copy

original = {"scores": [80, 90]}
copied = copy.deepcopy(original)

copied["scores"].append(100)

print(original["scores"])
print(copied["scores"])

Output:

[80, 90]
[80, 90, 100]

Mistake 6: Modifying a Dictionary While Iterating Over It

Adding or removing dictionary entries while iterating over a dictionary view can raise a RuntimeError or produce unexpected results.

scores = {"Amit": 80, "Priya": 90, "Neha": 70}

# Iterate over a snapshot of the keys
for name in list(scores.keys()):
    if scores[name] < 75:
        del scores[name]

print(scores)

Output:

{'Amit': 80, 'Priya': 90}

Solution: Iterate over a list of keys or a separate copy when removing entries during traversal.

13. Best Practices for Working with Dictionaries

• Use descriptive keys that clearly represent their values.
• Use get() when a key may not exist.
• Use items() to iterate over keys and values together.
• Use update() when adding or changing several fields.
• Keep nested dictionary structures consistent across records.
• Validate data types before accessing deeply nested values.
• Avoid duplicate keys when creating dictionary literals because later values replace earlier values for the same key.
• Use copy.deepcopy() when an independent recursive copy is necessary.
• Use dictionary comprehensions for simple transformations and filters.
• Choose a list or another data structure if you need repeated keys or ordered entries with duplicate labels.
• Avoid modifying a dictionary's size while iterating directly over its live views.
• Use clear variable names for outer dictionaries and inner records.

14. Hands-On Practice Exercises

Exercise 1: Dictionary Creation

Create a dictionary containing your name, age, city, and favorite programming language. Print each value using its key.

Exercise 2: Dictionary Methods

Create a dictionary of five products and their prices. Use keys(), values(), and items() to display the stored information.

Exercise 3: Update and Remove Entries

Create an employee dictionary. Update the salary using update(), remove a field using pop(), and display the final dictionary.

Exercise 4: Nested Student Records

Create a nested dictionary for three students. Store each student's name, marks, and course. Print each student's information using a loop.

Exercise 5: Product Inventory

Create a nested dictionary containing product names, prices, and quantities. Update a product quantity and calculate the total inventory value.

Exercise 6: Missing-Key Handling

Create a dictionary with employee information. Retrieve an optional email field using get() and display a default message if the field is missing.

Exercise 7: Dictionary Comprehension

Create a dictionary containing numbers from 1 to 10 as keys and their cubes as values. Then create another dictionary containing only the cubes greater than 100.

Exercise 8: Mini Project — Employee Management System

Build a simple employee management program using nested dictionaries. Each employee should have an ID, name, department, salary, and city.

Your program should support the following tasks:

• Add a new employee.
• Display all employees.
• Update an employee's salary.
• Search for an employee by ID.
• Remove an employee record.
• Calculate the total salary expenditure.

15. Interview Questions and Answers

Q1. What is a dictionary in Python?

Answer: A dictionary is a mutable mapping that stores key-value pairs and allows values to be retrieved using their keys.

Q2. What is the difference between get() and square-bracket access?

Answer: Square-bracket access raises a KeyError if a key is missing. The get() method returns None or a supplied default value.

Q3. What does the items() method return?

Answer: It returns a dynamic view of the dictionary's key-value pairs, which can be unpacked into two variables during iteration.

Q4. What is the purpose of update()?

Answer: The update() method adds new entries and replaces values for existing keys.

Q5. What is a nested dictionary?

Answer: A nested dictionary is a dictionary containing other dictionaries as values. It is useful for organizing hierarchical or grouped information.

Q6. How can you access a value inside a nested dictionary?

Answer: Use successive keys, such as data["employee"]["name"], to access a field inside an inner dictionary.

Q7. What is the difference between pop() and popitem()?

Answer: pop() removes a specified key, while popitem() removes and returns the last inserted key-value pair.

Q8. What does setdefault() do?

Answer: It returns a key's existing value or inserts the key with a specified default when the key is missing.

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

Answer: copy() creates a shallow copy, so nested objects may still be shared. deepcopy() recursively copies nested objects when possible.

Q10. Can a dictionary contain a list as a value?

Answer: Yes. Dictionary values can be lists, tuples, sets, other dictionaries, and many other objects.

Q11. Can a list be used as a dictionary key?

Answer: No. Lists are unhashable because they are mutable. Dictionary keys must be hashable.

Q12. How do you iterate through a nested dictionary?

Answer: Use an outer loop to access each record and an inner loop to access each record's fields.

Q13. What does clear() do?

Answer: The clear() method removes all key-value pairs from the dictionary.

Q14. What is a dictionary comprehension?

Answer: A dictionary comprehension is a concise way to construct a dictionary from an iterable, optionally transforming or filtering its elements.

Q15. Do Python dictionaries preserve insertion order?

Answer: Yes. Python guarantees insertion order for dictionaries. Updating an existing key does not move it to a new position, while deleting and reinserting a key places it at the end.

16. Quick Revision Checklist

• A dictionary stores key-value pairs.
• Dictionary keys must be unique and hashable.
• Dictionaries are mutable and preserve insertion order.
• get() retrieves a value with an optional default.
• keys(), values(), and items() return dynamic views.
• update() adds or updates entries.
• pop() removes a specified key.
• popitem() removes the last inserted pair.
• setdefault() inserts a missing key with a default value.
• copy() creates a shallow copy.
• clear() removes all dictionary entries.
• Nested dictionaries store structured information at multiple levels.
• Nested values can be accessed through successive keys.
• Dictionary comprehensions simplify data transformations.
• Safe key handling helps prevent common runtime errors.

17. Conclusion

Python dictionary methods provide convenient ways to retrieve, update, inspect, copy, and remove key-value pairs. Methods such as get(), items(), update(), pop(), and setdefault() make dictionary operations easier to understand and maintain.

Nested dictionaries extend these capabilities by allowing related records and hierarchical data to be stored in a structured format. They are especially useful in student management systems, employee databases, inventory applications, and API data processing.

By practicing dictionary methods, nested access, iteration, error handling, and dictionary comprehensions, you can build a strong foundation for more advanced Python programming and real-world software development.

18. Learn Python with JustAcademy

Explore the Python Training Course to continue learning programming concepts, practical coding techniques, and real-world applications.

Python Training Course: Explore Python Training at JustAcademy

Course Demo Registration: Register for a Course Demo

Official Website: Visit JustAcademy