根据键映射dicts

Question

Given a list of dict s

input = [
  {'key': k1, 'value': v1},
  {'key': k1, 'value': v2},
  {'key': k2, 'value': v3}
]

What is the easiest way to to map these to the output

output == {k1: (v1, v2), k2: (v3)}

I don't really care about the order of the values. The best I've come up with is.

output = dict()
for i in input:
    temp = output.get(i['key'], [])
    temp.append(i['value'])
    output[i['key']] = temp

Any slick what of doing this with dict comprehension? I'm assuming the same process would work for a list of objects with attributes as well.

Answer 1

You can use collections.defaultdict to loop over your dictionaries values then append them to defaultdict :

>>> from collections import defaultdict
>>> a = defaultdict(tuple)
>>> for d in input:
...     a[d['key']] += (d['value'],)
... 
>>> a
defaultdict(<type 'tuple'>, {'k2': ('v3',), 'k1': ('v1', 'v2')})

Answer 2

In a dict comprehension, any single key can only be accessed or modified once. In order to ensure that multiple values are paired with a single key, then, the values will need to be grouped in advance. A naive grouping solution will have, at best, quadratic performance. In fact, I can't come up with a one-liner that's better than cubic; it's an ugly beast, not even worth posting.

So an approach based on defaultdict will almost always be best.

However, if your data is guaranteed to be sorted, or if you're willing to accept O(n log n) performance, then you could use itertools.groupby .

>>> input
[{'value': 1, 'key': 'a'}, {'value': 2, 'key': 'a'}, {'value': 3, 'key': 'b'}]
>>> {k:tuple(d['value'] for d in v) for k, v in
...  itertools.groupby(input, key=lambda d: d['key'])}
{'a': (1, 2), 'b': (3,)}

To get rid of the unsightly lambda , you could use operator .

>>> {k:tuple(d['value'] for d in v) for k, v in
...  itertools.groupby(input, key=operator.itemgetter('key'))}
{'a': (1, 2), 'b': (3,)}

Or, if you have to sort first:

>>> {k:tuple(d['value'] for d in v) for k, v in itertools.groupby(
...  sorted(input, key=operator.itemgetter('key')),
...  key=operator.itemgetter('key'))}
{'a': (1, 2), 'b': (3,)}

None of these solutions are very attractive; they all look a bit like abuses of comprehension syntax, with the possible exception of the second.

As an alternative to importing from collections , you can use setdefault -- though this produces lists rather than tuples:

>>> output = {}
>>> for d in input:
...     output.setdefault(d['key'], []).append(d['value'])
... 
>>> output
{'a': [1, 2], 'b': [3]}

Finally, consider this alternative -- I can't tell how I feel about it, but it does avoid all imports and exotic features, and produces tuples:

>>> output = {d['key']:() for d in input}
>>> for d in input:
...     output[d['key']] += (d['value'],)
... 
>>> output
{'a': (1, 2), 'b': (3,)}