🏗️ Multi-level Dictionaries

Multi-level dictionaries enable sophisticated data organization by nesting dictionaries within dictionaries. This structure is perfect for representing complex relationships like user profiles with settings, organizational hierarchies, or configuration systems with multiple categories.

# Complex user profile with nested structure
user_profile = {
    'personal': {
        'name': 'Alice Johnson',
        'age': 28,
        'location': 'Boston'
    },
    'account': {
        'username': 'alice_j',
        'email': 'alice@example.com',
        'verified': True
    },
    'preferences': {
        'theme': 'dark',
        'notifications': True,
        'privacy': {'profile_public': False, 'show_email': False}
    }
}

print("User name:", user_profile['personal']['name'])
print("Email verified:", user_profile['account']['verified'])

🎯 Accessing Nested Data

Working with nested dictionaries requires understanding how to navigate through multiple levels safely. Python provides straightforward syntax for accessing deeply nested values.

company = {
    'departments': {
        'engineering': {
            'manager': 'Sarah Chen',
            'employees': 15,
            'budget': 500000
        },
        'marketing': {
            'manager': 'John Davis',
            'employees': 8,
            'budget': 200000
        }
    },
    'company_info': {
        'name': 'TechCorp',
        'founded': 2010
    }
}

# Access nested values
eng_manager = company['departments']['engineering']['manager']
total_employees = (company['departments']['engineering']['employees'] + 
                  company['departments']['marketing']['employees'])

print(f"Engineering manager: {eng_manager}")
print(f"Total employees: {total_employees}")

⚡ Safe Nested Access with get()

The get() method provides safe access to nested dictionary values, preventing KeyError exceptions when keys might not exist. This approach enables robust data processing with unpredictable data structures.

data = {
    'user1': {
        'profile': {'name': 'Alice', 'age': 25},
        'settings': {'theme': 'dark'}
    },
    'user2': {
        'profile': {'name': 'Bob'}
        # Missing 'settings' section
    }
}

# Safe access with defaults
def get_user_theme(user_id):
    user = data.get(user_id, {})
    settings = user.get('settings', {})
    return settings.get('theme', 'light')  # Default theme

print("User1 theme:", get_user_theme('user1'))
print("User2 theme:", get_user_theme('user2'))
print("User3 theme:", get_user_theme('user3'))

🚀 Building Nested Dictionaries

Creating multi-level dictionaries requires systematic approaches to ensure proper structure initialization. Using setdefault() helps build nested structures safely.

# Build nested structure dynamically
inventory = {}

def add_product(category, subcategory, product, quantity):
    """Add product to nested inventory structure"""
    inventory.setdefault(category, {})
    inventory[category].setdefault(subcategory, {})
    inventory[category][subcategory][product] = quantity

# Add various products
add_product('electronics', 'computers', 'laptop', 25)
add_product('electronics', 'phones', 'smartphone', 50)
add_product('clothing', 'men', 'shirt', 100)
add_product('clothing', 'women', 'dress', 75)

print("Inventory structure:", inventory)

🌟 Modifying Nested Values

Updating nested dictionary values requires careful navigation to the target location. The code demonstrates various modification patterns for different scenarios.

config = {
    'database': {
        'primary': {'host': 'localhost', 'port': 5432},
        'backup': {'host': 'backup.db.com', 'port': 5433}
    },
    'cache': {
        'redis': {'enabled': True, 'ttl': 3600}
    }
}

# Direct modification
config['database']['primary']['port'] = 5434
config['cache']['redis']['ttl'] = 7200

# Add new nested sections
config.setdefault('logging', {})
config['logging']['level'] = 'INFO'
config['logging']['file'] = '/var/log/app.log'

print("Updated config:", config)

📚 Nested Dictionary Operations Table

Operation	Syntax	Purpose	Safety Level
Direct access	`dict[key1][key2]`	Fast access to known paths	Low - raises KeyError
Safe access	`dict.get(key1, {}).get(key2)`	Safe access with defaults	High - returns None/default
Building structure	`dict.setdefault(key1, {})`	Initialize nested levels	High - creates if missing
Deep update	`dict[key1].update(new_data)`	Merge into nested dict	Medium - requires existing path

🔄 Iterating Through Nested Dictionaries

Processing multi-level dictionaries requires recursive or systematic approaches to traverse all levels effectively. Here we explore different iteration strategies.

school_data = {
    'grade_1': {
        'class_a': {'students': 25, 'teacher': 'Ms. Smith'},
        'class_b': {'students': 23, 'teacher': 'Mr. Jones'}
    },
    'grade_2': {
        'class_a': {'students': 27, 'teacher': 'Ms. Wilson'},
        'class_b': {'students': 24, 'teacher': 'Mr. Brown'}
    }
}

# Calculate total students
total_students = 0
for grade, classes in school_data.items():
    for class_name, info in classes.items():
        total_students += info['students']
        print(f"{grade} {class_name}: {info['students']} students")

print(f"Total students: {total_students}")

💡 Recursive Operations

Recursive functions handle arbitrary nesting levels, making them perfect for processing complex hierarchical data structures.

def count_nested_items(nested_dict):
    """Count total items at all nesting levels"""
    count = 0
    for key, value in nested_dict.items():
        count += 1
        if isinstance(value, dict):
            count += count_nested_items(value)
    return count

