Python 将类似的dict条目分组为一个键元组_Python_Dictionary_Data Structures

Python 将类似的dict条目分组为一个键元组

python dictionary data-structures

Python 将类似的dict条目分组为一个键元组,python,dictionary,data-structures,Python,Dictionary,Data Structures,我想对数据集的类似条目进行分组 ds = {1: 'foo', 2: 'bar', 3: 'foo', 4: 'bar', 5: 'foo'} >>>tupelize_dict(ds) { (1,3,5): 'foo', (2,4): 'bar' } 我写了这个函数，但我确信有更简单的方法，不是吗 def tupelize_dict(data): from itertools import chain, c

我想对数据集的类似条目进行分组

ds = {1: 'foo',
      2: 'bar',
      3: 'foo',
      4: 'bar',
      5: 'foo'}

>>>tupelize_dict(ds)
{
   (1,3,5): 'foo',
   (2,4): 'bar'
}

我写了这个函数，但我确信有更简单的方法，不是吗

def tupelize_dict(data):
    from itertools import chain, combinations
    while True:
        rounds = []
        for x in combinations(data.keys(), 2):
            rounds.append((x, data[x[0]], data[x[1]]))

        end = True
        for k, a, b in rounds:
            if a == b:
                k_chain = [x if isinstance(x, (tuple, list)) else [x] for x in k]
                data[tuple(sorted(chain.from_iterable(k_chain)))] = a
                [data.pop(r) for r in k]
                end = False
                break
        if end:
            break
    return data

编辑

我对数据集的内容可以是允许

ds[I]==ds[j]

的任何类型的对象的一般情况感兴趣：

ds = {1: {'a': {'b':'c'}},
      2: 'bar',
      3: {'a': {'b':'c'}},
      4: 'bar',
      5: {'a': {'b':'c'}}}

像这样的事情应该可以做到：

>>> from collections import defaultdict
>>> ds = {1: 'foo',
...       2: 'bar',
...       3: 'foo',
...       4: 'bar',
...       5: 'foo'}
>>>
>>> d = defaultdict(list)
>>> for k, v in ds.items():
...     d[v].append(k)
...
>>> res = {tuple(v): k for k, v in d.items()}
>>> res
{(1, 3, 5): 'foo', (2, 4): 'bar'}

像这样的事情应该可以做到：

>>> from collections import defaultdict
>>> ds = {1: 'foo',
...       2: 'bar',
...       3: 'foo',
...       4: 'bar',
...       5: 'foo'}
>>>
>>> d = defaultdict(list)
>>> for k, v in ds.items():
...     d[v].append(k)
...
>>> res = {tuple(v): k for k, v in d.items()}
>>> res
{(1, 3, 5): 'foo', (2, 4): 'bar'}

你也可以这样做

def tupelize_dict(ds):
    cache = {}
    for key, value in ds.items():
        cache.setdefault(value, []).append(key)
    return {tuple(v): k for k, v in cache.items()}


ds = {1: 'foo',
      2: 'bar',
      3: 'foo',
      4: 'bar',
      5: 'foo'}
print(tupelize_dict(ds))

你也可以这样做

def tupelize_dict(ds):
    cache = {}
    for key, value in ds.items():
        cache.setdefault(value, []).append(key)
    return {tuple(v): k for k, v in cache.items()}


ds = {1: 'foo',
      2: 'bar',
      3: 'foo',
      4: 'bar',
      5: 'foo'}
print(tupelize_dict(ds))

根据的答案，如果我可以计算dataset元素内容的散列，就可以使其工作

import pickle
from collections import defaultdict

def tupelize_dict(ds):
    t = {}
    d = defaultdict(list)
    for k, v in ds.items():
        h = dumps(ds)
        t[h] = v
        d[h].append(k)

    return {tuple(v): t[k] for k, v in d.items()}

这个解决方案比我原来的建议快得多

为了测试它，我制作了一套大型随机嵌套字典，并在两种实现上运行

cProfile

：

original: 204.9 seconds
new:        6.4 seconds

编辑：

我意识到

dumps

在某些字典中不起作用，因为键的顺序可能会因模糊的原因而在内部发生变化（参见此）

解决办法是订购所有的目录：

import copy
import collections

def faithfulrepr(od):
    od = od.deepcopy(od)
    if isinstance(od, collections.Mapping):
        res = collections.OrderedDict()
        for k, v in sorted(od.items()):
            res[k] = faithfulrepr(v)
        return repr(res)
    if isinstance(od, list):
        for i, v in enumerate(od):
            od[i] = faithfulrepr(v)
        return repr(od)
    return repr(od)

def tupelize_dict(ds):
    taxonomy = {}
    binder = collections.defaultdict(list)
    for key, value in ds.items():
        signature = faithfulrepr(value)
        taxonomy[signature] = value
        binder[signature].append(key)
    def tu(keys):
        return tuple(sorted(keys)) if len(keys) > 1 else keys[0]
    return {tu(keys): taxonomy[s] for s, keys in binder.items()}