Snowflake Note

Dictionary in Python
is a collection of keys values, used to store data values like a map, which, unlike
other data types which hold only a single value as an element.
Example of Dictionary in Python
Dictionary holds key:value pair. Key-Value is provided in the dictionary to make it more optimized.
Python3
Dict = {1: 'Geeks', 2: 'For', 3: 'Geeks'}
print(Dict)
Output:
{1: 'Geeks', 2: 'For', 3: 'Geeks'}
Creating a Dictionary
In Python, a dictionary can be created by placing a sequence of elements within curly {} braces,

separated by ‘comma’. Dictionary holds pairs of values, one being the Key and the other
corresponding pair element being its Key:value. Values in a dictionary can be of any data type and
can be duplicated, whereas keys can’t be repeated and must be immutable.
Note – Dictionary keys are case sensitive, the same name but different cases of Key will be treated
distinctly.
Python3
# Creating a Dictionary
# with Integer Keys
Dict = {1: 'Geeks', 2: 'For', 3: 'Geeks'}
print("\nDictionary with the use of Integer Keys: ")
print(Dict)

# with Mixed keys
Dict = {'Name': 'Geeks', 1: [1, 2, 3, 4]}
print("\nDictionary with the use of Mixed Keys: ")
print(Dict)
Output:
Dictionary with the use of Integer Keys:
{1: 'Geeks', 2: 'For', 3: 'Geeks'}

Dictionary with the use of Mixed Keys:
{'Name': 'Geeks', 1: [1, 2, 3, 4]}
Dictionary can also be created by the built-in function dict(). An empty dictionary can be created by
just placing to curly braces{}.
Python3
# Creating an empty Dictionary
Dict = {}
print("Empty Dictionary: ")
print(Dict)

# with dict() method
Dict = dict({1: 'Geeks', 2: 'For', 3: 'Geeks'})
print("\nDictionary with the use of dict(): ")
print(Dict)

# with each item as a Pair
Dict = dict([(1, 'Geeks'), (2, 'For')])
print("\nDictionary with each item as a pair: ")
print(Dict)
Output:
Empty Dictionary:
{}
Dictionary with the use of dict():
{1: 'Geeks', 2: 'For', 3: 'Geeks'}
Dictionary with each item as a pair:
{1: 'Geeks', 2: 'For'}
Complexities for Creating a Dictionary:

Time complexity: O(len(dict))
Space complexity: O(n)
Nested Dictionary
Python3
# Creating a Nested Dictionary
# as shown in the below image
Dict = {1: 'Geeks', 2: 'For',
3: {'A': 'Welcome', 'B': 'To', 'C': 'Geeks'}}

print(Dict)
Output:
{1: 'Geeks', 2: 'For', 3: {'A': 'Welcome', 'B': 'To', 'C': 'Geeks'}}
Adding elements to a Dictionary
Addition of elements can be done in multiple ways. One value at a time can be added to a Dictionary
by defining value along with the key e.g. Dict[Key] = ‘Value’. Updating an existing value in a
Dictionary can be done by using the built-in update() method. Nested key values can also be added
to an existing Dictionary.
Note- While adding a value, if the key-value already exists, the value gets updated otherwise a new
Key with the value is added to the Dictionary.
Python3
# Creating an empty Dictionary
Dict = {}
print("Empty Dictionary: ")
print(Dict)

# Adding elements one at a time
Dict[0] = 'Geeks'
Dict[2] = 'For'
Dict[3] = 1
print("\nDictionary after adding 3 elements: ")
print(Dict)

# Adding set of values
# to a single Key
Dict['Value_set'] = 2, 3, 4
print("\nDictionary after adding 3 elements: ")
print(Dict)

# Updating existing Key's Value
Dict[2] = 'Welcome'
print("\nUpdated key value: ")
print(Dict)

# Adding Nested Key value to Dictionary
Dict[5] = {'Nested': {'1': 'Life', '2': 'Geeks'}}

print("\nAdding a Nested Key: ")
print(Dict)
Output:
Empty Dictionary:
{}
Dictionary after adding 3 elements:
{0: 'Geeks', 2: 'For', 3: 1}
Dictionary after adding 3 elements:
{0: 'Geeks', 2: 'For', 3: 1, 'Value_set': (2, 3, 4)}
Updated key value:
{0: 'Geeks', 2: 'Welcome', 3: 1, 'Value_set': (2, 3, 4)}
Adding a Nested Key:
{0: 'Geeks', 2: 'Welcome', 3: 1, 'Value_set': (2, 3, 4), 5:
{'Nested': {'1': 'Life', '2': 'Geeks'}}}
Complexities for Adding elements in a Dictionary:
Time complexity: O(1)/O(n)
Space complexity: O(1)
Accessing elements of a Dictionary
In order to access the items of a dictionary refer to its key name. Key can be used inside square
brackets.
Python3
# Python program to demonstrate
# accessing a element from a Dictionary

Dict = {1: 'Geeks', 'name': 'For', 3: 'Geeks'}

# accessing a element using key
print("Accessing a element using key:")

print(Dict['name'])

# accessing a element using key
print("Accessing a element using key:")
print(Dict[1])
Output:
Accessing a element using key:
For
Accessing a element using key:
Geeks
There is also a method called get() that will also help in accessing the element from a dictionary.This
method accepts key as argument and returns the value.
Complexities for Accessing elements in a Dictionary:
Time complexity: O(1)
Space complexity: O(1)
Python3

# accessing a element using get()
# method
print("Accessing a element using get:")
print(Dict.get(3))
Output:
Accessing a element using get:
Geeks
Accessing an element of a nested dictionary
In order to access the value of any key in the nested dictionary, use indexing [] syntax.
Python3
Dict = {'Dict1': {1: 'Geeks'},
'Dict2': {'Name': 'For'}}

# Accessing element using key
print(Dict['Dict1'])
print(Dict['Dict1'][1])
print(Dict['Dict2']['Name'])
Output:
{1: 'Geeks'}
Geeks
For
Deleting Elements using del Keyword
The items of the dictionary can be deleted by using the del keyword as given below.
Python3
# Python program to demonstrate
# Deleting Elements using del Keyword


print("Dictionary =")
print(Dict)
#Deleting some of the Dictionar data
del(Dict[1])
print("Data after deletion Dictionary=")
print(Dict)
Output
Dictionary ={1: 'Geeks', 'name': 'For', 3: 'Geeks'}
Data after deletion Dictionary={'name': 'For', 3: 'Geeks'}
Dictionary methods
Method Description
dic.clear() Remove all the elements from the dictionary
dict.copy() Returns a copy of the dictionary
dict.get(key, default = “None”) Returns the value of specified key
dict.items() Returns a list containing a tuple for each key value pair
dict.keys() Returns a list containing dictionary’s keys
dict.update(dict2) Updates dictionary with specified key-value pairs
dict.values() Returns a list of all the values of dictionary
pop() Remove the element with specified key
popItem() Removes the last inserted key-value pair
dict.setdefault(key,default= set the key to the default value if the key is not specified in
“None”) the dictionary
dict.has_key(key) returns true if the dictionary contains the specified key.
dict.get(key, default = “None”) used to get the value specified for the passed key.
Python3
# demo for all dictionary methods
dict1 = {1: "Python", 2: "Java", 3: "Ruby", 4: "Scala"}

# copy() method
dict2 = dict1.copy()
print(dict2)

# clear() method
dict1.clear()
print(dict1)

# get() method
print(dict2.get(1))

# items() method
print(dict2.items())

# keys() method
print(dict2.keys())

# pop() method
dict2.pop(4)
print(dict2)

# popitem() method
dict2.popitem()
print(dict2)

# update() method
dict2.update({3: "Scala"})
print(dict2)

# values() method
print(dict2.values())
Output:
{1: 'Python', 2: 'Java', 3: 'Ruby', 4: 'Scala'}
{}
Python
dict_items([(1, 'Python'), (2, 'Java'), (3, 'Ruby'), (4, 'Scala')])
dict_keys([1, 2, 3, 4])
{1: 'Python', 2: 'Java', 3: 'Ruby'}
{1: 'Python', 2: 'Java'}
{1: 'Python', 2: 'Java', 3: 'Scala'}
dict_values(['Python', 'Java', 'Scala'])
Python | Convert flattened dictionary into nested dictionary

garg_ak0109
 Read
 Discuss
 Courses
 Practice
Given a flattened dictionary, the task is to convert that dictionary into a nested dictionary where
keys are needed to be split at ‘_’ considering where nested dictionary will be started.
Method #1: Using Naive Approach
Step-by-step approach :
Define a function named insert that takes two parameters, a dictionary (dct) and a list (lst). This
function iterates over all elements of the input list except the last two elements, and creates nested
dictionaries corresponding to each element in the list.
The insert() function then updates the dictionary (dct) with a key-value pair where the key is the
second last element of the input list, and the value is the last element of the input list.
Define a function named convert_nested that takes a dictionary (dct) as an input. This function first
initializes an empty dictionary named result to store the output nested dictionary.
The function then creates an iterator named lists, which is a list of lists where each list represents a
hierarchical flow of keys and values from the input dictionary. To create this iterator, it splits each
key of the input dictionary by the ‘_’ character and appends the corresponding value to the list.
The convert_nested() function then iterates over each list in the lists iterator and inserts it into the
result dictionary using the insert() function.
Finally, the convert_nested() function returns the resulting nested dictionary result.
Define an initial dictionary named ini_dict containing key-value pairs.
Print the initial dictionary using the print() function.
Create a new list named _split_dict that contains lists representing the hierarchical flow of keys and
values from the initial dictionary by splitting each key of the dictionary by the ‘_’ character and
appending the corresponding value to the list.
Print the final nested dictionary by calling the convert_nested() function on the initial dictionary and
print the resulting nested dictionary using the print() function.
Below is the implementation of the above approach:
Python3
# Python code to demonstrate
# conversion of flattened dictionary
# into nested dictionary

def insert(dct, lst):
for x in lst[:-2]:
dct[x] = dct = dct.get(x, dict())
dct.update({lst[-2]: lst[-1]})

def convert_nested(dct):
# empty dict to store the result
result = dict()
# create an iterator of lists
# representing nested or hierarchical flow
lists = ([*k.split("_"), v] for k, v in dct.items())
# insert each list into the result
for lst in lists:
insert(result, lst)
return result

# initialising_dictionary
ini_dict = {'Geeks_for_for':1,'Geeks_for_geeks':4,
'for_geeks_Geeks':3,'geeks_Geeks_for':7}
# printing initial dictionary
print ("initial_dictionary", str(ini_dict))
# code to convert ini_dict to nested
# dictionary splitting_dict_keys
_split_dict = [[*a.split('_'), b] for a, b in ini_dict.items()]

# printing final dictionary
print ("final_dictionary", str(convert_nested(ini_dict)))
Output
initial_dictionary {'Geeks_for_for': 1, 'Geeks_for_geeks': 4, 'for_geeks_Geeks': 3, 'geeks_Geeks_for':

7}
final_dictionary {'Geeks': {'for': {'for': 1, 'geeks': 4}}, 'for': {'geeks': {'Geeks': 3}}, 'geeks': {'Geeks':
{'for': 7}}}
Time Complexity: O(n)
Auxiliary Space: O(n)
Method #2: Using default dict and recursive approach
Python3
# code to convert dict into nested dict
def nest_dict(dict1):
result = {}
for k, v in dict1.items():

# for each key call method split_rec which
# will split keys to form recursively
# nested dictionary
split_rec(k, v, result)
return result
def split_rec(k, v, out):

# splitting keys in dict
# calling_recursively to break items on '_'
k, *rest = k.split('_', 1)
if rest:
split_rec(rest[0], v, out.setdefault(k, {}))
else:
out[k] = v

print ("final_dictionary", str(nest_dict(ini_dict)))
Output

7}
{'for': 7}}}
Time complexity: O(n), where n is the length of the key string.

Auxiliary space: O(N * n), where N is the number of items in the input dictionary and n is the length
of the longest key string.
Method #3: Using reduce and getitem
Python3

from collections import defaultdict
from functools import reduce
from operator import getitem
def getFromDict(dataDict, mapList):

# Iterate nested dictionary
return reduce(getitem, mapList, dataDict)

# instantiate nested defaultdict of defaultdicts
tree = lambda: defaultdict(tree)
d = tree()
# converting default_dict_to regular dict
def default_to_regular(d):

"""Convert nested defaultdict to regular dict of dicts."""
if isinstance(d, defaultdict):
d = {k: default_to_regular(v) for k, v in d.items()}
return d


# code to convert ini_dict to nested dictionary
# iterating_over_dict
for k, v in ini_dict.items():

# splitting keys
* keys, final_key = k.split('_')
getFromDict(d, keys)[final_key] = v
print ("final_dictionary", str(default_to_regular(d)))
Output

7}
{'for': 7}}}
Time complexity: O(n), where n is the number of key-value pairs in the dictionary.

Auxiliary space: O(nm), where n and m are the same as explained above
Method 4 : Using a recursive function without defaultdict or reduce
uses a recursive function add_to_nested_dict to add values to a nested dictionary. The function
takes a nested dictionary, a list of keys, and a value as inputs. If the list of keys has only one key, the
function adds the value to the nested dictionary at that key. Otherwise, it creates a nested dictionary
at the first key if it doesn’t already exist, and then recursively calls the function with the remaining
keys and value.
step-by-step approach :
Create a function add_to_nested_dict that takes three arguments: a nested dictionary, a list of keys,
and a value. This function will add the value to the nested dictionary at the specified keys.
Check if the length of the keys list is 1. If it is, add the value to the nested dictionary at the last key in
the list.
If the length of the keys list is greater than 1, check if the first key is in the nested dictionary. If it
isn’t, create a new nested dictionary at that key.
Recursively call the add_to_nested_dict function with the nested dictionary at the first key in the list,
the remaining keys in the list, and the value.
Create an empty dictionary d that will hold the nested dictionary.
Iterate over the flattened dictionary ini_dict using a for loop.
Split each key in ini_dict into a list of keys using the split method.
Call the add_to_nested_dict function with the empty dictionary d, the list of keys, and the value.
Print the final nested dictionary d.
Python3
def add_to_nested_dict(nested_dict, keys, value):
"""Add a value to a nested dictionary at the specified keys."""
if len(keys) == 1:
# base case: add value to the last key in the list
nested_dict[keys[0]] = value
else:
# recursive case: create nested dictionary if it doesn't exist
if keys[0] not in nested_dict:
nested_dict[keys[0]] = {}
# recursively call function with remaining keys and value
add_to_nested_dict(nested_dict[keys[0]], keys[1:], value)
# create empty nested dictionary
d = {}
# splitting keys
keys = k.split('_')
# add value to nested dictionary
add_to_nested_dict(d, keys, v)
print ("final_dictionary", str(d))
Output

