5 Best Ways to Find Common Elements in Two Python Dicts

💡 Problem Formulation: When working with dictionaries in Python, a common task is to identify which key-value pairs are shared between two different dictionaries. This can come up, for example, when comparing configurations, feature sets, or paired datasets. Ideally, you want to generate a new dictionary or a set containing only the elements that are present in both input dictionaries. For instance, if given two dictionaries {'a': 1, 'b': 2} and {'b': 2, 'c': 3}, the desired output would be {'b': 2}.

Method 1: Using Dictionary Comprehension

Dictionary comprehension in Python provides an elegant and Pythonic way to create new dictionaries. This method utilizes a comprehension to iterate over the items of one dictionary and include them in the new dictionary only if they are present in both dictionaries. It’s concise and quite performant for smaller dictionaries.

Here’s an example:

d1 = {'apple': 1, 'banana': 2, 'cherry': 3}
d2 = {'banana': 2, 'dragonfruit': 4, 'elderberry': 5}
common_elements = {k: d1[k] for k in d1 if k in d2 and d1[k] == d2[k]}

print(common_elements)

Output:

{'banana': 2}

This code snippet illustrates how dictionary comprehension can efficiently identify and construct a dictionary of common elements. By iterating through the first dictionary’s keys and including only those which also exist in the second dictionary with the same value, it ensures that only pairs present in both dictionaries are included.

Method 2: Using the keys() Method and Set Intersection

The keys() method returns a view of the dictionary’s keys, which can be converted to a set. Set intersection is a standard operation that yields elements common to all sets. In this method, we use set operations to find common keys and then build a dictionary of these keys with their values.

Here’s an example:

d1 = {'apple': 1, 'banana': 2, 'cherry': 3}
d2 = {'banana': 2, 'dragonfruit': 4, 'elderberry': 5}
common_keys = set(d1.keys()) & set(d2.keys())
common_elements = {k: d1[k] for k in common_keys if d1[k] == d2[k]}

print(common_elements)

Output:

{'banana': 2}

This snippet creates sets from the keys of each dictionary and then identifies the intersection of these two sets, which is the set of keys that are present in both dictionaries. A new dictionary is then created by dictionary comprehension, checking if the values for these common keys are equal in both original dictionaries.

Method 3: Using a Loop and the get() Method

For those who prefer a classic approach, this method involves looping through each item in one dictionary and checking for its presence in the other using the get() method. This method is straightforward and easy for those new to Python to understand but may not be as efficient for dictionaries with a large number of items.

Here’s an example:

d1 = {'apple': 1, 'banana': 2, 'cherry': 3}
d2 = {'banana': 2, 'dragonfruit': 4, 'elderberry': 5}
common_elements = {}

for k, v in d1.items():
    if d2.get(k) == v:
        common_elements[k] = v

print(common_elements)

Output:

{'banana': 2}

In the provided code, we iterate through the key-value pairs in the first dictionary. We use get() on the second dictionary, which returns the value associated with the key if it exists, or None otherwise. If the value matches the value from the first dictionary, we add the pair to the result dictionary common_elements.

Method 4: Using the items() Method and Set Intersection

Similarly to Method 2, this approach takes advantage of Python’s set operations but operates on the key-value pairs directly. The items() method provides a view of the dictionary’s items (key-value pairs) that can be turned into a set. As with keys, intersection finds items common to both.

Here’s an example:

d1 = {'apple': 1, 'banana': 2, 'cherry': 3}
d2 = {'banana': 2, 'dragonfruit': 4, 'elderberry': 5}
common_elements = dict(set(d1.items()) & set(d2.items()))

print(common_elements)

Output:

{'banana': 2}

This snippet leverages set operations on items (key-value pairs) to identify the intersection directly, rather than just the keys. The result of the intersection is a set of tuples, which is then converted back to a dictionary using the dict() constructor. This method is efficient and highly readable but assumes that the values are hashable.

Bonus One-Liner Method 5: Using Dictionary Comprehension with items() and in

This one-liner combines the brevity of a dictionary comprehension with the items() method to provide a concise solution. By using an if condition within the comprehension, this method quickly creates a dictionary of the common elements.

Here’s an example:

d1 = {'apple': 1, 'banana': 2, 'cherry': 3}
d2 = {'banana': 2, 'dragonfruit': 4, 'elderberry': 5}
common_elements = {k: v for k, v in d1.items() if k in d2 and d1[k] == d2[k]}

print(common_elements)

Output:

{'banana': 2}

This compact line of code performs an iteration over the items() of the first dictionary and includes an element in the new dictionary only if the key is present in the second dictionary with the same value. It’s a neat mix of readability and efficiency that works well for most use cases.

Summary/Discussion

• Method 1: Dictionary Comprehension. Efficient and Pythonic. Best for small to medium-sized dictionaries. However, it can be less readable for complex conditions.
• Method 2: keys() Method and Set Intersection. Leverages set logic. Works well with non-hashable values. It can be slightly less performant with very large dictionaries.
• Method 3: Loop and get() Method. Easy to understand for beginners. Can be slower for large dictionaries due to explicit looping.
• Method 4: items() Method and Set Intersection. Direct and efficient. Best when both keys and values are hashable. Not suitable for non-hashable values.
• Bonus Method 5: One-Liner with items(). Concise and efficient. Balances readability and performance but assumes hashable values.