python中的三向字典深度合并

Question

我想合并两个字典A和B，知道这两个字典以前的共同状态C。我需要合并也发生在子字典。如果是真正的冲突，我需要提出一个例外。在

1-在下面的示例中，merge方法应该理解A和B编辑了不同的项，因此merge不应该引发冲突

C = {"x": 0, "y": 0}
A = {"x": 1, "y": 0} # Edit x, but not y
B = {"x": 0, "y": 1} # Edit y, but not x
# merge(A, B, C) => {"x": 1, "y": 1}

2-该功能需要能够处理新项目和已删除项目

^{pr2}$

3-当实际冲突发生时，函数应引发异常

C = {"x": 0}
A = {"x": 1}         # Edit x 
B = {"x": 2}         # Also edit x
# merge(A, B, C) => raise Exception

C = {"x": 0}
A = {"x": 1}         # Edit x 
B = {}               # Delete x
# merge(A, B, C) => raise Exception

4-函数应该递归地工作

C = {"deeper": {"x": 0, "y": 0}}
A = {"deeper": {"x": 1, "y": 0}} # Edit deeper["x"], but not deeper["y"]
B = {"deeper": {"x": 0, "y": 1}} # Edit deeper["y"], but not deeper["x"]
# merge(A, B, C) => {"deeper": {"x": 1, "y": 1}}

实现这种合并功能的最佳方法是什么？在

Answer 1

尝试一个递归检查用例的函数，如果没有一个满足，则会失败（引发valueerror）。在

我相信这能满足你的要求

def three_way_merge(Origin, Dict_A, Dict_B):
    newdict = dict()
    for key, value in Origin.items():
        if isinstance(value, dict):  # handle recursion
            newdict[key] = three_way_merge(Origin[key], Dict_A[key], Dict_B[key])
        elif key not in Dict_A.keys() and Dict_B[key] == value:
            pass
        elif key not in Dict_B.keys() and Dict_A[key] == value:
            pass
        elif Dict_A[key] == value and Dict_B[key] == value:
             newdict[key] = value
        elif Dict_A[key] == value and Dict_B[key] != value:
             newdict[key] = Dict_B[key]
        elif Dict_A[key] != value and Dict_B[key] == value:
             newdict[key] = Dict_A[key]
        elif Dict_A[key] == Dict_B[key]:
             newdict[key] = Dict_A[key]
        else: # check for a conflict with this key
            raise ValueError('conflict occured with {} \n {} and {} both changed'.format(key, Dict_A[key], Dict_B[key]))
    newdict.update(add_missing_keys(Dict_A, Origin, Dict_B))
    newdict.update(add_missing_keys(Dict_B, Origin, Dict_A))
    return newdict    

def add_missing_keys (Dict_A, Origin, Dict_B):
    newdict = dict()
    for key, value in Dict_A.items():
        if key not in Origin.keys():
            if key not in Dict_B.keys() or Dict_B[key] == value:
                newdict[key] = value
            else:
                raise ValueError('conflict occured with {} \n {} and {} both changed'.format(key, Dict_A[key], Dict_B[key]))
    return newdict

print(three_way_merge({'x':0, 'y':0}, {'x':1, 'y':0}, {'x':0, 'y':2}))     # returns {'x':1, 'y':2}
print(three_way_merge({'x':0}, {'x':0, 'y':0}, {}))    # returns {'y':0}
print(three_way_merge({'x':0}, {'x':1}, {'x':1}))    # returns {'x':1}
print(three_way_merge({"deeper": {"x": 0, "y": 0}},{"deeper": {"x": 1, "y": 0}},{"deeper": {"x": 0, "y": 2}})) # returns {'deeper': {'x': 1, 'y': 2}}
print(three_way_merge({'x':0}, {'x':1}, {'x':2})) # raises valueerror
print(three_way_merge({'x':0}, {'x':1}, {}))  # raises keyerror

Answer 2

您可以将所有dict项转换为集合，使用从对称差异到C的键的交集来查找冲突，并使用3个集合的交集（公共项）和差分到C的并集来获得合并。递归地合并A、B和C共有的子字典，将子字典转换为项对的元组，使它们能够散列并转换为集合，然后在合并后将它们转换回dict。在

编辑：如果dict值是不易损坏的对象（如set），则必须先序列化这些值（我建议使用pickle作为序列化程序，因为它有Python的本机支持），然后才能将dict项转换为集合，并在合并后反序列化它们：

import pickle

def merge(a, b, c):
    # recursively merge sub-dicts that are common to a, b and c
    for k in a.keys() & b.keys() & c.keys():
        if all(isinstance(d.get(k), dict) for d in (a, b, c)):
            a[k] = b[k] = c[k] = merge(a[k], b[k], c[k])
    # convert sub-dicts into tuples of item pairs to allow them to be hashable
    for d in a, b, c:
        for k, v in d.items():
            if isinstance(v, dict):
                d[k] = tuple(v.items())
    # convert all the dict items into sets
    set_a, set_b, set_c = (set((k, pickle.dumps(v)) for k, v in d.items()) for d in (a, b, c))
    # intersect keys from the symmetric set differences to c to find conflicts
    for k in set(k for k, _ in set_a ^ set_c) & set(k for k, _ in set_b ^ set_c):
        # it isn't really a conflict if the new values of a and b are the same
        if a.get(k) != b.get(k) or (k in a) ^ (k in b):
            raise ValueError("Conflict found in key %s" % k)
    # merge the dicts by union'ing the differences to c with the common items
    d = dict(set_a & set_b & set_c | set_a - set_c | set_b - set_c)
    # convert the tuple of items back to dicts for output
    for k, v in d.items():
        v = pickle.loads(v)
        if isinstance(v, tuple):
            d[k] = dict(v)
        else:
            d[k] = v
    return d

因此：

^{pr2}$

将输出：

{'x': 1, 'y': 1}
{'y': 0}
{'x': 1}
{'deeper': {'x': {1, 2}, 'y': 1}}
{'deeper': {'x': 0, 'y': 1}, 'x': 2}
{'deeper': 1}

同时：

C = {"x": 0}
A = {"x": 1}         # Edit x
B = {"x": 2}         # Edit x with a different value
print(merge(A, B, C))

会引起：

ValueError: Conflict found in key x

以及：

C = {"deeper": {"x": 0, "y": 1}}
A = {"deeper": {"x": 0, "y": 2}} # Edit deeper["y"], but not deeper["x"]
B = {"deeper": 1} # Turn deeper into a scalar
print(merge(A, B, C))

会引起：

ValueError: Conflict found in key deeper