7}
{'for': 7}}}
The time complexity of this approach is O(nm), where n is the number of keys in the flattened
dictionary and m is the maximum depth of the nested dictionary.
The auxiliary space is also O(nm), since the function creates nested dictionaries as needed.
Method 5: Using a loop to iterate through the list of keys
Create an empty dictionary.
Iterate through the items in the initial dictionary using a for loop.
Split the keys into a list using the split() method and store the value in a variable.
Create a variable temp that references the empty dictionary.
Iterate through the list of keys using a for loop.
If the key exists in temp, update temp to reference the value of that key.
If the key does not exist in temp, create a new key with an empty dictionary as its value and update
temp to reference that value.
When the loop through the keys is finished, set the final value of the last key in the list to be the
value from the initial dictionary.
Return the nested dictionary.
Python3

temp = nested_dict
for key in keys[:-1]:
temp = temp.setdefault(key, {})
temp[keys[-1]] = value
return nested_dict
d = {}
# splitting keys
keys = k.split('_')
Output

7}
{'for': 7}}}
Time complexity: O(n*m), where n is the number of items in the initial dictionary and m is the
maximum number of keys in a single item.
Auxiliary space: O(m), where m is the maximum number of keys in a single item.
Last Updated : 10 Apr, 2023
Similar Reads
1.Python | Convert nested dictionar
Why does a nested loop perform much faster than the flattened one?
aniketpr11051998
 Read
 Discuss
 Courses
 Practice
Python provides three ways for executing the loops. While all the ways provide similar basic
functionality, they differ in their syntax and condition checking time.
In this article, we will see why does a nested loop performs better than the flattened one. But first,
let’s see what is a nested loop and what is a flattened loop.4
A nested loop performs faster than a flattened one because it takes advantage of spatial locality,
which is the principle that data that is close to each other in memory is also likely to be close to each
other in time.
When a nested loop iterates through an array, it typically accesses elements that are close to each
other in memory. This allows the CPU to access data from memory more quickly because it can take
advantage of the CPU cache, which is a small amount of memory that is built into the CPU itself. This
can greatly reduce the number of times that the CPU has to access main memory, which is much
slower than the CPU cache.
On the other hand, a flattened loop iterates through the entire array, which may cause the CPU to
frequently access memory that is not currently in the cache. This increases the number of times the
CPU has to access main memory, which can slow down the loop considerably.
Additionally, In some architectures, accessing memory in a sequential manner allows to use

prefetching mechanism, that can predict next memory location and fetch it to CPU cache before it’s
actually needed, which can also improve performance.
Nested loops are the logical structure in computer programming and coding. In which one loop
statement is inside another loop statement.
Syntax:
for [iter_1] in [sequence_1]:
for [iter_2] in [sequence_2]:
# statements of inner loop
statements(iter_2)
# statements of outer loop
statements(iter_1)
Loops have the ability to iterate over the items of any sequence, such as a list or a string.
Syntax:
for [iter] in sequence:
statements(s)
When we run our python script, the operating system we are running on will assign a Process ID for
it. It can be interrupted by system calls and its priority can be changed over time. But the system is
not likely to take resources away from a process when we change memory address or values. When
we run flat for loop it is assigning much fewer variables than a nested loop. So we can say that a
nested loop utilizes resources more than a flat loop if they are available.
Example:
Python3
# import module
import time
# flattened loop
def loop(n):
for i in range(n**3):
pass
# nested loop
def nested(n):

for i in range(n):
for j in range(n):
for k in range(n):
pass
for i in range(10, 100, 10):
start = time.time()
loop(i)
print('For flattened loop:',time.time() - start)

start = time.time()
nested(i)
print('For nested loop:',time.time() - start)
print()
Output:
For flattened loop: 2.7894973754882812e-05
For nested loop: 4.9114227294921875e-05
For flattened loop: 0.0002155303955078125

For nested loop: 0.00024271011352539062
For nested loop: 0.0007529258728027344
For nested loop: 0.0012614727020263672
For nested loop: 0.0022766590118408203
For nested loop: 0.003597736358642578
For nested loop: 0.0057599544525146484
For nested loop: 0.008468151092529297
For nested loop: 0.01381683349609375
Advantages and Disadvantages:
Advantages of nested loops:
They take advantage of spatial locality, which can greatly improve performance by reducing the
number of times the CPU has to access main memory.
They can be used to iterate over multi-dimensional arrays, which can make the code more readable
and easier to understand.
They allow for better data encapsulation and organization, as the different levels of the loop can
represent different aspects of the data.
Disadvantages of nested loops:

They can be more difficult to understand and debug than flattened loops, especially when there are
multiple levels of nesting.
They can be less efficient than flattened loops when the data is not organized in a multi-dimensional
structure.
They can consume more memory if the nested data structure is large, as it can take more memory to
store the nested elements.
It’s worth noting that in some cases, nested loops can be flattened using techniques like linearizing,
or using more advanced data structures like sparse
matrices to represent the data. It’s important to have a good understanding of the problem and the
data structure to choose the best approach, and it’s also
important to measure the performance of different solutions to select the best one.
Python | Convert nested dictionary into flattened dictionary

garg_ak0109
 Read
 Discuss
 Courses
 Practice
Given a nested dictionary, the task is to convert this dictionary into a flattened dictionary where the
key is separated by ‘_’ in case of the nested key to be started.
The function checks if the input dd is a dictionary. If it is, then it iterates over each key-value pair in
the dictionary, and calls the flatten_dict function recursively on the value of each key. It
concatenates the original key and the returned key from the recursive call with the separator, and
uses that as the new key in the flattened dictionary. It sets the value of the new key to the returned
value from the recursive call.
If the input dd is not a dictionary, the function creates a new dictionary with a single key-value pair,
where the key is the prefix argument (which is the path to the current value in the original nested
dictionary), and the value is the input dd itself.
The code then initializes a nested dictionary ini_dict with some sample data.
The code prints the initial dictionary ini_dict.
The code calls the flatten_dict function on the ini_dict dictionary and prints the resulting flattened
dictionary.
Python3
# conversion of nested dictionary
# into flattened dictionary
# code to convert ini_dict to flattened dictionary
# default separator '_'
def flatten_dict(dd, separator ='_', prefix =''):
return { prefix + separator + k if prefix else k : v
for kk, vv in dd.items()
for k, v in flatten_dict(vv, separator, kk).items()
} if isinstance(dd, dict) else { prefix : dd }

ini_dict = {'geeks': {'Geeks': {'for': 7}},
'for': {'geeks': {'Geeks': 3}},
'Geeks': {'for': {'for': 1, 'geeks': 4}}}
print ("final_dictionary", str(flatten_dict(ini_dict)))
Output:
initial_dictionary {‘geeks’: {‘Geeks’: {‘for’: 7}}, ‘Geeks’: {‘for’: {‘geeks’: 4, ‘for’: 1}}, ‘for’: {‘geeks’:
{‘Geeks’: 3}}}
final_dictionary {‘Geeks_for_for’: 1, ‘geeks_Geeks_for’: 7, ‘for_geeks_Geeks’: 3, ‘Geeks_for_geeks’:
4}

Time complexity: O(n^2), where n is the total number of keys in the nested dictionary.
Auxiliary space: O(n), where n is the total number of keys in the nested dictionary. The auxiliary
space is used to store the result of the flatten dictionary in the form of a new dictionary.
Method #2: Using mutableMapping
Python3
from collections import MutableMapping
# default separator '_'
def convert_flatten(d, parent_key ='', sep ='_'):
items = []
for k, v in d.items():
new_key = parent_key + sep + k if parent_key else k
if isinstance(v, MutableMapping):
items.extend(convert_flatten(v, new_key, sep = sep).items())
else:
items.append((new_key, v))
return dict(items)

print ("final_dictionary", str(convert_flatten(ini_dict)))
my_map = {"a" : 1,
"b" : {
"c": 2,
"d": 3,
"e": {
"f":4,
6:"a",
5:{"g" : 6},
"l":[1,"two"]
}
}}
# Expected Output
# {'a': 1, 'b_c': 2, 'b_d': 3, 'b_e_f': 4, 'b_e_6': 'a', 'b_e_5_g': 6, 'b_e_l': [1, 'two']}
# Expected Output
# {‘Geeks_for_geeks’: 4, ‘for_geeks_Geeks’: 3, ‘Geeks_for_for’: 1, ‘geeks_Geeks_for’: 7}
def flatten_dict(pyobj, keystring=''):
if type(pyobj) == dict:
keystring = keystring + '_' if keystring else keystring
for k in pyobj:
yield from flatten_dict(pyobj[k], keystring + str(k))
else:
yield keystring, pyobj
print("Input : %s\nOutput : %s\n\n" %
(my_map, { k:v for k,v in flatten_dict(my_map) }))

print("Input : %s\nOutput : %s\n\n" %
(ini_dict, { k:v for k,v in flatten_dict(ini_dict) }))
Output:
initial_dictionary {‘for’: {‘geeks’: {‘Geeks’: 3}}, ‘geeks’: {‘Geeks’: {‘for’: 7}}, ‘Geeks’: {‘for’: {‘for’: 1,
‘geeks’: 4}}}
final_dictionary {‘Geeks_for_geeks’: 4, ‘for_geeks_Geeks’: 3, ‘Geeks_for_for’: 1, ‘geeks_Geeks_for’:
7}

Time complexity: O(n), where n is the total number of keys in the nested dictionary
Auxiliary space: O(n), where n is the total number of keys in the nested dictionary.
Method #4: Using recursion and a separator
Define a function “flatten_dict” that takes in three parameters: dd (a dictionary), separator (a string,
default value “_”), and prefix (a string, default value “”).
Initialize an empty dictionary “res”.
Iterate through each key-value pair in the dictionary “dd”.
Check if the value associated with the current key is itself a dictionary or not. If it is a dictionary, then
recursively call the “flatten_dict” function with the value as the new dictionary to be flattened, the
separator and prefix updated with the current key and separator value.
If the value is not a dictionary, then add the key-value pair to the “res” dictionary, where the key is
the concatenation of prefix, separator and current key.
Return the final “res” dictionary.
Python3
def flatten_dict(dd, separator='_', prefix=''):
res = {}
for key, value in dd.items():
if isinstance(value, dict):
res.update(flatten_dict(value, separator, prefix + key + separator))
else:
res[prefix + key] = value
return res

print("initial dictionary", str(ini_dict))
# flattening the dictionary
res = flatten_dict(ini_dict)
print("final dictionary", str(res))
#This code is contributed by Vinay Pinjala.
Python | Convert flattened dictionary into nested dictionary

garg_ak0109
 Read
 Discuss
 Courses
 Practice
Given a flattened dictionary, the task is to convert that dictionary into a nested dictionary where
keys are needed to be split at ‘_’ considering where nested dictionary will be started.
Define a function named insert that takes two parameters, a dictionary (dct) and a list (lst). This
function iterates over all elements of the input list except the last two elements, and creates nested
dictionaries corresponding to each element in the list.
The insert() function then updates the dictionary (dct) with a key-value pair where the key is the
second last element of the input list, and the value is the last element of the input list.
Define a function named convert_nested that takes a dictionary (dct) as an input. This function first
initializes an empty dictionary named result to store the output nested dictionary.
The function then creates an iterator named lists, which is a list of lists where each list represents a
hierarchical flow of keys and values from the input dictionary. To create this iterator, it splits each
key of the input dictionary by the ‘_’ character and appends the corresponding value to the list.
The convert_nested() function then iterates over each list in the lists iterator and inserts it into the
result dictionary using the insert() function.
Finally, the convert_nested() function returns the resulting nested dictionary result.
Define an initial dictionary named ini_dict containing key-value pairs.
Create a new list named _split_dict that contains lists representing the hierarchical flow of keys and
values from the initial dictionary by splitting each key of the dictionary by the ‘_’ character and
appending the corresponding value to the list.
Print the final nested dictionary by calling the convert_nested() function on the initial dictionary and
print the resulting nested dictionary using the print() function.
Python3

def insert(dct, lst):
for x in lst[:-2]:
dct[x] = dct = dct.get(x, dict())
dct.update({lst[-2]: lst[-1]})

def convert_nested(dct):
# empty dict to store the result
result = dict()
# create an iterator of lists
# representing nested or hierarchical flow
lists = ([*k.split("_"), v] for k, v in dct.items())
# insert each list into the result
for lst in lists:
insert(result, lst)
return result

# code to convert ini_dict to nested
# dictionary splitting_dict_keys
_split_dict = [[*a.split('_'), b] for a, b in ini_dict.items()]

print ("final_dictionary", str(convert_nested(ini_dict)))
Output

7}
{'for': 7}}}
Method #2: Using default dict and recursive approach
Python3
# code to convert dict into nested dict
def nest_dict(dict1):
result = {}
for k, v in dict1.items():

# for each key call method split_rec which
# will split keys to form recursively
# nested dictionary
split_rec(k, v, result)
return result
def split_rec(k, v, out):

# splitting keys in dict
# calling_recursively to break items on '_'
k, *rest = k.split('_', 1)
if rest:
split_rec(rest[0], v, out.setdefault(k, {}))
else:
out[k] = v

print ("final_dictionary", str(nest_dict(ini_dict)))
Output

7}
{'for': 7}}}
Time complexity: O(n), where n is the length of the key string.

Auxiliary space: O(N * n), where N is the number of items in the input dictionary and n is the length
of the longest key string.
Method #3: Using reduce and getitem
Python3

from operator import getitem
def getFromDict(dataDict, mapList):

# Iterate nested dictionary
return reduce(getitem, mapList, dataDict)

# instantiate nested defaultdict of defaultdicts
tree = lambda: defaultdict(tree)
d = tree()
# converting default_dict_to regular dict
def default_to_regular(d):

"""Convert nested defaultdict to regular dict of dicts."""
if isinstance(d, defaultdict):
d = {k: default_to_regular(v) for k, v in d.items()}
return d


# code to convert ini_dict to nested dictionary

# splitting keys
* keys, final_key = k.split('_')
getFromDict(d, keys)[final_key] = v
print ("final_dictionary", str(default_to_regular(d)))
Output

7}
{'for': 7}}}

