Modify Values by Key in Python Nested Dictionary

Python is a powerful programming language, offers an array of data structures to handle complex information. One such structure is the nested dictionary, a collection of dictionaries within a dictionary. In this article, we go through a Python script that showcases the use of nested dictionaries and introduces two functions for modifying their values.

Understanding the Nested Dictionary

The provided Python script begins by defining a nested dictionary named nested_dict. This dictionary encapsulates information about two individuals, ‘Alice’ and ‘Bob’. Each person is represented as a sub-dictionary containing attributes such as name, age, hobbies, and addresses. Notably, the addresses are stored as a list of dictionaries, each detailing the city, street, and zipcode.

nested_dict = {
    'person1': {
        'name': 'Alice',
        'age': 30,
        'hobbies': ['reading', 'traveling', 'painting'],
        'addresses': [
            {
            'city': 'Wonderland',
            'street': '123 Dream Lane',
            'zipcode': '56789'
            }
        ],
    },
    'person2': {
        'name': 'Bob',
        'age': 29,
        'hobbies': ['footbal', 'cricket', 'swimming'],
        'addresses': [
            {
            'city': 'DxDolds',
            'street': '213 Sky Lane',
            'zipcode': '43456'
            }
        ],
    }
}

This structure provides a comprehensive way to organize and access information, especially when dealing with complex datasets.

Modifying Values in a Nested Dictionary

The script introduces two functions, update_value_for_key and update_value_for_new_key, designed to modify values associated with a specified key within the nested dictionary. Let’s explore each function in detail.

Function 1: update_value_for_key

The first function, update_value_for_key, adopts a recursive approach to traverse the nested dictionary. It checks if the target key exists in the current dictionary level and, if found, updates the associated value. This function employs a pass-by-reference mechanism, meaning it directly alters the original dictionary.

def update_value_for_key(json_obj, target_key, target_val):
    if isinstance(json_obj, dict):
        if target_key in json_obj:
            json_obj[target_key] = target_val
        for value in json_obj.values():
            update_value_for_key(value, target_key, target_val)
    elif isinstance(json_obj, list):
        for item in json_obj:
            update_value_for_key(item, target_key, target_val)

To illustrate the function, the script calls update_value_for_key to change the ‘zipcode’ value in the original nested_dict:

# Do change the original dict because pass by reference
update_value_for_key(nested_dict, "zipcode", "12453")
print(nested_dict)

This modification directly affects the original data, showcasing the power of pass-by-reference in Python.

Function 2: update_value_for_new_key

The second function, update_value_for_new_key, takes a different approach by creating a deep copy of the original nested dictionary using copy.deepcopy. This function then modifies the copied data, leaving the original dictionary untouched. The deep copy ensures that the new object in memory has no shared references with the original data.

import copy

def update_value_for_new_key(json_obj, target_key, target_val):
    if isinstance(json_obj, dict):
        if target_key in json_obj:
            json_obj[target_key] = target_val
        for value in json_obj.values():
            update_value_for_new_key(value, target_key, target_val)
    elif isinstance(json_obj, list):
        for item in json_obj:
            update_value_for_new_key(item, target_key, target_val)
    return json_obj

To demonstrate the difference, the script calls update_value_for_new_key with a deep copy of nested_dict:

# Doesn't change original dict because deep copy
new_json_obj = update_value_for_new_key(copy.deepcopy(nested_dict), "zipcode", "50000")
print(new_json_obj)

This time, the modification occurs on the copied data, leaving the original dictionary intact.

Conclusion

In summary, the provided Python script introduces the concept of nested dictionaries and demonstrates how to manipulate their values using two distinct approaches. The pass-by-reference mechanism in the first function, update_value_for_key, allows direct modification of the original dictionary. On the other hand, the second function, update_value_for_new_key, utilizes a deep copy to create a modified version of the data, leaving the original untouched.

Understanding these techniques is crucial when working with complex data structures in Python, offering flexibility in managing information without compromising the integrity of the original dataset. Whether modifying values in place or creating a modified copy, Python’s versatility shines through in handling nested dictionaries efficiently.