Python – Change Keys Case in Dictionary
Last Updated :
10 May, 2023
Sometimes, while working with Python dictionaries, we can have a problem in which we need to perform manipulation of cases of keys. This can have possible application in many domains including school programming and data domains. Lets discuss a way to solve this task.
Input : test_dict = {‘Gfg’ : {‘a’ : 5, ‘b’ : {‘best’ : 6}}}
Output : {‘GFG’: {‘A’: 5, ‘B’: {‘BEST’: 6}}}
Input : test_dict = {‘Gfg’ : 6}
Output : {‘GFG’: 6}
Method 1: Using isinstance() + upper() + recursion + loop The combination of above functions can also be used to solve this problem. In this, we use upper() to perform upper case of keys, recursion is used to perform keys manipulation in nested keys as well. The isinstance() is used to check if nesting is dictionary.
Python3
def keys_upper(test_dict):
res = dict ()
for key in test_dict.keys():
if isinstance (test_dict[key], dict ):
res[key.upper()] = keys_upper(test_dict[key])
else :
res[key.upper()] = test_dict[key]
return res
test_dict = { 'Gfg' : { 'a' : 5 , 'b' : 6 }, 'is' : { 'for' : 2 }, 'best' : 3 }
print ("The original dictionary : " + str (test_dict))
res = keys_upper(test_dict)
print ("The modified dictionary : " + str (res))
|
Output :
The original dictionary : {'is': {'for': 2}, 'Gfg': {'b': 6, 'a': 5}, 'best': 3}
The modified dictionary : {'GFG': {'A': 5, 'B': 6}, 'IS': {'FOR': 2}, 'BEST': 3}
Time Complexity: O(n), where n is the length of the list test_dict
Auxiliary Space: O(n) additional space of size n is created where n is the number of elements in the res list
Method 2: Using type() + upper() + recursion + loop
Approach
The combination of above functions can also be used to solve this problem. In this, we use upper() to perform upper case of keys, recursion is used to perform keys manipulation in nested keys as well. The type() is used to check if nesting is dictionary.
Python3
def keys_upper(test_dict):
res = dict ()
for key in test_dict.keys():
if type (test_dict[key]) is dict :
res[key.upper()] = keys_upper(test_dict[key])
else :
res[key.upper()] = test_dict[key]
return res
test_dict = { 'Gfg' : { 'a' : 5 , 'b' : 6 }, 'is' : { 'for' : 2 }, 'best' : 3 }
print ( "The original dictionary : " + str (test_dict))
res = keys_upper(test_dict)
print ( "The modified dictionary : " + str (res))
|
Output
The original dictionary : {'Gfg': {'a': 5, 'b': 6}, 'is': {'for': 2}, 'best': 3}
The modified dictionary : {'GFG': {'A': 5, 'B': 6}, 'IS': {'FOR': 2}, 'BEST': 3}
Time Complexity : O(N)
Auxiliary Space : O(N)
Method 3: using dictionary comprehension and the str.upper() method:
This method uses a dictionary comprehension to create a new dictionary where all keys are converted to upper case. If a value is itself a dictionary, the function is called recursively to convert the keys in the nested dictionary as well. If the value is not a dictionary, it is left unchanged.
Python3
def keys_upper(test_dict):
return {k.upper(): keys_upper(v) if isinstance (v, dict ) else v for k, v in test_dict.items()}
test_dict = { 'Gfg' : { 'a' : 5 , 'b' : 6 }, 'is' : { 'for' : 2 }, 'best' : 3 }
res = keys_upper(test_dict)
print (res)
|
Output
{'GFG': {'A': 5, 'B': 6}, 'IS': {'FOR': 2}, 'BEST': 3}
Time complexity: O(N), where N is the total number of keys in all nested dictionaries, because each key needs to be checked and potentially converted to upper case.
Auxiliary space: O(N), because a new dictionary is created with the same number of keys as the original dictionary.
Method 5: Using map() and lambda function
Step-by-step approach:
- Define a function called change_keys_case() that takes a dictionary as an argument.
- Inside the function, create a new dictionary by mapping the keys of the original dictionary to uppercase using a lambda function.
- For each key-value pair in the original dictionary, check if the value is a nested dictionary. If it is, call the change_keys_case() function recursively on the nested dictionary.
- Return the modified dictionary.
Python3
def change_keys_case(test_dict):
new_dict = dict ( map ( lambda x: (x[ 0 ].upper(), x[ 1 ]), test_dict.items()))
for key, value in new_dict.items():
if isinstance (value, dict ):
new_dict[key] = change_keys_case(value)
return new_dict
test_dict = { 'Gfg' : { 'a' : 5 , 'b' : 6 }, 'is' : { 'for' : 2 }, 'best' : 3 }
print ( "The original dictionary : " + str (test_dict))
res = change_keys_case(test_dict)
print ( "The modified dictionary : " + str (res))
|
Output
The original dictionary : {'Gfg': {'a': 5, 'b': 6}, 'is': {'for': 2}, 'best': 3}
The modified dictionary : {'GFG': {'A': 5, 'B': 6}, 'IS': {'FOR': 2}, 'BEST': 3}
The time complexity of this method is O(n), where n is the number of keys in the dictionary.
The auxiliary space complexity is O(n) as well, as a new dictionary is created and the function is called recursively for each nested dictionary.
Share your thoughts in the comments
Please Login to comment...