Auxiliary space: O(nm), where n and m are the same as explained above
Method 4 : Using a recursive function without defaultdict or reduce
uses a recursive function add_to_nested_dict to add values to a nested dictionary. The function
takes a nested dictionary, a list of keys, and a value as inputs. If the list of keys has only one key, the
function adds the value to the nested dictionary at that key. Otherwise, it creates a nested dictionary
at the first key if it doesn’t already exist, and then recursively calls the function with the remaining
keys and value.
step-by-step approach :
Create a function add_to_nested_dict that takes three arguments: a nested dictionary, a list of keys,
and a value. This function will add the value to the nested dictionary at the specified keys.
Check if the length of the keys list is 1. If it is, add the value to the nested dictionary at the last key in
the list.
If the length of the keys list is greater than 1, check if the first key is in the nested dictionary. If it
isn’t, create a new nested dictionary at that key.
Recursively call the add_to_nested_dict function with the nested dictionary at the first key in the list,
the remaining keys in the list, and the value.
Create an empty dictionary d that will hold the nested dictionary.
Iterate over the flattened dictionary ini_dict using a for loop.
Split each key in ini_dict into a list of keys using the split method.
Call the add_to_nested_dict function with the empty dictionary d, the list of keys, and the value.
Print the final nested dictionary d.
Python3
if len(keys) == 1:
# base case: add value to the last key in the list
nested_dict[keys[0]] = value
else:
# recursive case: create nested dictionary if it doesn't exist
if keys[0] not in nested_dict:
nested_dict[keys[0]] = {}
# recursively call function with remaining keys and value
add_to_nested_dict(nested_dict[keys[0]], keys[1:], value)
d = {}
# splitting keys
keys = k.split('_')
Python | Pretty Print a dictionary with dictionary value

manjeet_04
 Read
 Discuss
 Courses
 Practice
This article just provides a quick way to pretty print a dictionary that has dictionary as values. This is
required many times nowadays as the advent of NoSQL databases. Let’s code a way to perform this
particular task.
Method 1: Using loops We just loop through each dictionary element and its corresponding values
using brute manner of loops.
Create a dictionary with nested dictionaries as values.
Print the original dictionary.
Loop through the top-level keys of the dictionary.
For each top-level key, print it.
Loop through the keys of the nested dictionary associated with the top-level key.
For each key in the nested dictionary, print the key-value pair in the format “key: value”.
Python3
# Python3 code to demonstrate working of
# Pretty Print a dictionary with dictionary value
# Using loops
# initializing dictionary
test_dict = {'gfg': {'rate': 5, 'remark': 'good'}, 'cs': {'rate': 3}}
# printing original dictionary
print("The original dictionary is : " + str(test_dict))
# using loops to Pretty Print

print("The Pretty Print dictionary is : ")
for sub in test_dict:
print(sub)
for sub_nest in test_dict[sub]:
print(sub_nest, ':', test_dict[sub][sub_nest])
Output :
The original dictionary is : {'gfg': {'remark': 'good', 'rate': 5}, 'cs': {'rate': 3}}
The Pretty Print dictionary is :
gfg
remark : good
rate : 5
cs
rate : 3
Auxiliary Space: O(1)
Method 2: Using the built-in json module
STEPS:
First, the program imports the json module to use its dumps() function for pretty printing
dictionaries.
The program initializes a nested dictionary called test_dict with two keys: gfg and cs.
The gfg key has two nested key-value pairs, rate and remark, with values of 5 and ‘good’,
respectively.
The cs key has only one nested key-value pair, rate, with a value of 3.
The program prints the original dictionary using the print() function and the test_dict variable.
The program uses the dumps() function from the json module to pretty print the test_dict dictionary.
The pretty printed dictionary is assigned to a new variable called pretty_dict.
Finally, the program prints the pretty printed dictionary using the print() function and the pretty_dict
variable. The indent argument is set to 4 to make the output more readable.
Python3
import json

print("The original dictionary is : ", test_dict)
# using json.dumps() to Pretty Print
pretty_dict = json.dumps(test_dict, indent=4)
print("The Pretty Print dictionary is : \n", pretty_dict)
Output
The original dictionary is : {'gfg': {'rate': 5, 'remark': 'good'}, 'cs': {'rate': 3}}
"gfg": {
"rate": 5,
"remark": "good"
},
"cs": {
"rate": 3
Method 3:Using recursion and string concatenation:
1. The function starts by initializing an empty string, res.

2. Then it loops over each item in the input dictionary d by calling the items method. This operation
takes O(N) time where N is the number of items in the dictionary.
3. Inside the loop, the function appends a string to res using the += operator. The length of the string
being appended is proportional to the 4.current value of indent and the length of the key and value
being printed. Assuming the maximum length of key and value to be M, the time 5.complexity of
each iteration of the loop is O(indent + M).
6.If the current value is a dictionary, the function calls itself recursively with the inner dictionary and
an incremented value of indent. The recursive 7.call will have to traverse through all the items in the
nested dictionary. Therefore, the time complexity of the recursive call is O(M*k) where k is the
number of items in the nested dictionary.
8.Finally, the function returns the resulting string res.
Python3
def pretty_print_dict(d, indent=0):
res = ""
res += "\t"*indent + str(k) + "\n"
if isinstance(v, dict):
res += pretty_print_dict(v, indent+1)
else:
res += "\t"*(indent+1) + str(v) + "\n"
return res
# Using recursion and string concatenation for Pretty Print
print(pretty_print_dict(test_dict))
# This code is contributed by Jyothi pinjala.
Output
gfg
rate
remark
good
cs
rate
3
The time complexity: O(N), where N is the total number of elements in the dictionary, since it
iterates through each element once.
The auxiliary space: O(N), since it stores the output string in memory, and the size of the output
string is proportional to the size of the dictionary. Additionally, the recursive calls to
pretty_print_dict also use stack space, which could potentially grow to O(N) in the worst case
scenario where the dictionary is deeply nested.
Method 4: Using for loop+dictionary
Approach
for loop to iterate over the keys and values of the dictionary.
Algorithm
Initialize an empty string to hold the pretty-printed dictionary.
Iterate over the keys and values of the dictionary using a for loop.
For each key-value pair, add the key to the string followed by a colon and a space.
For each value, add it to the string followed by a newline character.
Return the pretty-printed dictionary string.
Python3
def pretty_print_dict(d):#define d
pretty_dict = '' #take empty string
for k, v in d.items():#get items for dict
pretty_dict += f'{k}: \n'
for value in v:
pretty_dict += f' {value}: {v[value]}\n'
return pretty_dict#return result
d = {'gfg': {'remark': 'good', 'rate': 5}, 'cs': {'rate': 3}}#input
print(pretty_print_dict(d))#print output
Output
gfg:
remark: good
rate: 5
cs:
rate: 3
Time Complexity: O(n^2), where n is the number of key-value pairs in the dictionary.

Auxiliary Space: O(n), where n is the number of key-value pairs in the dictionary
Method 5: Using the pprint module
The pprint module is a built-in module in Python that provides a way to pretty-print arbitrary Python
data structures in a form that can be used as input to the interpreter. It is useful for debugging and
displaying complex structures.
Python3
# import the pprint module
import pprint
# initialize the dictionary
test_dict = {'gfg' : {'rate' : 5, 'remark' : 'good'}, 'cs' : {'rate' : 3}}
# pretty-print the dictionary
print("The pretty-printed dictionary is:")
pprint.pprint(test_dict)
Output
The pretty-printed dictionary is:
{'cs': {'rate': 3}, 'gfg': {'rate': 5, 'remark': 'good'}}
The time complexity of the pprint module function pprint() depends on the size of the input
dictionary.
The space complexity of the pprint module function pprint() is also dependent on the size of the
input dictionary.
Method 6: using the json.dumps() method with an argument indent.
Step-by-step approach:
Import the json module.
Initialize the dictionary.
Use json.dumps() method with indent argument to pretty print the dictionary.
Print the pretty printed dictionary.

Python3
# Importing json module
import json
# Initializing dictionary
test_dict = {'gfg' : {'rate' : 5, 'remark' : 'good'}, 'cs' : {'rate' : 3}}
# Printing original dictionary
print("The original dictionary is : ", test_dict)
# Using json.dumps() with indent argument to Pretty Print
pretty_print_dict = json.dumps(test_dict, indent=4)
print(pretty_print_dict)
Regular Dictionary vs Ordered Dictionary in Python
AlapanKar
 Read
 Discuss
 Courses
 Practice
Dictionary in Python is an unordered collection of data values, used to store data values like a map,
which unlike other Data Types that hold only single value as an element, Dictionary holds key:value
pair. Key-value is provided in the dictionary to make it more optimized. A regular dictionary type
does not track the insertion order of the (key, value) pairs and thus iterates through the keys based
on how they are stored in the hash table which in turn is based on random values so as to reduce
collisions.
In contrast to this Python provides the OrderedDict type which remembers the insertion order of
(key, value) pairs in the dictionary and thus preserves the order. OrderedDict consumes more
memory than a regular dictionary in Python because of the underlying Doubly LinkedList
implementation to preserving the order.
Example:
Python
# A Python program to demonstrate
# the difference between regular
# and ordered dictionary.
import collections

# Creating a regular dictionary
print('Regular dictionary:')
d = {chr(k):k for k in range(ord('a'), ord('g'))}

print(k, v)

# Creating an Ordered dictionary
print('\nOrderedDict:')
d = collections.OrderedDict()
[d.setdefault(chr(k), k) for k in range(ord('a'), ord('g'))]

print(k, v)
Output :
Regular dictionary:
('a', 97)
('c', 99)
('b', 98)
('e', 101)
('d', 100)
('f', 102)
OrderedDict:
('a', 97)
('b', 98)
('c', 99)
('d', 100)
('e', 101)
('f', 102)
The time complexity of this program is O(N), where N is the number of key-value pairs in the
dictionary.
The auxiliary space complexity of this program is O(N), because it stores N key-value pairs in the
regular dictionary and in the OrderedDict.
Note: Starting from Python 3.7, insertion order of Python dictionaries is guaranteed.
Deletion and Re-Inserting:

Deleting and re-inserting the same key will push it to the back as OrderedDict however maintains the
order of insertion.
Example:
Python
# A Python program to demonstrate

# working of deletion and re-insertion in
# regular and OrderedDict
from collections import OrderedDict

print("Before deleting:\n")
d = {}
print("Regular dictionary:")
d['a'] = 1
d['b'] = 2
d['c'] = 3
d['d'] = 4
for key, value in d.items():
print(key, value)

od = OrderedDict()
print("\nOrdered dictionary:")
od['a'] = 1
od['b'] = 2
od['c'] = 3
od['d'] = 4
for key, value in od.items():
print(key, value)

print("\nAfter deleting:\n")

d.pop('c')
print(key, value)

od.pop('c')
print(key, value)

print("\nAfter re-inserting:\n")
d['c'] = 3
print(key, value)

od['c'] = 3
print(key, value)
Output:
Before deleting:
Regular dictionary:
('a', 1)
('c', 3)
('b', 2)
('d', 4)
Ordered dictionary:
('a', 1)
('b', 2)
('c', 3)
('d', 4)
After deleting:
Regular dictionary:
('a', 1)
('b', 2)
('d', 4)
Ordered dictionary:
('a', 1)
('b', 2)
('d', 4)
After re-inserting:
Regular dictionary:
('a', 1)
('c', 3)
('b', 2)
('d', 4)
Ordered dictionary:
('a', 1)
('b', 2)
('d', 4)
('c', 3)
The time complexity is O(n), as each element needs to be inserted into the dictionary.
The space complexity of re-inserting an element into a dictionary is O(1), as it only involves adding
one element to the dictionary.
Python | Dictionary initialization with common dictionary

manjeet_04
 Read
 Discuss
 Courses
 Practice
Sometimes, while working with dictionaries, we might have an utility in which we need to initialize a
dictionary with records values, so that they can be altered later. This kind of application can occur in
cases of memoizations in general or competitive programming. Let’s discuss certain way in which
this task can be performed.
Method 1: Using zip() + repeat() The combination of these functions can be used to perform this
particular task. In this, the Dictionary value is attached to the keys repeated using the repeat() by
help of zip()
Import the repeat function from the itertools module.
Initialize a dictionary test_dict with key-value pairs.
Call the zip() function with two arguments:

a. The range() function to create a sequence of numbers from 0 to 3 (inclusive).
b. The repeat() function with the test_dict dictionary as its argument to create an iterable that
returns test_dict infinitely.
Pass the output of zip() to the dict() function to create a dictionary from the key-value pairs
generated by zip().
Assign the resulting dictionary to the variable res.
Print the resulting dictionary res.
Python3
# Dictionary initialization with common dictionary
# Using zip() + repeat()
from itertools import repeat
# initialization Dictionary
test_dict = {'gfg' : 1, 'best' : 3}

# Using zip() + repeat()
res = dict(zip(range(4), repeat(test_dict)))
# printing result
print("The dictionary with record values : " + str(res))
Output
The dictionary with record values : {0: {'gfg': 1, 'best': 3}, 1: {'gfg': 1, 'best': 3}, 2: {'gfg': 1, 'best': 3}, 3:
{'gfg': 1, 'best': 3}}
Time complexity: O(1)
Auxiliary space: O(1)
Method 2: Using dict.fromkeys()
Uses the ‘dict.fromkeys()’ method to initialize a new dictionary named ‘res’. The ‘range(4)’ function
creates a sequence of numbers from 0 to 3, and the ‘test_dict’ dictionary is passed as the second
argument to the ‘dict.fromkeys()’ method. This creates a new dictionary where each key in the range
sequence maps to the same value (which is the entire ‘test_dict’ dictionary).
Finally, prints the resulting dictionary using the ‘print()’ function. The resulting dictionary is stored in
the ‘res’ variable, and it contains 4 key-value pairs, where each key is a number from 0 to 3, and
each value is the same dictionary as ‘test_dict’.
Python3
# Using dict.fromkeys()
# initialization Dictionary
test_dict = {'gfg' : 1, 'best' : 3}
# Using dict.fromkeys()

res = dict.fromkeys(range(4), test_dict)
# printing result
#This code is contributed by Edula Vinay Kumar Reddy
Output
{'gfg': 1, 'best': 3}}
Time Complexity : O(n)

Auxiliary Space : O(n)
Method #3: Using a dictionary comprehension.
Initializes a dictionary named ‘test_dict’ with two key-value pairs. It then creates a new dictionary
‘res’ with keys ranging from 0 to 3, and assigns the same dictionary object ‘test_dict’ as the value for
each key. Finally, it prints the resulting dictionary ‘res’.
Python3
test_dict = {'gfg': 1, 'best': 3}
res = {key: test_dict for key in range(4)}
Output
{'gfg': 1, 'best': 3}}
Python – Update dictionary with other dictionary

manjeet_04
 Read
 Discuss
 Courses
 Practice
