 GeeksforGeeks App
Open App Browser
Continue

# Python | Sum list of dictionaries with same key

You have given a list of dictionaries, the task is to return a single dictionary with sum values with the same key. Let’s discuss different methods to do the task.

### Method #1: Using reduce() + operator

Step-by-step approach:

• Import necessary modules – collections, functools, and operator.
• Initialize a list of dictionaries called “ini_dict” that contains dictionaries with some key-value pairs.
• Print the initial list of dictionaries.
• Use the map() function to create a list of Counter objects from the “ini_dict” list. The Counter object is a subclass of dictionary and is used to count the occurrences of elements in a collection.
• Use the reduce() function from functools module to combine the Counter objects in the list into a single dictionary. The reduce() function takes two arguments: a function and an iterable, and returns a single value obtained by applying the function to the elements of the iterable in a cumulative way.
• Use the dict() function to convert the resulting tuple into a dictionary.
• Print the resultant dictionary.

Below is the implementation of the above approach:

## Python3

 `# Python code to demonstrate``# return the sum of values of dictionary``# with same keys in list of dictionary` `import` `collections, functools, operator` `# Initialising list of dictionary``ini_dict ``=` `[{``'a'``:``5``, ``'b'``:``10``, ``'c'``:``90``},``            ``{``'a'``:``45``, ``'b'``:``78``},``            ``{``'a'``:``90``, ``'c'``:``10``}]`  `# printing initial dictionary``print` `("initial dictionary", ``str``(ini_dict))` `# sum the values with same keys``result ``=` `dict``(functools.``reduce``(operator.add,``         ``map``(collections.Counter, ini_dict)))` `print``("resultant dictionary : ", ``str``(result))`

Output:

initial dictionary [{‘b’: 10, ‘a’: 5, ‘c’: 90}, {‘b’: 78, ‘a’: 45}, {‘a’: 90, ‘c’: 10}] resultant dictionary : {‘b’: 88, ‘a’: 140, ‘c’: 100}

Time Complexity: O(n)
Auxiliary Space: O(1)

### Method #2: Using counter

Step-by-step approach:

• Import the collections module.
• Initialize a list of dictionaries called ini_dict.
• Print the initial dictionary using the print() function and passing the string representation of ini_dict.
• Initialize a Counter object called counter.
• Use a for loop to iterate over each dictionary in ini_dict.
• Use the update() method of the Counter object to add the values of the current dictionary to the counter.
• Convert the counter to a dictionary using the dict() function and store the result in a new dictionary called result.
• Print the resulting dictionary using the print() function and passing the string representation of result.

Below is the implementation of the above approach:

## Python3

 `# Python code to demonstrate``# return the sum of values of dictionary``# with same keys in list of dictionary` `import` `collections` `# Initialising list of dictionary``ini_dict ``=` `[{``'a'``:``5``, ``'b'``:``10``, ``'c'``:``90``},``            ``{``'a'``:``45``, ``'b'``:``78``},``            ``{``'a'``:``90``, ``'c'``:``10``}]` `# printing initial dictionary``print` `("initial dictionary", ``str``(ini_dict))` `# sum the values with same keys``counter ``=` `collections.Counter()``for` `d ``in` `ini_dict:``    ``counter.update(d)``    ` `result ``=` `dict``(counter)`  `print``("resultant dictionary : ", ``str``(counter))`

Output:

initial dictionary [{‘c’: 90, ‘a’: 5, ‘b’: 10}, {‘a’: 45, ‘b’: 78}, {‘a’: 90, ‘c’: 10}] resultant dictionary : Counter({‘a’: 140, ‘c’: 100, ‘b’: 88})

Time complexity: O(n*m), where n is the length of the list and m is the average number of keys in each dictionary.
Auxiliary space: O(k), where k is the number of unique keys in all dictionaries combined.

## Python3

 `# Python code to demonstrate``# return the sum of values of dictionary``# with same keys in list of dictionary` `from` `operator ``import` `itemgetter` `# Initialising list of dictionary``ini_dict ``=` `[{``'a'``:``5``, ``'b'``:``10``, ``'c'``:``90``},``            ``{``'a'``:``45``, ``'b'``:``78``},``            ``{``'a'``:``90``, ``'c'``:``10``}]` `# printing initial dictionary``print` `("initial dictionary", ``str``(ini_dict))` `# sum the values with same keys``result ``=` `{}``for` `d ``in` `ini_dict:``    ``for` `k ``in` `d.keys():``        ``result[k] ``=` `result.get(k, ``0``) ``+` `d[k]`  `print``("resultant dictionary : ", ``str``(result))`

Output:

