3

I have 2 dictionary which contain the same keys but the value pairs are different. Let's make dictA and dictB represent the two dictionaries in question.

dictA = {'key1':'Joe', 'key2':'Bob'}
dictB = {'key1':'Smith', 'key2':'Johnson'}

Currently, I am creating a new dictionary based the common occurring keys through a nested if statement. In doing so, the values that share a key are contained within a list, in the new dictionary. See this done below:

dictAB = {}  # Create a new dictionary

# Create a list container for dictionary values
for key in dictA.keys():
    dictAB[key] = []

# Iterate through keys in both dictionaries
# Find matching keys and append the respective values to the list container
for key, value in dictA.iteritems():
    for key2, value2 in dictB.iteritems():
        if key == key2:
            dictAB[key].append(value)
            dictAB[key].append(value2)
        else:
            pass

How can this be made into a more clean structure using python dictionary comprehension?

Wooble
  • 87,717
  • 12
  • 108
  • 131
Michael Markieta
  • 432
  • 4
  • 16

2 Answers2

8

Use sets or key views (python 2.7):

dictAB = {k: [dictA[k], dictB[k]] for k in dictA.viewkeys() & dictB.viewkeys()}

Before 2.7:

dictAB = dict((k, [dictA[k], dictB[k]]) for k in set(dictA) & set(dictB))

In python 3, you can use the .keys method for such operations directly, as they are implemented as views:

dictAB = {k: [dictA[k], dictB[k]] for k in dictA.keys() & dictB.keys()}

Demo (python 2.7):

>>> dictA = {'key1':'Joe', 'key2':'Bob'}
>>> dictB = {'key1':'Smith', 'key2':'Johnson'}
>>> dictAB = {k: [dictA[k], dictB[k]] for k in dictA.viewkeys() & dictB.viewkeys()}
>>> print dictAB
{'key2': ['Bob', 'Johnson'], 'key1': ['Joe', 'Smith']}

The & operator on either two sets or on a dict view creates the intersection of both sets; all keys that are present in both sets.

By using an intersection of the keys, this code will work even if either dictA or dictB has keys that do not appear in the other dictionary. If you are absolutely sure the keys will always match, you could just iterate over either dict directly without the intersection:

dictAB = {k: [dictA[k], dictB[k]] for k in dictA}
Martijn Pieters
  • 1,048,767
  • 296
  • 4,058
  • 3,343
  • 1
    Since `dictA` and `dictB` have the same keys anyway, it's not necessary to construct the intersection. A simple `for k in dictA` would do the trick. – Sven Marnach Jul 03 '12 at 15:04
  • 1
    To be defensive, I'd add a debugging assertion: `assert dictA.viewkeys() == dictB.viewkeys()`. This way, the speed of the production code is unaffected. – Sven Marnach Jul 03 '12 at 15:09
0
dictAB = { key: [dictA[key],dictB[key]] for key in dictA if key in dictB }
Marco de Wit
  • 2,686
  • 18
  • 22