Sometimes, while working with Python dictionaries, we can have problem in which we need to
perform the update of dictionary with other keys of dictionary. This can have applications in domains
in which we need to add certain records to previously captured records. Let’s discuss certain ways in
which this task can be performed.
Method #1 : Using loop This is a brute force way in which this task can be performed. In this, we
check for keys in other dictionary, and add the items in new dictionary.
Python3
# Update dictionary with other dictionary
# Using loop
# initializing dictionaries
test_dict1 = {'gfg': 1, 'best': 2, 'for': 4, 'geeks': 6}
test_dict2 = {'for': 3, 'geeks': 5}
# printing original dictionaries
print("The original dictionary 1 is : " + str(test_dict1))
# Using loop
for key in test_dict1:
if key in test_dict2:
test_dict1[key] = test_dict2[key]

# printing result
print("The updated dictionary is : " + str(test_dict1))
Output :
The original dictionary 1 is : {‘best’: 2, ‘for’: 4, ‘gfg’: 1, ‘geeks’: 6} The original dictionary 2 is : {‘for’: 3,
‘geeks’: 5} The updated dictionary is : {‘best’: 2, ‘for’: 3, ‘gfg’: 1, ‘geeks’: 5}
Method #2 : Using dictionary comprehension This is yet another way in which this task can be
performed. In this, we iterate for dictionary and perform update in single line using comprehension.
Python3
# Using dictionary comprehension
res = {key: test_dict2.get(key, val) for key, val in test_dict1.items()}
# printing result
print("The updated dictionary is : " + str(res))
Output :
The original dictionary 1 is : {‘best’: 2, ‘for’: 4, ‘gfg’: 1, ‘geeks’: 6} The original dictionary 2 is : {‘for’: 3,
‘geeks’: 5} The updated dictionary is : {‘best’: 2, ‘for’: 3, ‘gfg’: 1, ‘geeks’: 5}
The time complexity of the given program is O(N), where N is the total number of keys in both the
dictionaries.
The space complexity of the program is also O(N), where N is the number of keys in test_dict1.
Method #3 : Using update() method
Python3
# Using loop
# Using loop
test_dict1.update(test_dict2)
# printing result
Output
The original dictionary 1 is : {'gfg': 1, 'best': 2, 'for': 4, 'geeks': 6}
The original dictionary 2 is : {'for': 3, 'geeks': 5}
The updated dictionary is : {'gfg': 1, 'best': 2, 'for': 3, 'geeks': 5}
Time Complexity : O(N)
Auxiliary Space : O(N)
Method #4: Using the’ **’ operator: The ‘**’ operator

Define the two dictionaries:
Print the original dictionaries to verify their contents:
Use the “**” operator to combine the dictionaries into a new dictionary:
Print the updated dictionary to verify the combination:
The output should show the updated dictionary with the combined key-value pairs:
Example:
Python3
# Define the two dictionaries
test_dict1 = {'gfg' : 1, 'best' : 2, 'for' : 4, 'geeks' : 6}
test_dict2 = {'for' : 3, 'geeks' : 5}
# Use the "**" operator to combine the dictionaries
# The "**" operator is used to unpack dictionaries and pass the key-value pairs as separate
arguments to a function
# In this case, we are using the "**" operator to unpack the dictionaries and add their key-value
pairs to a new dictionary
test_dict1 = {**test_dict1, **test_dict2}
# Print the combined dictionary
# Output: {'a': 1, 'b': 2, 'c': 3, 'd': 4}
Output
Time Complexity: Creating the DataFrame object takes O(n) time, where n is the length of the first
list.
Extracting the values from the first list corresponding to the indices in the second list using the loc[]
function takes O(m) time, where m is the length of the second list.
Converting the resulting series object to a list takes O(m) time.
Therefore, the overall time complexity of the algorithm is O(n+m).
Auxiliary Space Complexity: The algorithm uses O(n) auxiliary space to store the DataFrame object
and O(m) auxiliary space to store the resulting list. Therefore, the overall auxiliary space complexity
of the algorithm is O(n+m). Note that this assumes that the length of the resulting list is at most
min(n,m); if the length of the resulting list can be greater than min(n,m), then the overall auxiliary
space complexity would be O(max(n,m)).
Method #6: Using the dict() constructor and the update() method
Use the dict() constructor to create a copy of the first dictionary and then updates it with the second
dictionary using the update() method.
Python3
# Using the dict() constructor and update() method
# Using the dict() constructor and update() method
new_dict = dict(test_dict1)
new_dict.update(test_dict2)
# printing result
print("The updated dictionary is : " + str(new_dict))
Output

Time complexity: O(N), where N is the total number of key-value pairs in both dictionaries.
Auxiliary space: O(N)
Method #7: Using reduce():
Import the reduce() function from the functools module.
Initialize the two dictionaries to be merged.
Define a lambda function that takes two arguments: an accumulator dictionary and the next
dictionary to merge, and returns a new dictionary that is the result of merging the accumulator
dictionary with the next dictionary using the unpacking syntax **.
Use the reduce() function to apply the lambda function to each dictionary in the list of dictionaries to
be merged, starting with the first dictionary as the initial accumulator value.
Return the final merged dictionary.
Python3
# Update dictionary with other dictionary using reduce
updated_dict = reduce(lambda acc, d: {**acc, **d}, [test_dict1, test_dict2])
# printing result
print("The updated dictionary is : " + str(updated_dict))
#This code is contributed by Jyothi pinjala.
Python – Filter dictionary values in heterogeneous dictionary

manjeet_04
 Read
 Discuss
 Courses
 Practice
Sometimes, while working with Python dictionaries, we can have a problem in which we need to
filter out certain values based on certain conditions on a particular type, e.g all values smaller than K.
This task becomes complex when dictionary values can be heterogeneous. This kind of problem can
have applications across many domains. Let’s discuss certain ways in which this task can be
performed.
Input : test_dict = {‘Gfg’ : 10, ‘for’ : ‘geeks’}

Output : {‘Gfg’: 10, ‘for’: ‘geeks’}
Input : test_dict = {‘Gfg’ : ‘geeks’}

Output : {‘Gfg’: ‘geeks’}
Method #1 : Using type() + dictionary comprehension

The combination of above functions can be used to perform this task. In this, we check for integral
type using type() and filter the data in dictionary comprehension.
Step-by-step approach
Use dictionary comprehension to create a new dictionary res.
Iterate over the items of test_dict using the items() method.
For each item, check if the value is not an integer (type(val) != int) or if it is greater than K (val > K).
If the condition is true, add the key-value pair to the new dictionary res.
Print the new dictionary res using the print() function.
Python3
# Filter dictionary values in heterogeneous dictionary
# Using type() + dictionary comprehension
test_dict = {'Gfg' : 4, 'is' : 2, 'best' : 3, 'for' : 'geeks'}

print("The original dictionary : " + str(test_dict))
# initializing K
K=3
res = {key : val for key, val in test_dict.items()
if type(val) != int or val > K}
# printing result
print("Values greater than K : " + str(res))
Output :
The original dictionary : {'Gfg': 4, 'for': 'geeks', 'is': 2, 'best': 3}
Values greater than K : {'Gfg': 4, 'for': 'geeks'}

Method #2 : Using isinstance() + dictionary comprehension

The combination of above functions can also be used to solve this problem. In this, we perform this
task similar to above, but the difference being that type test is done by isinstance() rather than
type().
Python3
# Using isinstance() + dictionary comprehension
# initializing K
K=3
if not isinstance(val, int) or val > K}
# printing result
Output :
Time complexity: O(n), where n is the number of items in the dictionary.

Auxiliary space: O(k), where k is the number of items in the resulting dictionary after filtering.
Method 3: Using a for loop and conditional statements:
Initialize a dictionary test_dict with some key-value pairs.
Print the original dictionary using print(“The original dictionary : ” + str(test_dict)).
Initialize an integer K with value 3.
Create an empty dictionary res to store the filtered values.
Loop through the key-value pairs of the dictionary using for key, val in test_dict.items()
Use a conditional statement to filter the dictionary values. If the value is not an integer or it is
greater than K, we add it to the res dictionary using res[key] = val.
Print the filtered dictionary using print(“Values greater than K : ” + str(res)).

Python3
# Using for loop and conditional statements
# initializing K
K=3
res = {}
for key, val in test_dict.items():
if type(val) != int or val > K:
res[key] = val
# printing result
Output
The original dictionary : {'Gfg': 4, 'is': 2, 'best': 3, 'for': 'geeks'}

Auxiliary space: O(n), where n is the number of key-value pairs in the dictionary.
Method #4: Using a dictionary comprehension with if condition:

Initialize a variable K with a value to compare against dictionary values.
Use dictionary comprehension to filter out the items from the dictionary.
Loop through each key-value pair in the dictionary and check if the value is either non-integer or
greater than K.
If the value satisfies the condition, add the key-value pair to the result dictionary.
Return the filtered dictionary.
Python3
# initializing K
K=3
# Using dictionary comprehension with if condition
res = {k:v for k, v in test_dict.items() if type(v) != int or v > K}
# printing result
Output
Time complexity: O(n) as it loops through all the items in the dictionary once.
Auxiliary space: O(n) as it creates a new dictionary to store the filtered items.
Method #6: Using filter() function with lambda function
Initialize a variable K with a value of 3.
Use the filter() function to filter the items in the test_dict dictionary using a lambda function. The
lambda function checks if an item’s value is not an integer or is greater than K.
Convert the filtered items into a dictionary using the dict() function.
Assign the filtered dictionary to a variable named res.
Print the filtered dictionary using the print() function.
Python3
# initializing K
K=3
# Using filter() function with lambda function
res = dict(filter(lambda item: not(isinstance(item[1], int) and item[1] <= K), test_dict.items()))
# printing result
Python | Filter dictionary key based on the values in selective list

manjeet_04
 Read
 Discuss
 Courses
 Practice
In Python, sometimes we require to get only some of the dictionary keys and not all. This problem is
quite common in web development we require to get only the selective dictionary keys from some
given list. Let’s discuss certain ways in which this problem can be solved.
Method #1: Using list comprehension
The list comprehension can be used to solve this particular problem. This is just the shorthand way
of performing it instead of writing a loop.
Python3
# Python3 code to demonstrate
# getting selective dictionary keys
# using list comprehension
test_dict = {"Akash" : 1, "Akshat" : 2, "Nikhil" : 3, "Manjeet" : 4}
# initializing selective list keys
select_list = ['Manjeet', 'Nikhil']
print ("The original dictionary is : " + str(test_dict))
# printing selective list
print ("The selective list is : " + str(select_list))

res = [test_dict[i] for i in select_list if i in test_dict]
# printing result
print ("The selected values from list keys is : " + str(res))
Output
The original dictionary is : {'Akash': 1, 'Akshat': 2, 'Nikhil': 3, 'Manjeet': 4}
The selective list is : ['Manjeet', 'Nikhil']
The selected values from list keys is : [4, 3]
Method #2: Using set.intersection() This is the most elegant method in which this task can be
performed. The intersection property of sets can give the common keys that can be extracted and
then values can be computed.
Python3
# using set.intersection()
print ("The original dictionary is : " + str(test_dict))
print ("The selective list is : " + str(select_list))

# using set.intersection()
temp = list(set(select_list).intersection(test_dict))
res = [test_dict[i] for i in temp]
# printing result
Output
Time complexity: O(n), where n is the length of the longest input, i.e., the length of the list select_list
or the number of keys in the dictionary test_dict, whichever is larger. This is because the program
iterates through the list once to create a set, iterates through the dictionary once to check for
intersection, and iterates through the resulting keys once to retrieve the values.
Auxiliary space: O(m), where m is the number of keys in the resulting dictionary. This is because the
program creates a set and a list of length at most m to store the intersection of keys and the
corresponding values.
Method 3: Using simple for loop:
Initialize a dictionary called test_dict with some key-value pairs.
Initialize a list called select_list with some keys from the dictionary.
Print the original dictionary and the selective list.
Create an empty list called res to store the selected values from the dictionary.
Loop through each key in the select_list.
Check if the key exists in the test_dict dictionary using an if statement.
If the key exists, add the corresponding value to the res list using the append() method.
After all keys have been checked, print the res list, which contains the selected values from the
dictionary.
Python3
test_dict = {"Akash": 1, "Akshat": 2, "Nikhil": 3, "Manjeet": 4}

print("The selective list is : " + str(select_list))
# using for loop to iterate over selective list and get
# corresponding values from dictionary
res = []
for key in select_list:
# check if key is in dictionary
if key in test_dict:
# add corresponding value to result list
res.append(test_dict[key])
# printing result
print("The selected values from list keys is : " + str(res))
Output
Method 4: Using filter() function
The filter() function checks if each key in the selective list is present in the dictionary using the
__contains__() method of the dictionary. The resulting filtered list of keys is then passed to the
map() function along with the get() method of the dictionary. The map() function returns the values
corresponding to each key in the filtered list.
Python3
# using filter() and map() functions
res = list(map(test_dict.get, filter(test_dict.__contains__, select_list)))
# printing result
Output
The time complexity of this approach is O(n), where n is the length of the selective list.
The auxiliary space complexity of this approach is O(m), where m is the number of keys in the
selective list that are also present in the dictionary.
Method#5: Using the Recursive method.
Initialize the dictionary and selective list.
Define a recursive function that takes the dictionary and the list of keys as parameters.
If the list of keys is empty, return an empty list.
Get the first key from the list.
Check if the key is in the dictionary.
If the key is in the dictionary, add its value to the result list.
Recursively call the function with the remaining keys in the list.
Concatenate the result of step 6 with the result of step 7.
Return the result list.
Python3
# defining the recursive function
def get_values_recursive(dictionary, keys):
# base case: if the list of keys is empty
if not keys:
return []

# get the first key from the list
key = keys[0]

# if the key is in the dictionary, add its value to the result list
if key in dictionary:
res = [dictionary[key]]
else:
res = []

# recursively call the function with the remaining keys in the list
res += get_values_recursive(dictionary, keys[1:])

return res
test_dict = {"Akash": 1, "Akshat": 2, "Nikhil": 3, "Manjeet": 4}

print("The selective list is : " + str(select_list))
# calling the recursive function to get the values for the selected keys
res = get_values_recursive(test_dict, select_list)
# printing result
print("The selected values from list keys is : " + str(res))
Python | Filter the negative values from given dictionary

garg_ak0109
 Read
 Discuss
 Courses
 Practice
Given a dictionary, the task is to filter all the negative values from given dictionary. Let’s discuss few
methods to do this task.
Method #1: Using dict comprehension
Follow the below steps to implement:
Initializing a dictionary named ini_dict with some key-value pairs.
Next, create a new dictionary named result using dictionary comprehension. Dictionary
comprehension is a concise way to create dictionaries from other iterables like lists, tuples, and sets.
In the dictionary comprehension, iterate over the key-value pairs of the ini_dict using

