Is there any pythonic way to combine two dicts (adding values for keys that appear in both)?

Using collections.Counter for Dict Summation

Python's collections.Counter object simplifies ours task of adding dictionary values. It handles non-existing keys gracefully and supports addition, so less code to write:

from collections import Counter

dict1 = Counter({'a': 1, 'b': 2})
dict2 = Counter({'b': 3, 'c': 4})
combined = dict1 + dict2


Notice the combined now is a Counter: Counter({'b': 5, 'a': 1, 'c': 4}).

Merging Dictionaries: Advanced Techniques

Custom Dictionary Class

We can create a CustomDict class that inherits from dict, granting better control over the merge behavior:

class CustomDict(dict):
    def __add__(self, other):
        result = CustomDict()
        for key in self.keys() | other.keys():
            result[key] = self.get(key, 0) + other.get(key, 0)
        return result

dict1 = CustomDict({'a': 1, 'b': 2})
dict2 = CustomDict({'b': 3, 'c': 4})
combined = dict1 + dict2  # You now control the '+' operator.


Working with Complex Types

What if your dictionary values were more complex types? What if you had a dictionary within a dictionary or a list of dictionaries (Inception, anyone?)? You'll need a deep merge strategy which can be implemented recursively or with libraries like deepmerge.

Large Datasets? No problem.

When dealing with large datasets, there are unique considerations such as computation time and memory usage. Techniques like generator expressions, itertools, and parallel processing might be your new best friends here. Like when you realize guacamole is extra, but you're okay with that.

Mastering the Art of Set Operations

Identifying Common Keys (Intersection)

You can use set intersection to identify shared keys, then apply specific operations:

common_keys = dict1.keys() & dict2.keys()  # "&" is like the cool neighborhood where common keys hang out.
common_values_sum = {k: dict1[k] + dict2[k] for k in common_keys}


Unmasking the Unique Keys (Difference)

On the other hand, the set difference operation helps you reveal keys unique to each dictionary:

unique_to_dict1 = dict1.keys() - dict2.keys()  # Dict1's secret stash
unique_to_dict2 = dict2.keys() - dict1.keys()  # Dict2's VIP list


Combining Non-Integer Counts

Albeit Counter is aimed for integer counts, what if you need to combine non-integer values? In such cases, you'll need a custom solution. You want to make sure this operation is applicable to your data types. Kind of like when you try to add chicken to a vegetarian recipe, it's a big nono.

Fault Tolerance with try-except

Remember to include try-except logic in your code for graceful error handling:

try:
    combined[k] = dict1[k] + dict2[k]
except TypeError:
    print(f"Sorry, can't add values of key {k}. They must be going through an identity crisis.")


Counter's update() Trick

The Counter.update() method is perfect for adding counts, it even modifies the Counter in-place. It's kind of like that friend who crashes your place and doesn't leave (but in a good way).

counter = Counter(dict1)
counter.update(dict2)  # At this point, 'counter' has moved on. It's now also seeing 'dict2'.