def find_all_values(nested_dict, target_key):
    """Find all values for a specific key at any nesting level"""
    results = []
    for key, value in nested_dict.items():
        if key == target_key:
            results.append(value)
        elif isinstance(value, dict):
            results.extend(find_all_values(value, target_key))
    return results

# Test recursive operations
test_data = {
    'section1': {
        'name': 'First Section',
        'subsection': {
            'name': 'Sub Section',
            'data': {'name': 'Deep Data'}
        }
    },
    'section2': {'name': 'Second Section'}
}

total_items = count_nested_items(test_data)
all_names = find_all_values(test_data, 'name')

print(f"Total nested items: {total_items}")
print(f"All names found: {all_names}")

📊 Flattening Nested Dictionaries

Converting nested structures to flat dictionaries simplifies data processing for analysis and reporting applications.

def flatten_dict(nested_dict, parent_key='', separator='_'):
    """Flatten nested dictionary into single-level structure"""
    items = []
    for key, value in nested_dict.items():
        new_key = f"{parent_key}{separator}{key}" if parent_key else key
        
        if isinstance(value, dict):
            items.extend(flatten_dict(value, new_key, separator).items())
        else:
            items.append((new_key, value))
    
    return dict(items)

# Flatten complex structure
nested_config = {
    'database': {
        'host': 'localhost',
        'credentials': {'username': 'admin', 'password': 'secret'}
    },
    'cache': {'enabled': True, 'ttl': 300}
}

flat_config = flatten_dict(nested_config)
print("Flattened config:", flat_config)

🛠️ Practical Applications

Configuration Systems

Multi-level dictionaries excel at organizing complex application settings with hierarchical relationships.

app_config = {
    'server': {
        'host': '0.0.0.0',
        'port': 8080,
        'ssl': {'enabled': True, 'cert_path': '/path/to/cert'}
    },
    'database': {
        'primary': {'host': 'db1.example.com', 'port': 5432},
        'replica': {'host': 'db2.example.com', 'port': 5432}
    },
    'features': {
        'authentication': {'enabled': True, 'method': 'oauth'},
        'caching': {'enabled': True, 'backend': 'redis'}
    }
}

# Access specific configuration values
ssl_enabled = app_config['server']['ssl']['enabled']
auth_method = app_config['features']['authentication']['method']

print(f"SSL enabled: {ssl_enabled}")
print(f"Auth method: {auth_method}")

Data Analysis Hierarchies

Nested dictionaries organize analytical data with natural hierarchical relationships.

sales_data = {
    '2024': {
        'Q1': {'January': 45000, 'February': 52000, 'March': 48000},
        'Q2': {'April': 55000, 'May': 61000, 'June': 58000}
    },
    '2023': {
        'Q4': {'October': 42000, 'November': 47000, 'December': 65000}
    }
}

# Calculate quarterly totals
def calculate_quarterly_total(year, quarter):
    quarter_data = sales_data.get(year, {}).get(quarter, {})
    return sum(quarter_data.values())

q1_2024 = calculate_quarterly_total('2024', 'Q1')
q2_2024 = calculate_quarterly_total('2024', 'Q2')

print(f"2024 Q1 total: ${q1_2024:,}")
print(f"2024 Q2 total: ${q2_2024:,}")

Hands-on Exercise

Create a function that safely gets information from a nested dictionary representing a student's data. The structure is: student['info']['name'] and student['grades']['math']. Use get() methods to avoid errors.

python

def get_student_summary(student_data):
    # TODO: Safely get the student's name and math grade
    # TODO: Return a formatted string with the information
    # TODO: Use 'Unknown' and 'No grade' as defaults
    pass

# Test data
student1 = {
    'info': {'name': 'Alice', 'age': 16},
    'grades': {'math': 85, 'science': 90}
}

student2 = {
    'info': {'name': 'Bob'},
    # Missing grades section
}

student3 = {}  # Empty data

print(get_student_summary(student1))
print(get_student_summary(student2))
print(get_student_summary(student3))

Solution and Explanation 💡

Click to see the complete solution

def get_student_summary(student_data):
    # Safely navigate nested structure with get()
    info = student_data.get('info', {})
    grades = student_data.get('grades', {})
    
    # Get name and math grade with defaults
    name = info.get('name', 'Unknown')
    math_grade = grades.get('math', 'No grade')
    
    # Return formatted summary
    return f"Student: {name}, Math grade: {math_grade}"

# Test data
student1 = {
    'info': {'name': 'Alice', 'age': 16},
    'grades': {'math': 85, 'science': 90}
}

student2 = {
    'info': {'name': 'Bob'},
    # Missing grades section
}

student3 = {}  # Empty data

print(get_student_summary(student1))
print(get_student_summary(student2))
print(get_student_summary(student3))

Key Learning Points:

📌 Nested get() usage: Use get() at each level to safely navigate nested dictionaries
📌 Default values: Provide meaningful defaults for missing data at any level
📌 Intermediate variables: Store intermediate dictionary levels for cleaner access
📌 Safe navigation: Handle missing or incomplete nested structures gracefully

Learn more about dictionary tools to discover powerful built-in functions for advanced dictionary manipulation.

Test Your Knowledge

Test what you've learned about multi-level dictionaries:

What's Next?

Now that you can work with complex nested structures, you're ready to learn about powerful dictionary tools. Understanding built-in functions will make your dictionary operations more efficient and elegant.

Ready to continue? Check out our lesson on Dictionary Tools.

Online Python

🏗️ Multi-level Dictionaries

Hands-on Exercise

Track Your Learning Progress