the items() method.
For each key-value pair, check if the value is greater than or equal to 0 using the if condition.
If the condition is true, add the key-value pair to the new dictionary result.
Finally, print the filtered dictionary result using the print() function.
Python3
# return the filtered dictionary
# on certain criteria
# Initialising dictionary
ini_dict = {'a':1, 'b':-2, 'c':-3, 'd':7, 'e':0}
print ("initial lists", str(ini_dict))
# filter dictionary such that no value is greater than 0
result = dict((k, v) for k, v in ini_dict.items() if v >= 0)

print("resultant dictionary : ", str(result))
Output
initial lists {'a': 1, 'b': -2, 'c': -3, 'd': 7, 'e': 0}
resultant dictionary : {'a': 1, 'd': 7, 'e': 0}

Method #2: Using lambda and filter
Python3
ini_dict = {'a':1, 'b':-2, 'c':-3, 'd':7, 'e':0}
print ("initial lists", str(ini_dict))
result = dict(filter(lambda x: x[1] >= 0.0, ini_dict.items()))
result = dict(result)
print("resultant dictionary : ", str(result))
Output
Time Complexity: O(n) where n is the number of elements in the dictionary.

Auxiliary Space: O(n) as the size of the resultant dictionary can be equal to the number of elements
in the initial dictionary.
Method #3 : Using find() method
Python3
ini_dict = {'a': 1, 'b': -2, 'c': -3, 'd': 7, 'e': 0}
print("initial lists", str(ini_dict))
res = dict()
for i in ini_dict:
if(str(ini_dict[i]).find("-") != 0):
res[i] = ini_dict[i]
print("resultant dictionary : ", str(res))
Output
The time complexity of this code is O(n), where n is the number of items in the initial dictionary
ini_dict.
The auxiliary space used by this code is O(n).
Method #4 : Using map() and a custom function
Here is an example of using map() and a custom function to filter negative values from a dictionary:
Python3
#If the value is negative, it returns None.
def filter_negative(item):
key, value = item
if value < 0:
return
return (key, value)
#Initialize the dictionary
ini_dict = {'a': 1, 'b': -2, 'c': -3, 'd': 7, 'e': 0}
#Use map to apply the filter_negative function to each item in the dictionary and return a map
object
#Use filter to remove the None values from the map object
#Use dict to convert the map object to a dictionary
result = dict(filter(None, map(filter_negative, ini_dict.items())))
#Print the resulting dictionary
print(result)
#This code is contributed by Edula Vinay Kumar Reddy
Output
{'a': 1, 'd': 7, 'e': 0}
The filter_negative() function takes a tuple representing a key-value pair in the dictionary, and
returns the tuple if the value is non-negative. If the value is negative, the function returns None,
which is filtered out by the filter() function. The map() function applies filter_negative() to each item
in the dictionary, producing a list of tuples. The filter() function then filters out any None values, and
the resulting list is passed to dict() to create the final filtered dictionary.
Time complexity: O(n), where n is the number of items in the dictionary. T

Auxiliary Space: O(n), as the filtered dictionary will have a size equal to the number of non-negative
values in the original dictionary.
Method #5 : Using startswith() method
Python3

ini_dict = {'a': 1, 'b': -2, 'c': -3, 'd': 7, 'e': 0}
print("initial lists", str(ini_dict))
res = dict()
for i in list(ini_dict.keys()):
x=str(ini_dict[i])
if(not x.startswith("-")):
res[i]=ini_dict[i]

print("resultant dictionary : ", str(res))
Output

Method #6: Using list comprehension and dict() constructor
Initialize the dictionary ini_dict
Print the initial dictionary ini_dict
Use a list comprehension to filter the dictionary such that no value is greater than 0. Store the
resulting key-value pairs as a list of tuples.
Convert the list of tuples into a dictionary using the dict() constructor.
Print the resultant dictionary result.
Compute the time complexity and auxiliary space complexity.
Python3
ini_dict = {'a':1, 'b':-2, 'c':-3, 'd':7, 'e':0}
print ("initial dictionary:", ini_dict)
# using list comprehension and dict() constructor
result = dict([(k, v) for k, v in ini_dict.items() if v >= 0])
# printing resultant dictionary
print("resultant dictionary:", result)
# compute time complexity and auxiliary space
# time complexity: O(N)
# auxiliary space: O(N)
Spatial Filters – Averaging filter and Median filter in Image Processing

AmiMunshi
 Read
 Discuss
 Courses
 Practice
Spatial Filtering technique is used directly on pixels of an image. Mask is usually considered to be

added in size so that it has a specific center pixel. This mask is moved on the image such that the
center of the mask traverses all image pixels.
In this article, we are going to cover the following topics –
To write a program in Python to implement spatial domain averaging filter and to observe its
blurring effect on the image without using inbuilt functions
To write a program in Python to implement spatial domain median filter to remove salt and pepper
noise without using inbuilt functions
Theory
Neighborhood processing in spatial domain: Here, to modify one pixel, we consider values of the
immediate neighboring pixels also. For this purpose, 3X3, 5X5, or 7X7 neighborhood mask can be
considered. An example of a 3X3 mask is shown below.
f(x-1, y-1) f(x-1, y) f(x-1, y+1)
f(x, y-1) f(x, y) f(x, y+1)
f(x+1, y-1) f(x+1, y) f(x+1, y+1)
Low Pass filtering: It is also known as the smoothing filter. It removes the high-frequency content
from the image. It is also used to blur an image. A low pass averaging filter mask is as shown.
1/9 1/9 1/9
1/9 1/9 1/9
1/9 1/9 1/9
High Pass Filtering: It eliminates low-frequency regions while retaining or enhancing the high-
frequency components. A high pass filtering mask is as shown.
-1/9 -1/9 -1/9
-1/9 8/9 -1/9
-1/9 -1/9 -1/9
Median Filtering: It is also known as nonlinear filtering. It is used to eliminate salt and pepper noise.
Here the pixel value is replaced by the median value of the neighboring pixel.
Below is the implementation.

Input Image:
Averaging Filter:
Python3
# Low Pass SPatial Domain Filtering
# to observe the blurring effect

import cv2
import numpy as np

# Read the image
img = cv2.imread('sample.png', 0)

# Obtain number of rows and columns
# of the image
m, n = img.shape

# Develop Averaging filter(3, 3) mask
mask = np.ones([3, 3], dtype = int)
mask = mask / 9

# Convolve the 3X3 mask over the image
img_new = np.zeros([m, n])

for i in range(1, m-1):
for j in range(1, n-1):
temp = img[i-1, j-1]*mask[0, 0]+img[i-1, j]*mask[0, 1]+img[i-1, j + 1]*mask[0, 2]+img[i, j-

1]*mask[1, 0]+ img[i, j]*mask[1, 1]+img[i, j + 1]*mask[1, 2]+img[i + 1, j-1]*mask[2, 0]+img[i + 1,
j]*mask[2, 1]+img[i + 1, j + 1]*mask[2, 2]

img_new[i, j]= temp

img_new = img_new.astype(np.uint8)
cv2.imwrite('blurred.tif', img_new)
Output:
In the above example, it is observed that the filtered image is slightly blurred. If we increase the size
of the averaging mask, more blurring can be obtained.
Median Filtering:
Python3
# Median Spatial Domain Filtering

import cv2
import numpy as np

# Read the image
img_noisy1 = cv2.imread('sample.png', 0)

# Obtain the number of rows and columns
# of the image
m, n = img_noisy1.shape

# Traverse the image. For every 3X3 area,
# find the median of the pixels and
# replace the center pixel by the median
img_new1 = np.zeros([m, n])

for i in range(1, m-1):
for j in range(1, n-1):
temp = [img_noisy1[i-1, j-1],
img_noisy1[i-1, j],
img_noisy1[i-1, j + 1],
img_noisy1[i, j-1],
img_noisy1[i, j],
img_noisy1[i, j + 1],
img_noisy1[i + 1, j-1],
img_noisy1[i + 1, j],
img_noisy1[i + 1, j + 1]]

temp = sorted(temp)
img_new1[i, j]= temp[4]

img_new1 = img_new1.astype(np.uint8)
cv2.imwrite('new_median_filtered.png', img_new1)
Python – Split Dictionary values on size limit of values
manjeet_04
 Read
 Discuss
 Courses
 Practice
Given a dictionary with string values, the task is to write a python program to split values if the size
of string exceeds K.
Input : {1 : “Geeksforgeeks”, 2 : “best for”, 3 : “all geeks”}, limit = 5

Output : {1: ‘Geeks’, 2: ‘forge’, 3: ‘eks’, 4: ‘best ‘, 5: ‘for’, 6: ‘all g’, 7: ‘eeks’}
Explanation : All string values are capped till length 5. New value is created post size limit.
Input : {1 : “Geeksforgeeks”, 2 : “best for”}, limit = 5

Output : {1: ‘Geeks’, 2: ‘forge’, 3: ‘eks’, 4: ‘best ‘, 5: ‘for’}
Explanation : All string values are capped till length 5. New value is created post size limit.
Method 1: Using dictionary comprehension + enumerate() + list slicing
In this, we perform the task of getting required value chunks using list slicing and list comprehension
on the iteration of values extracted using values(). The next step is to reassign keys with new
chunked values using list comprehension and enumerate().
Python3
# Split Dictionary values on size limit
# Using dictionary comprehension + enumerate() + list slicing
test_dict = {1: "Geeksforgeeks",
2: "best for", 3:
"all geeks"}
# initializing limit
limit = 4
# cutting chunks of K
chunks = (sub[idx: idx + limit] for sub in test_dict.values()
for idx in range(0, len(sub), limit))
# re assigning dictionary with chunks
res = {key: val for key, val in enumerate(chunks, 1)}
# printing result
print("The extracted values : " + str(res))
Output:
The original dictionary is : {1: ‘Geeksforgeeks’, 2: ‘best for’, 3: ‘all geeks’}
The extracted values : {1: ‘Geek’, 2: ‘sfor’, 3: ‘geek’, 4: ‘s’, 5: ‘best’, 6: ‘ for’, 7: ‘all ‘, 8: ‘geek’, 9: ‘s’}
Method 2: Using a for loop and string slicing
Initialize an empty dictionary called res.
Loop through each key-value pair in the test_dict.
For each value in the key-value pair, slice it into chunks of size limit using string slicing and store
them in a temporary list called chunks.
Loop through each chunk in chunks, and add it as a value to the res dictionary with a new key that is
incremented by 1 for each chunk.
Print the resulting dictionary res.
Python3
# Using for loop and string slicing

2: "best for", 3:
"all geeks"}
limit = 4
# initializing empty dictionary for result
res = {}
# loop through each key-value pair in test_dict
for key, value in test_dict.items():
# split value into chunks of size limit using string slicing
chunks = [value[i:i+limit] for i in range(0, len(value), limit)]
# loop through each chunk and add it to res with a new key
for i, chunk in enumerate(chunks):
res[len(res)+1] = chunk
# printing result
Output
The original dictionary is : {1: 'Geeksforgeeks', 2: 'best for', 3: 'all geeks'}
The extracted values : {1: 'Geek', 2: 'sfor', 3: 'geek', 4: 's', 5: 'best', 6: ' for', 7: 'all ', 8: 'geek', 9: 's'}
Time complexity: O(nm), where n is the number of key-value pairs in test_dict and m is the
maximum length of any value in test_dict.
Auxiliary space: O(nm), since we are creating a new dictionary with the same number of key-value
pairs as test_dict, and each value can be split into multiple chunks of size limit.
Method 3: Using a while loop and dictionary update
Initialize the original dictionary test_dict.
Initialize the size limit.
Create an empty dictionary res to store the result.
Loop over the items in the original dictionary using items().
Initialize the start index start to 0.
While the start index is less than the length of the value, do the following:
a. Calculate the end index end for slicing by adding the limit to the start index.
b. Slice the value using the start and end indices, and add the result to the result dictionary with a
new key.
c. Increment the start index by the limit.
Print the result dictionary.
Python3
# Using while loop and dictionary update
2: "best for", 3:
"all geeks"}
limit = 4
# create an empty dictionary to store the result
res = {}
# loop over the items in the original dictionary

# initialize the start index for slicing
start = 0

# split the value into chunks of size limit
while start < len(value):

# get the end index for slicing
end = start + limit

# slice the value and add it to the result dictionary
res[len(res) + 1] = value[start:end]

# increment the start index
start = end
# printing result
Output
The original dictionary is : {1: 'Geeksforgeeks', 2: 'best for', 3: 'all geeks'}
Time complexity: O(n*m), where n is the number of values in the original dictionary and m is the
maximum length of a value in the dictionary.
Auxiliary space: O(n*m), because we need to create a new dictionary to store the result, and the size
of this dictionary is proportional to the number of values in the original dictionary and the maximum
length of a value.
Method 4: Using list comprehension and dictionary update
Start by initializing the original dictionary and the size limit.
Create an empty dictionary to store the result.
Use list comprehension to split each value in the dictionary into chunks of size limit.
Loop over the items in the original dictionary, and use dictionary update to add each chunk as a new
value to the result dictionary.
Print the result.
Python3
2: "best for", 3:
"all geeks"}
limit = 4
# create an empty dictionary to store the result
res = {}
# use list comprehension to split each value in the dictionary into chunks of size limit
chunks = [value[i:i+limit] for value in test_dict.values() for i in range(0, len(value), limit)]
# loop over the items in the original dictionary and use dictionary update to add each chunk as a
new value to the result dictionary
res[i+1] = chunk

# printing result
Output
Time complexity: O(nm), where n is the number of items in the dictionary and m is the length of the
longest value in the dictionary.
Auxiliary space: O(nm), to store the chunks of each value in the list comprehension.
Method 5: Using built-in function divmod()
Initialize the original dictionary, test_dict.
Set the limit of each chunk, limit.
Initialize an empty dictionary to store the split chunks, res.
Loop through each key-value pair in test_dict.
Calculate the number of chunks needed to split the value, num_chunks, using divmod().
Split the value into num_chunks chunks using a list comprehension and string slicing, and store them
in a list, chunks.
Loop through each chunk in chunks, and add it to res with a new key.
Return the res dictionary.
Python3
# Using divmod() and list comprehension
2: "best for",
3: "all geeks"}

limit = 4
# initializing empty dictionary for result
res = {}
# loop through each key-value pair in test_dict
# calculate the number of chunks needed to split the value
num_chunks, remainder = divmod(len(value), limit)
if remainder:
num_chunks += 1
# split value into chunks of size limit using string slicing
chunks = [value[i:i+limit] for i in range(0, len(value), limit)]
# loop through each chunk and add it to res with a new key
res[len(res)+1] = chunk
# printing result
Output
Python – Extract Unique values dictionary values

manjeet_04
 Read
 Discuss
 Courses
 Practice
Sometimes, while working with data, we can have problem in which we need to perform the
extraction of only unique values from dictionary values list. This can have application in many
domains such as web development. Lets discuss certain ways in which this task can be performed.
Method #1 : Using sorted() + set comprehension + values() The combination of above functionalities

