← Back to Python Course | Chapter 6: Data Structures | Lesson 12 of 12

Python Nested Dictionaries

A dictionary's values can be anything -- including another dictionary -- and this is exactly how you represent hierarchical, structured data in Python: a dictionary of dictionaries, like a collection of user profiles each holding their own name, age, and address fields, mirrors real-world nested data naturally.

In this page:

  1. Creating a Nested Dictionary
  2. Accessing Nested Values
  3. Modifying Nested Dictionary Values
  4. Looping Over a Nested Dictionary
  5. The Shallow Copy Trap with Nested Dictionaries
Syntax
python 
nested_dict = {
    key1: {inner_key: value},
    key2: {inner_key: value}
}
nested_dict[key1][inner_key]

Creating a Nested Dictionary

A nested dictionary is written just like a regular dictionary literal, except one or more of its values are themselves dictionary literals -- {"sam": {"age": 28, "city": "Austin"}} represents a single user's data nested one level inside an outer dictionary keyed by username.

Note: Format a nested dictionary literal across multiple lines with consistent indentation, making its hierarchical structure easy to read at a glance.
Warning: A deeply nested dictionary literal with many levels can become visually hard to read if not formatted with clear indentation.

Example: Creating a Nested Dictionary

python 
data = {"sam": {"age": 28, "city": "Austin"}}
print(data)

Accessing Nested Values

Reaching a deeply nested value means chaining square-bracket lookups one level at a time -- data["users"]["sam"]["address"]["city"] walks through three levels of nesting to reach the final value, in the exact order the structure is nested.

Note: Read a chained nested lookup from left to right as "go into this key, then into that key, then that one" to keep track of which level you are navigating.
Warning: A missing key at ANY level in the chain (not just the final one) raises a KeyError at that specific level, which can be confusing if you assumed only the last key might be missing.

Example: Accessing Nested Values

python 
data = {"users": {"sam": {"address": {"city": "Austin"}}}}
print(data["users"]["sam"]["address"]["city"])

Modifying Nested Dictionary Values

Updating a value inside a nested dictionary uses the same chained bracket syntax as reading it -- data["users"]["sam"]["age"] = 29 reaches into the nested structure and updates just that one specific value, leaving the rest of the structure untouched.

Note: Before modifying a deeply nested value, confirm every intermediate level already exists, or the assignment will raise a KeyError rather than automatically creating the missing levels.
Warning: Unlike some languages, Python does not automatically create missing intermediate dictionaries when you assign to a deeply nested path -- every level must already exist first.

Example: Modifying Nested Dictionary Values

python 
data = {"users": {"sam": {"age": 28}}}
data["users"]["sam"]["age"] = 29  # chained brackets reach into the nested dict
print(data)

Looping Over a Nested Dictionary

Looping over a nested dictionary typically means an outer loop over the top-level keys, with an inner loop (or direct access) handling each nested dictionary's own keys and values -- letting you process every piece of hierarchical data systematically.

Note: Use .items() at each level of the loop to get both the key and the nested value together, rather than looking up the value separately after getting just the key.
Warning: Forgetting that each iteration's value at the outer level IS itself a dictionary (not a plain value) is a common source of confusion when first looping over nested data.

Example: Looping Over a Nested Dictionary

python 
users = {"sam": {"age": 28}, "alex": {"age": 30}}
for name, info in users.items():  # outer loop over each user
    print(name, info["age"])  # info is the nested dict for that user

The Shallow Copy Trap with Nested Dictionaries

Copying an outer dictionary with .copy() (or dict()) only copies the top level -- any nested dictionaries inside remain shared references between the original and the copy, meaning a change to a nested value through the copy still affects the original. copy.deepcopy() is needed for a genuinely independent copy.

Note: Use copy.deepcopy() specifically when you need a nested dictionary structure to be fully independent from the original, not just its top level.
Warning: Modifying a nested value through a shallow-copied dictionary silently also changes the original, since the nested dictionary itself was never actually duplicated.

Example: The Shallow Copy Trap with Nested Dictionaries

python 
import copy
original = {"user": {"age": 28}}
shallow = original.copy()
shallow["user"]["age"] = 99
print(original["user"]["age"])  # also changed

deep = copy.deepcopy(original)
deep["user"]["age"] = 1
print(original["user"]["age"])  # unaffected
Related Topics

Python Dictionaries · Python Nested Data Structures · Python Nested If · Python Frozenset

{# common_mistakes/chapter_summary/browser_support: on Hindi pages the view already swaps in the hi_ translation fields (or blanks these out if untranslated), so this renders correctly for both languages without a lang_code check here. #}
Common Mistakes
  1. Assuming a nested dictionary is copied independently when you copy the outer one with a shallow copy() -- the inner dictionaries remain shared references, not independent copies.
  2. Chaining several key lookups (data["users"]["sam"]["address"]) without checking each level actually exists first, risking a KeyError partway through the chain.
  3. Confusing a nested dictionary's structure with a list of dictionaries -- they solve different problems and are not interchangeable without restructuring.
Chapter Summary
  • A nested dictionary is simply a dictionary whose values are themselves dictionaries, letting you represent hierarchical data naturally.
  • Accessing a deeply nested value chains multiple square-bracket lookups: data["outer_key"]["inner_key"].
  • Nested dictionaries can be built directly as a literal, or constructed incrementally by assigning dictionary values to keys.
Browser Support

Nested dictionaries are a natural consequence of core dict support, available in every Python version.

🔒

Chapter Quiz — Complete all 12 topics to unlock

0/12 topics done

Complete these topics first:

← Previous Lesson Python Dict Comprehension Next Lesson → Python Nested Data Structures

Login to run this code

C/C++/Java/PHP execution requires a free account. Your code is saved — you'll land right back in the editor after logging in.