Open In App

# Python | Equal Keys List Summation

Sometimes, while working with dictionaries, we can have a problem in which we have many dictionaries and we are required to sum like keys. This problem seems common, but complex is if the values of keys are list and we need to add elements to list of like keys. Letâ€™s discuss way in which this problem can be solved.

Method : Using list comprehension + items() + sum() This problem can be solved using list comprehension and sum() that can be used to sum the list content and also the items method which can be employed to get the dictionary keys and values.

## Python3

 `# Python3 code to demonstrate working of``# Equal Keys List Summation``# Using items() + list comprehension + sum()` `# initializing dictionaries``test_dict1 ``=` `{``'Gfg'` `: [``1``, ``2``, ``3``], ``'for'` `: [``2``, ``4``], ``'CS'` `: [``7``, ``8``]}``test_dict2 ``=` `{``'Gfg'` `: [``10``, ``11``], ``'for'` `: [``5``], ``'CS'` `: [``0``, ``18``]}` `# printing original dictionaries``print``("The original dictionary ``1` `is` `: " ``+` `str``(test_dict1))``print``("The original dictionary ``2` `is` `: " ``+` `str``(test_dict2))` `# Using items() + list comprehension + sum()``# Equal Keys List Summation``res ``=` `{key: ``sum``(value) ``+` `sum``(test_dict2[key]) ``for` `key, value ``in` `test_dict1.items()}` `# printing result``print``("The summation of dictionary values ``is` `: " ``+` `str``(res))`

Output :

```The original dictionary 1 is : {'CS': [7, 8], 'for': [2, 4], 'Gfg': [1, 2, 3]}
The original dictionary 2 is : {'CS': [0, 18], 'for': [5], 'Gfg': [10, 11]}
The summation of dictionary values is : {'CS': 33, 'for': 11, 'Gfg': 27}```

Time Complexity: O(n*n), where n is the length of the list test_dict
Auxiliary Space: O(n) additional space of size n is created where n is the number of elements in the res list

#### Method#2 : Using for loop

In this method, we first loop through the keys of the first dictionary, and for each key, we check if it exists in the second dictionary. If it does, we sum the values of the two lists using the + operator and store the result in the result_dict. If the key is not present in the second dictionary, we simply sum the values of the list from the first dictionary and store the result in the result_dict. Finally, we loop through the keys of the second dictionary, and for each key that is not already present in the result_dict, we sum the values of the list from the second dictionary and store the result in the result_dict

## Python3

 `dict1 ``=` `{``'CS'``: [``7``, ``8``], ``'for'``: [``2``, ``4``], ``'Gfg'``: [``1``, ``2``, ``3``]}``#dictionary input 1``dict2 ``=` `{``'CS'``: [``0``, ``18``], ``'for'``: [``5``], ``'Gfg'``: [``10``, ``11``]}``#dictionary input 2` `result_dict ``=` `{}``#take empty dictionary` `for` `key ``in` `dict1.keys():``#using loop to get keys from dict1``    ``if` `key ``in` `dict2:``        ``result_dict[key] ``=` `sum``(dict1[key] ``+` `dict2[key])``#summation of keys``    ``else``:``        ``result_dict[key] ``=` `sum``(dict1[key])` `for` `key ``in` `dict2.keys():``#using loop to get keys from dict2``    ``if` `key ``not` `in` `result_dict:``#summation of keys``        ``result_dict[key] ``=` `sum``(dict2[key])` `print``(``"The summation of dictionary values is :"``, result_dict)``#print result`

Output

`The summation of dictionary values is : {'CS': 33, 'for': 11, 'Gfg': 27}`

Time complexity: O(n)
Auxiliary Space: O(n)

Method#3 : Using itertools.chain() and itertools.groupby():

Algorithm:

1. Import the necessary modules, itertools.
2.Define two dictionaries.
3.Create an empty dictionary.
4.Merge the keys of both the dictionaries using chain() function and group them using groupby() function.
5.Find the sum of values of common keys in both the dictionaries, using get() function.
6.Store the result in a new dictionary.
7.Print the new dictionary.

## Python3

 `from` `itertools ``import` `chain, groupby` `dict1 ``=` `{``'CS'``: [``7``, ``8``], ``'for'``: [``2``, ``4``], ``'Gfg'``: [``1``, ``2``, ``3``]}``dict2 ``=` `{``'CS'``: [``0``, ``18``], ``'for'``: [``5``], ``'Gfg'``: [``10``, ``11``]}``# printing original dictionaries``print``(``"The original dictionary 1 is : "` `+` `str``(dict1))``print``(``"The original dictionary 2 is : "` `+` `str``(dict2))`` `  `merged_dict ``=` `{}``for` `key, group ``in` `groupby(``sorted``(chain(dict1.keys(), dict2.keys()))):``    ``merged_dict[key] ``=` `sum``(chain(dict1.get(key, []), dict2.get(key, [])))` `print``(``"The summation of dictionary values is :"``, merged_dict)``#This code is contributed by Jyothi pinjala.`

Output

```The original dictionary 1 is : {'CS': [7, 8], 'for': [2, 4], 'Gfg': [1, 2, 3]}
The original dictionary 2 is : {'CS': [0, 18], 'for': [5], 'Gfg': [10, 11]}
The summation of dictionary values is : {'CS': 33, 'Gfg': 27, 'for': 11}```

Time Complexity: O(NlogN)

The use of sorted() function makes the time complexity O(NlogN).
The iteration over the merged keys has a time complexity of O(N), as does the iteration over the values of the dictionaries.
The sum() function has a time complexity of O(N).
Space Complexity: O(N)

We are using extra space for the merged dictionary which has the same number of elements as the input dictionaries. Therefore, the space complexity is O(N).