can be used to perform this task. In this, we extract all the values using values() and set
comprehension is used to get unique values compiled in list.
Python3
# Extract Unique values dictionary values
# Using set comprehension + values() + sorted()
test_dict = {'gfg': [5, 6, 7, 8],
'is': [10, 11, 7, 5],
'best': [6, 12, 10, 8],
'for': [1, 2, 5]}
# Using set comprehension + values() + sorted()
res = list(sorted({ele for val in test_dict.values() for ele in val}))
# printing result
print("The unique values list is : " + str(res))
Output
The original dictionary is : {'gfg': [5, 6, 7, 8], 'is': [10, 11, 7, 5], 'best': [6, 12, 10, 8], 'for': [1, 2, 5]}
The unique values list is : [1, 2, 5, 6, 7, 8, 10, 11, 12]
Time Complexity: O(nlogn)

Method #2 : Using chain() + sorted() + values() This performs the task in similar way. The difference
is that the task of set comprehension is performed using chain().
Python3
# Using chain() + sorted() + values()
from itertools import chain
test_dict = {'gfg': [5, 6, 7, 8],
'is': [10, 11, 7, 5],
'best': [6, 12, 10, 8],
'for': [1, 2, 5]}
# Using chain() + sorted() + values()
res = list(sorted(set(chain(*test_dict.values()))))
# printing result
Output
The time complexity of the code is O(nlog(n)) where n is the total number of elements in all the lists
of the dictionary.
The auxiliary space complexity of the code is O(n) because it creates a new list of all the values in the
dictionary using the values() method, which requires O(n) space.
Method #3: Using keys(),extend(),list(),set() and sort() methods
Python3
test_dict = {'gfg' : [5, 6, 7, 8],
'is' : [10, 11, 7, 5],
'best' : [6, 12, 10, 8],
'for' : [1, 2, 5]}
x=[]
for i in test_dict.keys():
x.extend(test_dict[i])
x=list(set(x))
x.sort()
# printing result
print("The unique values list is : " + str(x))
Output

Time complexity: O(n*m*log(m)), where n is the number of keys in the dictionary and m is the
maximum length of the lists in the dictionary.
Auxiliary space: O(n*m), where n is the number of keys in the dictionary and m is the maximum
length of the lists in the dictionary.
Method #4 : Using extend() and sort() methods
Python3
test_dict = {'gfg' : [5, 6, 7, 8],
'is' : [10, 11, 7, 5],
'best' : [6, 12, 10, 8],
'for' : [1, 2, 5]}
x=list(test_dict.values())
y=[]
res=[]
for i in x:
y.extend(i)
for i in y:
if i not in res:
res.append(i)
res.sort()
# printing result
Output
Time Complexity: O(nlogn)
Method #5: Using Counter(),append() and sort() methods
Import the Counter class from the collections module.
Define a dictionary test_dict with string keys and lists of integers as values.
Create an empty list called valuesList.
Iterate over the dictionary using the items() method to access the keys and values. For each key-
value pair, iterate over the values list and append each value to valuesList.
Use the Counter() function to count the frequency of each value in valuesList. This creates a
dictionary where the keys are the unique values in valuesList and the values are their frequencies.
Use the keys() method to extract a list of the unique values from freq.
Sort the uniqueValues list in ascending order.
Print the final list of unique values
Python3
from collections import Counter
test_dict = {'gfg': [5, 6, 7, 8],
'is': [10, 11, 7, 5],
'best': [6, 12, 10, 8],
'for': [1, 2, 5]}
valuesList = []
for key, values in test_dict.items():
for value in values:

valuesList.append(value)
freq = Counter(valuesList)
uniqueValues = list(freq.keys())
uniqueValues.sort()
# printing result
print("The unique values list is : " + str(uniqueValues))
Output
The time complexity of the above program is O(nmlog(m)), where n is the number of keys in the
dictionary and m is the average number of values per key.
Auxiliary space complexity is O(n*m).
Method #6:Using Operator.countOf() method
STEPS:
Import the “operator” module as “op”.
Create a dictionary called “test_dict” and initialize it with some key-value pairs where each key is a
string and the value is a list of integers.
Print the original dictionary using the “print()” function.
Create an empty list called “x”.
Get all the values of the dictionary and append them to the list “x” using the “list()” function and the
“values()” method of the dictionary.
Create an empty list called “y”.
Iterate over each item in the list “x” using a for loop and append all the elements of each list to the
list “y” using the “extend()” method.
Create an empty list called “res”.
Iterate over each item in the list “y” using a for loop.
Check if the count of the current item in the list “res” is zero using the “countOf()” method of the
“operator” module.
If the count is zero, append the current item to the list “res” using the “append()” method.
Sort the list “res” using the “sort()” method.
Print the unique values list using the “print()” function.

Python3
import operator as op
test_dict = {'gfg' : [5, 6, 7, 8],
'is' : [10, 11, 7, 5],
'best' : [6, 12, 10, 8],
'for' : [1, 2, 5]}
x=list(test_dict.values())
y=[]
res=[]
for i in x:
y.extend(i)
for i in y:
if op.countOf(res,i)==0:
res.append(i)
res.sort()
# printing result
Output
Auxiliary Space: O(N*N)
Time Complexity:O(N)
Method 7: Using set() + sum()
Python3
#Python3 code to demonstrate working of
#Extract Unique values dictionary values
#initializing dictionary
test_dict = {'gfg' : [5, 6, 7, 8],
'is' : [10, 11, 7, 5],
'best' : [6, 12, 10, 8],
'for' : [1, 2, 5]}
#printing original dictionary
#Extract Unique values dictionary values
result = list(set(sum(test_dict.values(), [])))
#printing result
print("The unique values list is : " + str(result))
Python – Filter dictionary values in heterogeneous dictionary

manjeet_04
 Read
 Discuss
 Courses
 Practice
Sometimes, while working with Python dictionaries, we can have a problem in which we need to
filter out certain values based on certain conditions on a particular type, e.g all values smaller than K.
This task becomes complex when dictionary values can be heterogeneous. This kind of problem can
have applications across many domains. Let’s discuss certain ways in which this task can be
performed.
Input : test_dict = {‘Gfg’ : 10, ‘for’ : ‘geeks’}

Output : {‘Gfg’: 10, ‘for’: ‘geeks’}
Input : test_dict = {‘Gfg’ : ‘geeks’}

Output : {‘Gfg’: ‘geeks’}
Method #1 : Using type() + dictionary comprehension

The combination of above functions can be used to perform this task. In this, we check for integral
type using type() and filter the data in dictionary comprehension.
Step-by-step approach
Use dictionary comprehension to create a new dictionary res.
Iterate over the items of test_dict using the items() method.
For each item, check if the value is not an integer (type(val) != int) or if it is greater than K (val > K).
If the condition is true, add the key-value pair to the new dictionary res.
Print the new dictionary res using the print() function.
Python3

# initializing K
K=3
if type(val) != int or val > K}
# printing result
Output :

Method #2 : Using isinstance() + dictionary comprehension

The combination of above functions can also be used to solve this problem. In this, we perform this
task similar to above, but the difference being that type test is done by isinstance() rather than
type().
Python3
# initializing K
K=3
if not isinstance(val, int) or val > K}
# printing result
Output :

Auxiliary space: O(k), where k is the number of items in the resulting dictionary after filtering.
Method 3: Using a for loop and conditional statements:
Print the original dictionary using print(“The original dictionary : ” + str(test_dict)).
Initialize an integer K with value 3.
Create an empty dictionary res to store the filtered values.
Loop through the key-value pairs of the dictionary using for key, val in test_dict.items()
Use a conditional statement to filter the dictionary values. If the value is not an integer or it is
greater than K, we add it to the res dictionary using res[key] = val.
Print the filtered dictionary using print(“Values greater than K : ” + str(res)).

Python3
# initializing K
K=3
res = {}
for key, val in test_dict.items():
if type(val) != int or val > K:
res[key] = val
# printing result
Output
The original dictionary : {'Gfg': 4, 'is': 2, 'best': 3, 'for': 'geeks'}

Method #4: Using a dictionary comprehension with if condition:

Initialize a variable K with a value to compare against dictionary values.
Use dictionary comprehension to filter out the items from the dictionary.
Loop through each key-value pair in the dictionary and check if the value is either non-integer or
greater than K.
If the value satisfies the condition, add the key-value pair to the result dictionary.
Return the filtered dictionary.
Python3
# initializing K
K=3
# Using dictionary comprehension with if condition
res = {k:v for k, v in test_dict.items() if type(v) != int or v > K}
# printing result
Output
Time complexity: O(n) as it loops through all the items in the dictionary once.
Auxiliary space: O(n) as it creates a new dictionary to store the filtered items.
Method #6: Using filter() function with lambda function
Initialize a variable K with a value of 3.
Use the filter() function to filter the items in the test_dict dictionary using a lambda function. The
lambda function checks if an item’s value is not an integer or is greater than K.
Convert the filtered items into a dictionary using the dict() function.
Assign the filtered dictionary to a variable named res.
Print the filtered dictionary using the print() function.
Python3
# initializing K
K=3
# Using filter() function with lambda function
res = dict(filter(lambda item: not(isinstance(item[1], int) and item[1] <= K), test_dict.items()))
# printing result
Python – Replace dictionary value from other dictionary

manjeet_04
 Read
 Discuss
 Courses
 Practice
Given two dictionaries, update the values from other dictionary if key is present in other dictionary.
Input : test_dict = {“Gfg” : 5, “is” : 8, “Best” : 10, “for” : 8, “Geeks” : 9}, updict = {“Geeks” : 10,
“Best” : 17}
Output : {‘Gfg’: 5, ‘is’: 8, ‘Best’: 17, ‘for’: 8, ‘Geeks’: 10}
Explanation : “Geeks” and “Best” values updated to 10 and 17.
Input : test_dict = {“Gfg” : 5, “is” : 8, “Best” : 10, “for” : 8, “Geeks” : 9}, updict = {“Geek” : 10, “Bet” :
17}
Explanation : No values matched, hence original dictionary.
Method #1 : Using loop
This is brute way in which this task can be performed. In this, we run a loop for each key in target
dictionary and update in case the value is present in other dictionary.
Python3
# Replace dictionary value from other dictionary
# Using loop
test_dict = {"Gfg" : 5, "is" : 8, "Best" : 10, "for" : 8, "Geeks" : 9}
# initializing updict
updict = {"Gfg" : 10, "Best" : 17}


# checking if key present in other dictionary
if sub in updict:
test_dict[sub] = updict[sub]
# printing result
print("The updated dictionary: " + str(test_dict))
Output
The original dictionary is : {'Gfg': 5, 'is': 8, 'Best': 10, 'for': 8, 'Geeks': 9}
The updated dictionary: {'Gfg': 10, 'is': 8, 'Best': 17, 'for': 8, 'Geeks': 9}

Method #2 : Using dictionary comprehension
This is one liner approach in which this task can be performed. In this, we iterate for all the
dictionary values and update in a one-liner manner in dictionary comprehension.
Python3
updict = {"Gfg" : 10, "Best" : 17}

res = {key: updict.get(key, test_dict[key]) for key in test_dict}
# printing result
print("The updated dictionary: " + str(res))
Output
Time complexity: O(n),
Auxiliary space: O(m),
Method #3: Using dict.update() method
This program updates the values of certain keys in a dictionary by using the update() method. It
initializes two dictionaries (test_dict and updict), updates the values of the keys “Gfg” and “Best” in
test_dict using the corresponding values in updict, and then prints the updated test_dict.
Python3
# Using dict.update() method
updict = {"Gfg" : 10, "Best" : 17}
# updating dictionary using dict.update() method

test_dict.update(updict)
# printing result
Output
Time complexity: O(m), where m is the size of the updict.
Auxiliary space: O(1), as the algorithm updates the existing dictionary in place and does not use any
additional space proportional to the size of the input.
Method #5: Using the built-in map() function and a lambda function
In this method, we first create a list of updated values by mapping a lambda function to the keys of
the original dictionary. The lambda function checks if the key is present in the second dictionary, and
if it is, returns the corresponding value from the second dictionary. Otherwise, it returns the value
from the original dictionary.
Python3
test_dict = {"Gfg": 5, "is": 8, "Best": 10, "for": 8, "Geeks": 9}
updict = {"Gfg": 10, "Best": 17}
updated_values = map(
lambda key: updict[key] if key in updict else test_dict[key], test_dict)
updated_dict = dict(zip(test_dict.keys(), updated_values))

print("The updated dictionary: " + str(updated_dict))
Output
The time complexity of this code is O(N), where N is the number of key-value pairs in the test_dict.
The auxiliary space complexity of this code is also O(N), as we use a map() object to store the
updated values, and then we create a new dictionary using the zip() function.
Method 6: Using defaultdict
Use the defaultdict class from the collections module to create a new dictionary with default values
set to the values of the original dictionary. We will then update the values of the keys present in the
updict.
Create a defaultdict with default values from the original dictionary
Update the values of the keys present in the updict
Convert the defaultdict back to a regular dictionary
Python3
# create a defaultdict with default values from the original dictionary
default_dict = defaultdict(lambda: None, test_dict)
# update the values of the keys present in the updict
for key, value in updict.items():
default_dict[key] = value

# convert the defaultdict back to a regular dictionary
updated_dict = dict(default_dict)
Python – Append Dictionary Keys and Values ( In order ) in dictionary

manjeet_04
 Read
 Discuss
 Courses
 Practice
Given a dictionary, perform append of keys followed by values in list.
Input : test_dict = {“Gfg” : 1, “is” : 2, “Best” : 3}

Output : [‘Gfg’, ‘is’, ‘Best’, 1, 2, 3]
Explanation : All the keys before all the values in list.
Input : test_dict = {“Gfg” : 1, “Best” : 3}

Output : [‘Gfg’, ‘Best’, 1, 3]
Explanation : All the keys before all the values in list.
Method #1 : Using list() + keys() + values()
This is one of the ways in which this task can be performed. In this, we extract keys and values using
keys() and values(), convert then to list using list() and perform append in order.
Python3
# Append Dictionary Keys and Values ( In order ) in dictionary
# Using values() + keys() + list()
test_dict = {"Gfg" : 1, "is" : 3, "Best" : 2}
# + operator is used to perform adding keys and values
res = list(test_dict.keys()) + list(test_dict.values())
# printing result
print("The ordered keys and values : " + str(res))
Output
The original dictionary is : {'Gfg': 1, 'is': 3, 'Best': 2}
The ordered keys and values : ['Gfg', 'is', 'Best', 1, 3, 2]
Method #2 : Using chain() + keys() + values()
This is one of the ways in which this task can be performed. In this, we bind keys with values
together in order using chain().
Python3
# Using chain() + keys() + values()
from itertools import chain
# chain() is used for concatenation
res = list(chain(test_dict.keys(), test_dict.values()))
# printing result
Output

