组合共享值和键的python字典

Question

我正在根据字符串编辑距离进行一些实体匹配，我的结果是一个字典，其中包含基于某些评分标准的键（查询字符串）和值 [相似字符串列表]。

例如：

results = {
  'ben' : ['benj', 'benjamin', 'benyamin'],
  'benj': ['ben', 'beny', 'benjamin'],
  'benjamin': ['benyamin'],
  'benyamin': ['benjamin'],
  'carl': ['karl'],
  'karl': ['carl'],
}

每个值也有一个对应的字典项，它是它的键（例如'carl'和'karl'）。

我需要组合具有共同价值的元素。选择一个值作为新键（假设是最长的字符串）。在上面的例子中，我希望得到：

results = {
  'benjamin': ['ben', 'benj', 'benyamin', 'beny', 'benjamin', 'benyamin'],
  'carl': ['carl','karl']
}

我尝试过使用键迭代字典，但我无法理解如何迭代和比较每个字典项及其值列表（或单个值）。

Answer 1

这是使用collections.defaultdict 和集合的一种解决方案。

所需的输出与您所拥有的非常相似，并且可以轻松操作以对齐。

from collections import defaultdict

results = {
  'ben' : ['benj', 'benjamin', 'benyamin'],
  'benj': ['ben', 'beny', 'benjamin'],
  'benjamin': 'benyamin',
  'benyamin': 'benjamin',
  'carl': 'karl',
  'karl': 'carl',
}

d = defaultdict(set)

for i, (k, v) in enumerate(results.items()):
    w = {k} | (set(v) if isinstance(v, list) else {v})
    for m, n in d.items():
        if not n.isdisjoint(w):
            d[m].update(w)
            break
    else:
        d[i] = w

result = {max(v, key=len): v for k, v in d.items()}

# {'benjamin': {'ben', 'benj', 'benjamin', 'beny', 'benyamin'},
#  'carl': {'carl', 'karl'}}

感谢@IMCoins 在第二个循环中将v 操作为w 的想法。

说明

有3个主要步骤：

1. 将值转换为一致的集合格式，包括原始字典中的键和值。
2. 循环浏览此字典并将值添加到新字典。如果与某个键 [i.e.集合不是不相交的]，然后使用该键。否则，添加到通过枚举确定的新密钥。
3. 通过将最大长度键映射到值来在最终转换中创建结果字典。

Answer 2

编辑：尽管性能不是这里的问题，但我冒昧地在 jpp 的答案和我的答案之间进行了一些测试......这是完整的脚本。我的脚本在 17.79 秒内执行测试，而他在 23.5 秒内执行测试。

import timeit

results = {
  'ben' : ['benj', 'benjamin', 'benyamin'],
  'benj': ['ben', 'beny', 'benjamin'],
  'benjamin': ['benyamin'],
  'benyamin': ['benjamin'],
  'carl': ['karl'],
  'karl': ['carl'],
}

def imcoins(result):
    new_dict = {}
    # .items() for python3x
    for k, v in results.iteritems():
        flag = False
        #   Checking if key exists...
        if k not in new_dict.keys():
            #   But then, we also need to check its values.
            for item in v:
                if item in new_dict.keys():
                    #   If we update, set the flag to True, so we don't create a new value.
                    new_dict[item].update(v)
                    flag = True
            if flag == False:
                new_dict[k] = set(v)

    #   Now, to sort our newly created dict...
    sorted_dict = {}
    for k, v in new_dict.iteritems():
        max_string = max(v)
        if len(max_string) > len(k):
            sorted_dict[max(v, key=len)] = set(v)
        else:
            sorted_dict[k] =  v

    return sorted_dict

def jpp(result):
    from collections import defaultdict

    res = {i: {k} | (set(v) if isinstance(v, list) else {v}) \
          for i, (k, v) in enumerate(results.items())}

    d = defaultdict(set)

    for i, (k, v) in enumerate(res.items()):
        for m, n in d.items():
            if n & v:
                d[m].update(v)
                break
        else:
            d[i] = v

    result = {max(v, key=len): v for k, v in d.items()}
    return result

iterations = 1000000
time1 = timeit.timeit(stmt='imcoins(results)', setup='from __main__ import imcoins, results', number=iterations)
time2 = timeit.timeit(stmt='jpp(results)', setup='from __main__ import jpp, results', number=iterations)

print time1 # Outputs : 17.7903265883
print time2 # Outputs : 23.5605850732

如果我将导入从他的函数移动到全局范围，它会给出......

imcoins : 13.4129249463 秒

jpp : 21.8191823393 秒