initial dictionary [{‘b’: 10, ‘c’: 90, ‘a’: 5}, {‘b’: 78, ‘a’: 45}, {‘c’: 10, ‘a’: 90}] resultant dictionary : {‘b’: 88, ‘c’: 100, ‘a’: 140}

Time complexity: O(n*m).
Auxiliary space: O(k).

### Method 4: Using a dictionary comprehension

Another approach to sum the values of dictionaries with the same key in a list of dictionaries is to use dictionary comprehension. This method is concise and can be easier to read than the other methods, depending on your personal preferences. Here’s an example of how you can use dictionary comprehension to achieve the same result as the other methods:

## Python3

 `ini_dict ``=` `[{``'a'``:``5``, ``'b'``:``10``, ``'c'``:``90``},``            ``{``'a'``:``45``, ``'b'``:``78``},``            ``{``'a'``:``90``, ``'c'``:``10``}]` `# Create a dictionary with keys and values obtained by iterating over the keys in the dictionaries``# and summing the values for each key.``result ``=` `{k: ``sum``(d[k] ``for` `d ``in` `ini_dict ``if` `k ``in` `d) ``for` `k ``in` `set``(k ``for` `d ``in` `ini_dict ``for` `k ``in` `d)}` `print``(result)  ``# Output: {'b': 88, 'a': 140, 'c': 100}``#This code is contributed by Edula Vinay Kumar Reddy`

Output

`{'a': 140, 'c': 100, 'b': 88}`

Time complexity: O(n * m), where n is the number of dictionaries in the list and m is the average number of keys in each dictionary. This is because dictionary comprehension iterates over all the keys in all the dictionaries and sums the values for each key.
Auxiliary space: O(n * m), because the resulting dictionary will have at most n * m key-value pairs.

### Method #5 Using defaultdict

This method uses defaultdict to create a dictionary where the default value for any key is set to 0. This allows us to easily add up the values for each key as we iterate over the list of dictionaries.

## Python3

 `from` `collections ``import` `defaultdict` `# Initialising list of dictionary``ini_dict ``=` `[{``'a'``:``5``, ``'b'``:``10``, ``'c'``:``90``},``            ``{``'a'``:``45``, ``'b'``:``78``},``            ``{``'a'``:``90``, ``'c'``:``10``}]` `# sum the values with same keys``result ``=` `defaultdict(``int``)``for` `d ``in` `ini_dict:``    ``for` `k, v ``in` `d.items():``        ``result[k] ``+``=` `v` `print``(``"resultant dictionary : "``, ``dict``(result))`

Output

`resultant dictionary :  {'a': 140, 'b': 88, 'c': 100}`

Time Complexity: O(n*k), where n is the number of dictionaries in the list and k is the maximum number of keys in any dictionary. This is because we iterate over each dictionary in the list, and for each dictionary, we iterate over its keys and add its values to the corresponding key in the result dictionary.
Auxiliary Space: O(k), where k is the maximum number of keys in any dictionary. This is because we create a result dictionary with a default value of 0 for each key in the dictionary

### Method 6: Using defaultdict from the collections module.

Approach:

1. Import the defaultdict module from collections.
2. Initialize a defaultdict object with the int() function as the default_factory argument. This means that when a new key is encountered, the defaultdict will automatically create a new entry with a value of 0.
3. Loop through each dictionary in the list of dictionaries.
4. Loop through each key-value pair in the dictionary.
5. Use the key to access the corresponding value in the defaultdict and add the value from the current dictionary to it.
6. Return the resulting dictionary.

## Python3

 `from` `collections ``import` `defaultdict` `# Initialising list of dictionary``ini_dict ``=` `[{``'a'``:``5``, ``'b'``:``10``, ``'c'``:``90``},``            ``{``'a'``:``45``, ``'b'``:``78``},``            ``{``'a'``:``90``, ``'c'``:``10``}]` `# printing initial dictionary``print``(``"initial dictionary"``, ``str``(ini_dict))` `# sum the values with same keys using defaultdict``result ``=` `defaultdict(``int``)``for` `d ``in` `ini_dict:``    ``for` `k, v ``in` `d.items():``        ``result[k] ``+``=` `v` `print``(``"resultant dictionary : "``, ``dict``(result))`

Output

```initial dictionary [{'a': 5, 'b': 10, 'c': 90}, {'a': 45, 'b': 78}, {'a': 90, 'c': 10}]
resultant dictionary :  {'a': 140, 'b': 88, 'c': 100}```

Time complexity: O(n*m) where n is the number of dictionaries in the list and m is the average number of key-value pairs in each dictionary.
Auxiliary space: O(m) where m is the number of unique keys across all dictionaries in the list.

My Personal Notes arrow_drop_up