使用dicts进行动态编程-Python

Question

I have a list of dict s; I get the indices and get the combination of indices using itertools.combinations .

list_of_dict = [{1: 'a', 2:'b', 3: 'c', 4: 'd'}, 
                {1: 'b', 2:'b', 3: 'a', 4: 'd'},
                {1: 'a', 2:'c', 3: 'd', 4: 'd'},
                {1: 'c', 2:'a', 3: 'd', 4: 'b'}]
indices = [0, 1, 2, 3]
combinations = [(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3), 
                (0, 1, 2), (0, 1, 3), (0, 2, 3), (1, 2, 3), 
                (0, 1, 2, 3)]

Now I define a merge function that takes 2 dict s implements my logic of merge and returns a single dict . I perform merge on all elements of combinations .

The calls to merge happen as follows:

candidates = {}
for p in combinations:
    n = 1
    temp_p = None
    c = None
    while (n < (len(p) - 2)):
        c = tuple(list(p)[0:-n]) 
        if c in candidates:
            temp_p = candidates[c]
            break
        else: 
            n += 1
    if temp_p:
        p1 = temp_p
        p2 = p[len(c)]
        candidate[p] = merge(list_of_dict[p1], list_of_dict[p2])
    else:
        candidates[p] = merge(list_of_dict[p[0]], list_of_dict[p[1]])

Logic: As we can see, I can reuse the output of merge(0, 1) when I calculate merge(0, 1, 2) ; ie merge(0, 1, 2) = merge( merge(0,1), 2) . Similarly for merge(0, 1, 2, 3) I can reuse merge(0, 1, 2) .

Questions:

1. I am not completely sure if the above chunk of code does exactly what is described in "Logic".
2. Is there an elegant and efficient way to do the above?

Edit: Merge function does the following. If d1[k] == d2[k] it adds d1[k] to the new dict to be returned else adds None. So from the example given:

merge(0,1) should return : {1: None, 2: 'b', 3: None, 4: 'd'}

and

merge(0, 1, 2) becomes merge merge({1: None, 2: 'b', 3: None, 4: 'd'}, {1: 'a', 2:'c', 3: 'd', 4: 'd'}) and should return {1: None, 2: None, 3: None, 4: 'd'}

This process continues till all combination of dicts are merged.

The question is especially important when we don't know the initial number of such dictionaries presented to the algorithm.

Answer 1

This code will fit all your requirements:

from collections import defaultdict

def merge(d1, d2, *dicts):
    new_dict = defaultdict()
    new_dict.update(d1.copy())

    for key, value in d2.items():
        if value != new_dict[key]:
            new_dict[key] = None

    if dicts:
        new_dict = merge(new_dict, *dicts)

    return new_dict


for comb in combinations:
    print(merge(*map(list_of_dict.__getitem__, comb)))

First of all, I left passing dictionaries to merge , because dict is mutable object, so in this case only its reference in memory is passed to function. You can easily check it with id function. So, since this solution is more readable than gathering dictionaries from list by indexes - it's more pythonic.

Secondary, I used copy of first dictionary passed to merge , so original one is left unmodified for other combinations.

Also as you can see, instead of dict I used defaultdict from collections package, so if your d1 and d2 have different keys - you can skip checking if key exist in new_dict .

And last one: map(list_of_dict.__getitem__, comb) - this will return generator object ( for python 3.x ) with items from list_of_dict , which indexes in comb . Wildcard before ( * ) map means unpack as arguments , so, without actually creating new list or tuple ( and unpack it afterwards ) - it just yields items ( in our case references to dictionaries in list ) as merge arguments.

Thats it.

Provided code will print this:

defaultdict(None, {1: None, 2: 'b', 3: None, 4: 'd'})
defaultdict(None, {1: 'a', 2: None, 3: None, 4: 'd'})
defaultdict(None, {1: None, 2: None, 3: None, 4: None})
defaultdict(None, {1: None, 2: None, 3: None, 4: 'd'})
defaultdict(None, {1: None, 2: None, 3: None, 4: None})
defaultdict(None, {1: None, 2: None, 3: 'd', 4: None})
defaultdict(None, {1: None, 2: None, 3: None, 4: 'd'})
defaultdict(None, {1: None, 2: None, 3: None, 4: None})
defaultdict(None, {1: None, 2: None, 3: None, 4: None})
defaultdict(None, {1: None, 2: None, 3: None, 4: None})
defaultdict(None, {1: None, 2: None, 3: None, 4: None})

Also, i've tested this code on list of 20 dictionaries ( each dictionary len = 10000 ) and i've got next timings:

1. generating list of dicts: 15.96887145599976
2. apply merge to each indexes combination ( 1012 in total ): 15.630234674000349