Time complexity: O(n), where n is the size of the dictionary.
Auxiliary space: O(n), as we are creating a list of size 2n to store the concatenated keys and values.
Method #3 : Using list() +keys() + values() + extend()
Python3
# Append Dictionary Keys and Values
#( In order ) in dictionary
# Using values() + keys() + extend()+list()
test_dict = {"Gfg": 1, "is": 3, "Best": 2}
a = list(test_dict.keys())
b = list(test_dict.values())
a.extend(b)
res = a
# printing result
Output

Method #4: Using zip() function and list comprehension
This program initializes a dictionary and prints it. It then uses a zip() function and list comprehension
to create a list of key-value pairs where the values come first, and then the keys. It finally prints the
ordered key-value pairs.
Python3
test_dict = {"Gfg": 1, "is": 3, "Best": 2}
# using the zip() function and list comprehension to append dictionary keys and values
res = [val for val in zip(test_dict.values(), test_dict.keys())]
# printing result
Output
The ordered keys and values : [(1, 'Gfg'), (3, 'is'), (2, 'Best')]

Auxiliary space: O(n), as we are creating a list of n items using the list comprehension.
Method #5: Using sorted() function and list comprehension
Initialize the dictionary test_dict.
Print the original dictionary using the print() function.
Use the sorted() function to get the keys in alphabetical order, and assign the result to the keys
variable.
Use a list comprehension to get the values corresponding to each key in the keys list, and assign the
result to the values variable.
Concatenate the keys and values lists using the + operator, and assign the result to the res variable.
Print the ordered keys and values using the print() function.
Python3

# Using sorted() + list comprehension
# using sorted() to get the keys in alphabetical order
keys = sorted(test_dict.keys())
# using list comprehension to get the values corresponding to each key
values = [test_dict[key] for key in keys]
# concatenating the keys and values lists
res = keys + values
# printing result
Python – Replace dictionary value from other dictionary

manjeet_04
 Read
 Discuss
 Courses
 Practice
Given two dictionaries, update the values from other dictionary if key is present in other dictionary.
Input : test_dict = {“Gfg” : 5, “is” : 8, “Best” : 10, “for” : 8, “Geeks” : 9}, updict = {“Geeks” : 10,
“Best” : 17}
Explanation : “Geeks” and “Best” values updated to 10 and 17.
Input : test_dict = {“Gfg” : 5, “is” : 8, “Best” : 10, “for” : 8, “Geeks” : 9}, updict = {“Geek” : 10, “Bet” :
17}
Explanation : No values matched, hence original dictionary.
Method #1 : Using loop
This is brute way in which this task can be performed. In this, we run a loop for each key in target
dictionary and update in case the value is present in other dictionary.
Python3
# Using loop
updict = {"Gfg" : 10, "Best" : 17}


# checking if key present in other dictionary
if sub in updict:
test_dict[sub] = updict[sub]
# printing result
Output

Method #2 : Using dictionary comprehension
This is one liner approach in which this task can be performed. In this, we iterate for all the
dictionary values and update in a one-liner manner in dictionary comprehension.
Python3
updict = {"Gfg" : 10, "Best" : 17}

res = {key: updict.get(key, test_dict[key]) for key in test_dict}
# printing result
print("The updated dictionary: " + str(res))
Output
Time complexity: O(n),
Auxiliary space: O(m),
Method #3: Using dict.update() method
This program updates the values of certain keys in a dictionary by using the update() method. It
initializes two dictionaries (test_dict and updict), updates the values of the keys “Gfg” and “Best” in
test_dict using the corresponding values in updict, and then prints the updated test_dict.
Python3
# Using dict.update() method
updict = {"Gfg" : 10, "Best" : 17}
# updating dictionary using dict.update() method

test_dict.update(updict)
# printing result
Output
Time complexity: O(m), where m is the size of the updict.
Auxiliary space: O(1), as the algorithm updates the existing dictionary in place and does not use any
additional space proportional to the size of the input.
Method #5: Using the built-in map() function and a lambda function
In this method, we first create a list of updated values by mapping a lambda function to the keys of
the original dictionary. The lambda function checks if the key is present in the second dictionary, and
if it is, returns the corresponding value from the second dictionary. Otherwise, it returns the value
from the original dictionary.
Python3

Output
The time complexity of this code is O(N), where N is the number of key-value pairs in the test_dict.
The auxiliary space complexity of this code is also O(N), as we use a map() object to store the
updated values, and then we create a new dictionary using the zip() function.
Method 6: Using defaultdict
Use the defaultdict class from the collections module to create a new dictionary with default values
set to the values of the original dictionary. We will then update the values of the keys present in the
updict.
Create a defaultdict with default values from the original dictionary
Update the values of the keys present in the updict
Convert the defaultdict back to a regular dictionary
Python3
# create a defaultdict with default values from the original dictionary
default_dict = defaultdict(lambda: None, test_dict)
# update the values of the keys present in the updict
for key, value in updict.items():
default_dict[key] = value

# convert the defaultdict back to a regular dictionary
updated_dict = dict(default_dict)
Output
Time complexity: O(N+M), where N is the number of keys in the original dictionary and M is the
number of keys in the updict.
Auxiliary space: O(N), where N is the number of keys in the original dictionary.
Python – Replace value by Kth index value in Dictionary List

manjeet_04
 Read
 Discuss
 Courses
 Practice
Given a dictionary list, the task is to write a Python program to replace the value of a particular key
with kth index of value if the value of the key is list.
Examples:
Input : test_list = [{‘gfg’ : [5, 7, 9, 1], ‘is’ : 8, ‘good’ : 10}, {‘gfg’ : 1, ‘for’ : 10, ‘geeks’ : 9}, {‘love’ : 3, ‘gfg’
: [7, 3, 9, 1]}], K = 2, key = “gfg”
Output : [{‘gfg’: 9, ‘is’: 8, ‘good’: 10}, {‘gfg’: 1, ‘for’: 10, ‘geeks’: 9}, {‘love’: 3, ‘gfg’: 9}]
Explanation : gfg is assigned with 9 which is 2nd index in list.
Input : test_list = [{‘gfg’ : [5, 7, 9, 1], ‘is’ : 8, ‘good’ : 10}, {‘gfg’ : 1, ‘for’ : 10, ‘geeks’ : 9}], K = 2, key =
“gfg”
Output : [{‘gfg’: 9, ‘is’: 8, ‘good’: 10}, {‘gfg’: 1, ‘for’: 10, ‘geeks’: 9}]
Explanation : gfg is assigned with 9 which is 2nd index in list.
Method #1 : Using loop + isinstance()
Use isinstance() to check for list type of values and loop is used to iterate through dictionaries.
Loop over each dictionary sub in the list test_list.
Use the isinstance() function to check if the value corresponding to the key key is a list in the current
dictionary sub.
If the value is a list, update the value corresponding to the key key with the Kth element of the list.
Print the modified list of dictionaries test_list.
Python3
# Replace value by Kth index value in Dictionary List
# Using loop + isinstance()
# initializing list
test_list = [{'gfg': [5, 7, 9, 1], 'is': 8, 'good': 10},
{'gfg': 1, 'for': 10, 'geeks': 9},
{'love': 3, 'gfg': [7, 3, 9, 1]}]
# printing original list
print("The original list is : " + str(test_list))
# initializing K
K=2
# initializing Key
key = "gfg"
for sub in test_list:
# using isinstance() to check for list
if isinstance(sub[key], list):
sub[key] = sub[key][K]
# printing result
print("The Modified Dictionaries : " + str(test_list))
Output
The original list is : [{'gfg': [5, 7, 9, 1], 'is': 8, 'good': 10}, {'gfg': 1, 'for': 10, 'geeks': 9}, {'love': 3, 'gfg':
[7, 3, 9, 1]}]
The Modified Dictionaries : [{'gfg': 9, 'is': 8, 'good': 10}, {'gfg': 1, 'for': 10, 'geeks': 9}, {'love': 3, 'gfg':
9}]
Method #2 : Using dictionary comprehension + isinstance()
In this, we reconstruct dictionaries with modified dictionary values using isinstance() and dictionary
comprehension is used to form intermediate dictionaries.
Python3
# Using dictionary comprehension + isinstance()
# initializing list
{'gfg': 1, 'for': 10, 'geeks': 9},
{'love': 3, 'gfg': [7, 3, 9, 1]}]
# initializing K
K=2
# initializing Key
key = "gfg"
# intermediate Dictionaries constructed using dictionary comprehension
res = [{newkey: (val[K] if isinstance(val, list) and newkey == key else val)
for newkey, val in sub.items()} for sub in test_list]
# printing result
print("The Modified Dictionaries : " + str(res))
Output
[7, 3, 9, 1]}]
9}]
Method 3: Modifying the original list in-place using a list comprehension:
This approach uses a list comprehension to create a new list of dictionaries with the specified key
updated at index K, and then assigns the new list back to the original variable to modify it in-place.
The output of this code should match exactly with the original program.
Python3
# initializing list
{'gfg': 1, 'for': 10, 'geeks': 9},
{'love': 3, 'gfg': [7, 3, 9, 1]}]
# initializing K and key
K=2
key = "gfg"
# modifying the original list in-place using a list comprehension
test_list = [{k: (v[K] if k == key and isinstance(v, list) else v) for k, v in d.items()} for d in test_list]
# printing result
Output
[7, 3, 9, 1]}]
9}]
Method #4: Using for loop and try-except block

we can use a for loop to iterate over the dictionaries in the list, and a try-except block to check if the
key is present and if the value is a list. If the conditions are satisfied, we can replace the value with
the K-th element of the list.
Python3
# initializing list
{'gfg': 1, 'for': 10, 'geeks': 9},
{'love': 3, 'gfg': [7, 3, 9, 1]}]
# initializing K and key
K=2
key = "gfg"
# using for loop and try-except block
for d in test_list:
try:
if isinstance(d[key], list):
d[key] = d[key][K]
except KeyError:
pass
# printing result
Output
[7, 3, 9, 1]}]
9}]
Time complexity: O(nm)
Where n is the number of dictionaries in the list and m is the maximum number of keys in any
dictionary. This is because we need to iterate over each dictionary in the list and check each key to
see if it matches the given key and whether the value is a list.
Auxiliary space: O(1)
Because we are not creating any additional data structures. We are only modifying the existing list in
place.
Method #5: Using map() function and lambda expression
Initialize the original list test_list with the given dictionaries.
Print the original list.
Initialize the index K with the given value. Initialize the key with the given value.
Use the map() function to modify the original list in place.
The map() function takes two arguments: a function and an iterable. In this case, the function is a
lambda expression that modifies each sub-dictionary in the list. The iterable is the original list itself.
The lambda expression checks if the value of the key is a list. If it is, then it updates the value of the
key to be the Kth index value of the list. Otherwise, it does nothing.
The map() function returns an iterator that applies the lambda function to each element of the list.
However, since we don’t need the iterator, we discard it using the list() function.
Print the modified list.
Python3
# Using map() + lambda
# initializing list
{'gfg': 1, 'for': 10, 'geeks': 9},
{'love': 3, 'gfg': [7, 3, 9, 1]}]
# initializing K
K=2
# initializing Key
key = "gfg"
# using map() function to modify the original list in-place
list(map(lambda sub: sub.update({key: sub[key][K]}) if isinstance(
sub[key], list) else None, test_list))
# printing result
Output
Python – Replace String by Kth Dictionary value

manjeet_04
 Read
 Discuss
 Courses
 Practice
Given a list of Strings, replace the value mapped with the Kth value of mapped list.
Input : test_list = [“Gfg”, “is”, “Best”], subs_dict = {“Gfg” : [5, 6, 7], “is” : [7, 4, 2]}, K = 0
Output : [5, 7, “Best”]
Explanation : “Gfg” and “is” is replaced by 5, 7 as 0th index in dictionary value list.
Input : test_list = [“Gfg”, “is”, “Best”], subs_dict = {“Gfg” : [5, 6, 7], “Best” : [7, 4, 2]}, K = 0
Output : [5, “is”, 7]
Explanation : “Gfg” and “Best” is replaced by 5, 7 as 0th index in dictionary value list.
Method #1: Using list comprehension
This is one of the ways in which this task can be performed. In this, we perform the task iteration
and conditional replacement inside a one-liner in list comprehension.
Python3
# Replace String by Kth Dictionary value
# Using list comprehension
# initializing list
test_list = ["Gfg", "is", "Best"]
print("The original list : " + str(test_list))
# initializing subs. Dictionary
subs_dict = {
"Gfg" : [5, 6, 7],
"is" : [7, 4, 2],

}
# initializing K
K=2
# using list comprehension to solve
# problem using one liner
res = [ele if ele not in subs_dict else subs_dict[ele][K]
for ele in test_list]

# printing result
print("The list after substitution : " + str(res))
Output
The original list : ['Gfg', 'is', 'Best']
The list after substitution : [7, 2, 'Best']
Method #2 : Using get() + list comprehension
The combination of above functions can be used to solve this problem. In this, we iterate using list
comprehension and check for key existence and substitution using get().
Python3
# Using get() + list comprehension
# initializing list

