Python - How to calculate equal parts of two dictionaries?

Question

I have a problem with combining or calculating common/equal part of these two dictionaries. In my dictionaries, values are lists:

d1 = {0:['11','18','25','38'], 
      1:['11','18','25','38'], 
      2:['11','18','25','38'], 
      3:['11','18','25','38']}

d2 = {0:['05','08','11','13','16','25','34','38','40', '43'], 
      1:['05', '08', '09','13','15','20','32','36','38', '40','41'], 
      2:['02', '08', '11', '13', '18', '20', '22','33','36','39'], 
      3:['06', '11', '12', '25', '26', '27', '28', '30', '31', '37']}

I'd like to check "d2" and know if there are numbers from "d1". If there are some, I'd like to update one of them with new data or receive 3rd dictionary "d3" with only the values that are identical/equal in both "d1" and "d2" like:

d3 = {0:['11','25','38'], 1:['38'], 2:['11','18'], 3:['11','25']}

Can anyone help me with this?

My fault I forgot to be more specific. I'm looking for a solution in Python.

Answer 1

in pseudocode:

Dictionary d3 = new Dictionary()
for (i = 0 to min(d1.size(), d2.size()))
{
  element shared = getSharedElements(d1[i], d2[i]);
  d3.store(i, shared);
}

function getsharedElements(array e1, array e2)
{
  element e3 = new element();
  for (int i = 0 to e1.length)
  {
    if (e2.contains(e1[i]))
    {
      e3.add[e1[i]];
    }
  }
  return e3;
}

Answer 2

Assuming this is Python, you want:

dict((x, set(y) & set(d1.get(x, ()))) for (x, y) in d2.iteritems())

to generate the resulting dictionary "d3".

Python 3.0+ version

>>> d3 = {k: list(set(d1.get(k,[])).intersection(v)) for k, v in d2.items()}
{0: ['11', '25', '38'], 1: ['38'], 2: ['11', '18'], 3: ['11', '25']}

The above version (as well as Python 2.x version) allows empty intersections therefore additional filtering is required in general case:

>>> d3 = {k: v for k, v in d3.items() if v}

Combining the above in one pass:

d3 = {}
for k, v in d2.items():
    # find common elements for d1 & d2
    v3 = set(d1.get(k,[])).intersection(v)
    if v3: # whether there are common elements
       d3[k] = list(v3)

---

[Edit: I made this post community wiki so that people can improve it if desired. I concede it might be a little hard to read if you're not used to reading this sort of thing in Python.]

Answer 3

The problem boils down to determining the common elements between the two entries. (To obtain the result for all entries, just enclose the code in a loop over all of them.) Furthermore, it looks like each entry is a set (i.e. it has not duplicate elements). Therefore, all you need to do is find the set intersection between these elements. Many languages offer a method or function for doing this; for instance in C++ use the set container and the set_intersection function. This is a lot more efficient than comparing each element in one set against the other, as others have proposed.

Answer 4

If we can assume d1 and d2 have the same keys:

d3 = {}
for k in d1.keys():
    intersection = set(d1[k]) & set(d2[k])
    d3[k] = [x for x in intersection]

Otherwise, if we can't assume that, then it is a little messier:

d3 = {}
for k in set(d1.keys() + d2.keys()):
    intersection = set(d1.get(k, [])) & set(d2.get(k, []))
    d3[k] = [x for x in intersection]

Edit: New version taking the comments into account. This one only checks for keys that d1 and d2 have in common, which is what the poster seems to be asking.

d3 = {}
for k in set(d1.keys()) & set(d2.keys()):
    intersection = set(d1[k]) & set(d2[k])
    d3[k] = list(intersection)

Answer 5

Offering a more readable solution:

d3= {}
for common_key in set(d1) & set(d2):
    common_values= set(d1[common_key]) & set(d2[common_key])
    d3[common_key]= list(common_values)

EDIT after suggestion:

If you want only keys having at least one common value item:

d3= {}
for common_key in set(d1) & set(d2):
    common_values= set(d1[common_key]) & set(d2[common_key])
    if common_values:
        d3[common_key]= list(common_values)

You could keep the d1 and d2 values as sets instead of lists, if order and duplicates are not important.