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.
Comments
There are no comments yet.