subs_dict = {
"Gfg" : [5, 6, 7],
"is" : [7, 4, 2],
# initializing K
K=2
# using list comprehension to solve problem using one liner
# get() to perform presence checks and assign default value
res = [subs_dict.get(ele, ele) for ele in test_list]
res = [ele[K] if isinstance(ele, list) else ele for ele in res]

# printing result
Output
Method #3: Using a loop
Use a for loop to iterate through the list and check if the current element is present in the subs_dict.
If it is, then replace the current element with the Kth value from the dictionary.
Python3
# initializing list

subs_dict = {
"Gfg" : [5, 6, 7],
"is" : [7, 4, 2],
# initializing K
K=2
# using for loop to solve problem
for i in range(len(test_list)):
if test_list[i] in subs_dict:
test_list[i] = subs_dict[test_list[i]][K]
# printing result
print("The list after substitution : " + str(test_list))
Output
Method #4: Using map() function
Another way to replace the strings in a list with the k-th value from the dictionary is to use the map()
function, which takes a function and an iterable as arguments and applies the function to each
element of the iterable.
Here’s how you can use map() to solve this problem:

Define a function replace_string that takes a string s as input and returns either the value at the k-th
index of the dictionary if the string is a key in the dictionary, or the original string if it is not.
Use the map() function to apply replace_string to each element of the list test_list.
Convert the result of the map() function back to a list using the list() function.
Print the resulting list.
Python3
# Using map() function
# initializing list
subs_dict = {
"Gfg" : [5, 6, 7],
"is" : [7, 4, 2],
# initializing K
K=2
# define function to replace string
def replace_string(s):
return subs_dict[s][K] if s in subs_dict else s
# using map() function to solve problem

res = list(map(replace_string, test_list))
# printing result
Output
Time complexity: O(n), where n is the length of the input list test_list since we need to apply the
replace_string function to each element of the list.
Auxiliary space: O(n), since we create a new list res with the same length as test_list to store the
result.
Method #7: Using a dictionary comprehension
Use a dictionary comprehension to replace each string in test_list with its Kth element in subs_dict,

if the string is present as a key in the dictionary, otherwise, leave the string unchanged.
Store the resulting list in the variable res.
Print the updated list res.
Python3
# initializing list

subs_dict = {
"Gfg" : [5, 6, 7],
"is" : [7, 4, 2],
# initializing K
K=2
# using dictionary comprehension to solve problem
res = [subs_dict[x][K] if x in subs_dict else x for x in test_list]
# printing result
# Time complexity: O(n), where n is the length of the input list
# Auxiliary space: O(n), since we are creating a new list of the same length as the input list.
Output
Python – Replace index elements with elements in Other List

manjeet_04
 Read
 Discuss
 Courses
 Practice
Sometimes, while working with Python data, we can have a problem in which we have two lists and
we need to replace positions in one list with the actual elements from other list. Lets discuss certain
ways in which this task can be performed.
Method #1 : Using list comprehension This is one way to solve this problem. In this we just iterate
through the list and assign the index value from one list to other.
Python3
# Replace index elements with elements in Other List
# Initializing lists
test_list1 = ['Gfg', 'is', 'best']
test_list2 = [0, 1, 2, 1, 0, 0, 0, 2, 1, 1, 2, 0]
# printing original lists
print("The original list 1 is : " + str(test_list1))
res = [test_list1[idx] for idx in test_list2]

# printing result
print ("The lists after index elements replacements is : " + str(res))
Output :
The original list 1 is : [‘Gfg’, ‘is’, ‘best’] The original list 2 is : [0, 1, 2, 1, 0, 0, 0, 2, 1, 1, 2, 0] The lists
after index elements replacements is : [‘Gfg’, ‘is’, ‘best’, ‘is’, ‘Gfg’, ‘Gfg’, ‘Gfg’, ‘best’, ‘is’, ‘is’, ‘best’,
‘Gfg’]
Time Complexity: O(n*n) where n is the number of elements in the list “test_list”.
Auxiliary Space: O(n) where n is the number of elements in the list “test_list”.
Method #2 : Using map() + lambda The combination of above functions can be used to perform this
task. In this, we perform task of extension of logic to every element using map() and lambda
functions.
Python3
# using map() + lambda
test_list2 = [0, 1, 2, 1, 0, 0, 0, 2, 1, 1, 2, 0]
# using map() + lambda
res = list(map(lambda idx: test_list1[idx], test_list2))

# printing result
Output :
The original list 1 is : [‘Gfg’, ‘is’, ‘best’] The original list 2 is : [0, 1, 2, 1, 0, 0, 0, 2, 1, 1, 2, 0] The lists
after index elements replacements is : [‘Gfg’, ‘is’, ‘best’, ‘is’, ‘Gfg’, ‘Gfg’, ‘Gfg’, ‘best’, ‘is’, ‘is’, ‘best’,
‘Gfg’]
Time complexity: O(M^N) as the number of combinations generated is M choose N.

Auxiliary space: O(M^N) as the size of the resultant list is also M choose N.
# Method #3 : Using numpy.take()
We can also perform this task by using numpy module. In this, we just have to pass the both list to
numpy.take() and then assign the result to list.
Python3
# using numpy.take()

# import numpy
import numpy as np

test_list2 = [0, 1, 2, 1, 0, 0, 0, 2, 1, 1, 2, 0]


# using numpy.take()
res = np.take(test_list1, test_list2)

# printing result
Output :
The original list 1 is : [‘Gfg’, ‘is’, ‘best’]
The original list 2 is : [0, 1, 2, 1, 0, 0, 0, 2, 1, 1, 2, 0]
The lists after index elements replacements is : [‘Gfg’, ‘is’, ‘best’, ‘is’, ‘Gfg’, ‘Gfg’, ‘Gfg’, ‘best’, ‘is’, ‘is’,
‘best’, ‘Gfg’]
Time complexity: O(n)

Method #4: using a for loop and a dictionary
Python3
test_list2 = [0, 1, 2, 1, 0, 0, 0, 2, 1, 1, 2, 0]
# Create a dictionary to map indices to elements in test_list1
index_map = {index: element for index, element in enumerate(test_list1)}
# Replace index elements with elements in Other List using a for loop
res = [index_map[idx] for idx in test_list2]

# printing result
Output
The original list 1 is : ['Gfg', 'is', 'best']
The original list 2 is : [0, 1, 2, 1, 0, 0, 0, 2, 1, 1, 2, 0]
The lists after index elements replacements is : ['Gfg', 'is', 'best', 'is', 'Gfg', 'Gfg', 'Gfg', 'best', 'is', 'is',
'best', 'Gfg']
Method #5: Using pandas library
step-by-step algorithm for implementing the approach
Import the pandas module.
Define the two original lists.

Create a DataFrame object with one column containing the values from the first list.
Use the loc[] function of the DataFrame to extract the values from the first list corresponding to the
indices in the second list.
Convert the resulting series object to a list.
Assign the resulting list to a new variable.
Print the resulting list.
Python3
import pandas as pd
# Initializing the two lists
test_list2 = [0, 1, 2, 1, 0, 0, 0, 2, 1, 1, 2, 0]
# Creating a dataframe with one column ('a') containing the values from test_list1
df = pd.DataFrame({'a': test_list1})
# Extracting the values from test_list1 corresponding to the indices in test_list2
# by using the loc[] function of the dataframe and converting the result to a list
res = df.loc[test_list2, 'a'].tolist()
# Printing the resulting list
print("The lists after index elements replacements is : " + str(res))
output
The lists after index elements replacements is : ['Gfg', 'is', 'best', 'is', 'Gfg', 'Gfg', 'Gfg', 'best', 'is', 'is',
'best', 'Gfg']
Space complexity: O(n)
Method #5 : Using zip() function
Use the zip() function to combine test_list1 and test_list2 element-wise.

Loop through the resulting tuples obtained in step 1.
Append the corresponding element from test_list1 to a new list res.
Print the final result list res.
Python3
test_list2 = [0, 1, 2, 1, 0, 0, 0, 2, 1, 1, 2, 0]
# Using zip() function
res = [test_list1[i] for i in test_list2]
# printing result
Python – Combine two dictionaries having key of the first dictionary and value of the second
dictionary
manjeet_04
 Read
 Discuss
 Courses
 Practice
Given two dictionaries. The task is to merge them in such a way that the resulting dictionary contains
the key from the first dictionary and the value from the second dictionary.
Examples:
Input : test_dict1 = {"Gfg" : 20, "is" : 36, "best" : 100},
test_dict2 = {"Gfg2" : 26, "is2" : 20, "best2" : 70}
Output : {'Gfg': 26, 'is': 20, 'best': 70}
Explanation : Similar index keys' values assigned to dictionary 1.
Input : test_dict1 = {"Gfg" : 20, "best" : 100}, test_dict2 = {"Gfg2" : 26, "best2" : 70}
Output : {'Gfg': 26, 'best': 70}
Explanation : Similar index keys' values assigned to dictionary 1.
Method #1 : Using loop + keys()
This is one way in which this task can be performed. In this, we extract all the keys using keys() and
then assign required values inside loop.
Extract the keys from test_dict1 using the keys() method, and store them in a list called keys1.
Extract the values from test_dict2 using the values() method, and store them in a list called vals2.
Initialize an empty dictionary called res.
Loop through the range of the length of keys1.
For each iteration, assign the value of the idx-th element in keys1 as a key, and the value of the idx-
th element in vals2 as the value to the res dictionary.
Print the final mapped dictionary, res.
Python3
# Assign similar index values in Dictionary

# Using loop + keys()
test_dict1 = {"Gfg" : 20, "is" : 36, "best" : 100}
# extracting keys and values
keys1 = list(test_dict1.keys())
vals2 = list(test_dict2.values())
# assigning new values
res = dict()
for idx in range(len(keys1)):
res[keys1[idx]] = vals2[idx]

# printing result
print("Mapped dictionary : " + str(res))
Output
The original dictionary 1 is : {'Gfg': 20, 'is': 36, 'best': 100}
The original dictionary 2 is : {'Gfg2': 26, 'is2': 19, 'best2': 70}
Mapped dictionary : {'Gfg': 26, 'is': 19, 'best': 70}
Method #2 : Using zip() + values()
This is yet another way in which this task can be performed. In this, we perform the task of mapping
using zip(), extracting values using values().
Initialize two dictionaries test_dict1 and test_dict2.
Print the original dictionaries.
Use the zip() function to combine the keys of test_dict1 with the values of test_dict2 and create a
new dictionary.
Print the resulting dictionary.
Python3
# Using zip() + values()
# using zip() to perform required dict. mapping
res = dict(zip(test_dict1, test_dict2.values()))

# printing result
Output
Auxiliary space: O(n) (for the resultant dictionary)
Method #3: Using enumerate() and loop:

we loop through the keys of the first dictionary using enumerate(), which gives us an index and the
key itself on each iteration. We then check if the index is within the range of the second dictionary’s
values (to avoid an index out of range error), and if so, we assign the corresponding value from the
second dictionary to the new dictionary using the current key. Finally, we print the resulting
dictionary.
Python3
# assigning new values
res = dict()
for idx, key in enumerate(test_dict1.keys()):
if idx < len(test_dict2):
res[key] = list(test_dict2.values())[idx]
# printing result
Output
Auxiliary space: O(n)
Method #4: Using dictionary comprehension and zip()
Use a dictionary comprehension to create a new dictionary with the same keys as test_dict1 and the
values from test_dict2. We do this by using the zip() function to iterate over both dictionaries
simultaneously, extracting the keys from test_dict1 and the values from test_dict2. Finally, we use
dictionary comprehension to create the new dictionary res with the key-value pairs.
Python3
# using dictionary comprehension and zip to assign new values
res = {k: v2 for k, v2 in zip(test_dict1.keys(), test_dict2.values())}
# printing result
Output
Auxiliary space: O(n)
Method #5: Using dictionary comprehension and items()
Use dictionary comprehension along with the items() method to extract the key-value pairs from
both dictionaries simultaneously. The zip() function is used to pair up the corresponding key-value
pairs from both dictionaries. The resulting pairs are then used in the dictionary comprehension to
create a new dictionary with the keys from the first dictionary and values from the second
dictionary. This method has a time complexity of O(n), where n is the size of the dictionaries.
Approach:
Initialize a dictionary named “test_dict” with some key-value pairs.
Print the original dictionary using the “print()” function and string concatenation.
Initialize a variable “K” with the number of items to be returned from the dictionary.
Initialize an empty dictionary named “res”.
Use a for loop with “test_dict.items()” to iterate over the key-value pairs of the dictionary.
Check if the length of “res” is less than “K”. If so, add the key-value pair to the “res” dictionary using
the key as the index and the value as the value.
If the length of “res” is equal to or greater than “K”, break out of the loop.
Print the final dictionary named “res” limited to the first K items.
Python3
# Using dictionary comprehension and items()
# assigning new values using dictionary comprehension and items()
res = {k: v2 for (k, v1), (k2, v2) in zip(test_dict1.items(), test_dict2.items())}
# printing result

Snowflake Note

Uploaded by

Copyright:

Available Formats

Snowflake Note

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Snowflake Note

Uploaded by

Copyright:

Available Formats

Dictionary in Python

Example of Dictionary in Python

Dictionary holds key:value pair. Key-Value is provided in the dictionary to make it more optimized.

Dict = {1: 'Geeks', 2: 'For', 3: 'Geeks'}

{1: 'Geeks', 2: 'For', 3: 'Geeks'}

In Python, a dictionary can be created by placing a sequence of elements within curly {} braces,

# with Integer Keys

Dict = {1: 'Geeks', 2: 'For', 3: 'Geeks'}

print("\nDictionary with the use of Integer Keys: ")

# with Mixed keys

Dict = {'Name': 'Geeks', 1: [1, 2, 3, 4]}

print("\nDictionary with the use of Mixed Keys: ")

Dictionary with the use of Integer Keys:

{1: 'Geeks', 2: 'For', 3: 'Geeks'}

{'Name': 'Geeks', 1: [1, 2, 3, 4]}

# Creating an empty Dictionary

print("Empty Dictionary: ")

# with dict() method

Dict = dict({1: 'Geeks', 2: 'For', 3: 'Geeks'})

print("\nDictionary with the use of dict(): ")

# with each item as a Pair

Dict = dict([(1, 'Geeks'), (2, 'For')])

print("\nDictionary with each item as a pair: ")

Dictionary with the use of dict():

{1: 'Geeks', 2: 'For', 3: 'Geeks'}

Dictionary with each item as a pair:

{1: 'Geeks', 2: 'For'}

Complexities for Creating a Dictionary:

# Creating a Nested Dictionary

# as shown in the below image

Dict = {1: 'Geeks', 2: 'For',

3: {'A': 'Welcome', 'B': 'To', 'C': 'Geeks'}}

{1: 'Geeks', 2: 'For', 3: {'A': 'Welcome', 'B': 'To', 'C': 'Geeks'}}

Adding elements to a Dictionary

# Creating an empty Dictionary

print("Empty Dictionary: ")

# Adding elements one at a time

print("\nDictionary after adding 3 elements: ")

# Adding set of values

print("\nDictionary after adding 3 elements: ")

# Updating existing Key's Value

print("\nUpdated key value: ")

# Adding Nested Key value to Dictionary

Dict[5] = {'Nested': {'1': 'Life', '2': 'Geeks'}}

Dictionary after adding 3 elements:

{0: 'Geeks', 2: 'For', 3: 1}

Dictionary after adding 3 elements:

{0: 'Geeks', 2: 'For', 3: 1, 'Value_set': (2, 3, 4)}

Updated key value:

{0: 'Geeks', 2: 'Welcome', 3: 1, 'Value_set': (2, 3, 4)}

Adding a Nested Key:

{0: 'Geeks', 2: 'Welcome', 3: 1, 'Value_set': (2, 3, 4), 5:

{'Nested': {'1': 'Life', '2': 'Geeks'}}}

Complexities for Adding elements in a Dictionary:

Accessing elements of a Dictionary

# Python program to demonstrate

# accessing a element from a Dictionary

Dict = {1: 'Geeks', 'name': 'For', 3: 'Geeks'}