在Python中合并字典的值列表

Question

我正在尝试合并三个字典，这些字典都有相同的键，其中包含值列表或单个值。

one={'a': [1, 2], 'c': [5, 6], 'b': [3, 4]}
two={'a': [2.4, 3.4], 'c': [5.6, 7.6], 'b': [3.5, 4.5]}
three={'a': 1.2, 'c': 3.4, 'b': 2.3}

我需要的是将values中所有的项目添加到一个列表中。

result={'a': [1, 2, 2.4, 3.4, 1.2], 'c': [5, 6, 5.6, 7.6, 2.3], 'b': [3, 4, 3.5, 4.5, 3.4]}

我已经尝试了几种方法，但大多数方法都将值放入嵌套列表中。例如：

out=dict((k, [one[k], two.get(k), three.get(k)]) for k in one)
{'a': [[1, 2], [2.4, 3.4], 1.2], 'c': [[5, 6], [5.6, 7.6], 3.4], 'b': [[3, 4], [3.5, 4.5], 2.3]}

我尝试通过循环遍历值来更新它：

out.update((k, [x for x in v]) for k,v in out.iteritems())

但是结果完全相同。我试图简单地添加这些列表，但由于第三个字典仅有一个浮点数，所以我无法这样做。

check=dict((k, [one[k]+two[k]+three[k]]) for k in one)

所以我先尝试将一和二的值相加，然后再附加三的值。合并列表很好用，但是当我尝试添加第三个字典中的浮点数时，整个值突然变成了“None”。

check=dict((k, [one[k]+two[k]]) for k in one)
{'a': [[1, 2, 2.4, 3.4]], 'c': [[5, 6, 5.6, 7.6]], 'b': [[3, 4, 3.5, 4.5]]}
new=dict((k, v.append(three[k])) for k,v in check.items())
{'a': None, 'c': None, 'b': None}

- branwen85

Answer 1

使用字典推导式，可以将其编写成一行代码：

new = {key: value + two[key] + [three[key]] for key, value in one.iteritems()}

这将创建新的列表，将one中的列表与two中对应的列表连接起来，并将three中的单个值放入临时列表中，以使连接更加容易。

或者使用一个for循环来直接更新one：

for key, value in one.iteritems():
    value.extend(two[key])
    value.append(three[key])

这段代码使用了list.extend()方法来原地更新原始列表，将two列表中的内容添加到其中，同时使用list.append()方法将three中的单个值添加到此列表中。

你犯的错误：

• 你第一次尝试创建了一个新列表，其中包含嵌套在其中的one、two和three列表的值，而不是连接现有列表。你后来试图清理它，只是复制了那些嵌套的列表。

• 你的第二次尝试没有成功，因为three中的值不是一个列表，所以不能进行连接操作。我为此创建了一个仅包含该值的新列表。

• 你最后的尝试不应该在生成器表达式中使用list.append()方法，因为你存储的是该方法的返回值，而其返回的总是None（它的更改直接存储在v中，列表不需要再次返回）。

下面是第一种方法的示例：

>>> one={'a': [1, 2], 'c': [5, 6], 'b': [3, 4]}
>>> two={'a': [2.4, 3.4], 'c': [5.6, 7.6], 'b': [3.5, 4.5]}
>>> three={'a': 1.2, 'c': 3.4, 'b': 2.3}
>>> {key: value + two[key] + [three[key]] for key, value in one.iteritems()}
{'a': [1, 2, 2.4, 3.4, 1.2], 'c': [5, 6, 5.6, 7.6, 3.4], 'b': [3, 4, 3.5, 4.5, 2.3]}

- Martijn Pieters

---

在Python3中，使用items()代替iteritems()。 - Green

Answer 2

任意字典编号和键

您尝试的问题由@MartijnPieters' solution解决。

对于一个通用的解决方案，考虑使用itertools.chain来链接多个字典。您还可以在没有在每个字典中找到相同键的更一般情况下使用defaultdict。

from collections import defaultdict
from itertools import chain
from operator import methodcaller

# dictionaries with non-equal keys, values all lists for simplicity
one = {'a': [1, 2], 'c': [5, 6], 'b': [3, 4], 'e': [6.2]}
two = {'a': [2.4, 3.4], 'c': [5.6, 7.6], 'b': [3.5, 4.5], 'f': [1.3]}
three = {'a': [1.2], 'c': [3.4], 'b': [2.3], 'e': [3.1]}

# initialise defaultdict of lists
dd = defaultdict(list)

# iterate dictionary items
dict_items = map(methodcaller('items'), (one, two, three))
for k, v in chain.from_iterable(dict_items):
    dd[k].extend(v)

print(dd)

# defaultdict(list,
#             {'a': [1, 2, 2.4, 3.4, 1.2],
#              'b': [3, 4, 3.5, 4.5, 2.3],
#              'c': [5, 6, 5.6, 7.6, 3.4],
#              'e': [6.2, 3.1],
#              'f': [1.3]})

注意defaultdict是dict的一个子类，通常不需要将结果转换为普通的dict。

- jpp

---

使用dict.setdefault的替代方法是使用defaultdict。如果您忘记了每次访问不存在的键时不会抛出异常并返回列表（或任何您的defaultdict的默认值工厂方法返回的内容），则defaultdict可能会对您造成麻烦。 - Dominykas Mostauskis

Answer 3

一个强大的解决方案。=)

def FullMergeDict(D1, D2):
  for key, value in D1.items():
    if key in D2:
      if type(value) is dict:
        FullMergeDict(D1[key], D2[key])
      else:
        if type(value) in (int, float, str):
          D1[key] = [value]
        if type(D2[key]) is list:
          D1[key].extend(D2[key])
        else:
          D1[key].append(D2[key])
  for key, value in D2.items():
    if key not in D1:
      D1[key] = value

if __name__ == '__main__':
  X = {
    'a': 'aaa',
    'c': [1,3,5,7],
    'd': 100,
    'e': {'k': 1, 'p': 'aa','t': [-1,-2]},
    'f': {'j':1}
  }
  Y = {
    'b': 'bbb',
    'd': 200,
    'e': {'k': 2, 'p': 'bb','o': [-4]},
    'c': [2,4,6],
    'g': {'v':2}
  }
  FullMergeDict(X, Y)
  exit(0)

结果：

  X = {
    'a': 'aaa',
    'b': 'bbb',
    'c': [1, 3, 5, 7, 2, 4, 6],
    'd': [100, 200],
    'e': {'k': [1, 2], 'o': [-4], 'p': ['aa', 'bb'], 't': [-1, -2]},
    'f': {'j': 1},
    'g': {'v': 2}}

- Deoclecio Freire

---

很棒的解决方案！我刚刚用它来合并两个字典，其中列表值是元组对的元组。 哦，还有两个字典中的键也是元组。 所有元组（键和值）都是坐标对。 运行得非常好！ - MarkS

Answer 4

一行解决方案（也适用于仅存在于一个字典中的键）:

{ key:one.get(key,[])+two.get(key,[]) for key in set(list(one.keys())+list(two.keys())) }

例子1：

one = {'a': [1, 2], 'c': [5, 6], 'b': [3, 4]}
two = {'a': [2.4, 3.4], 'c': [5.6, 7.6], 'd': [3.5, 4.5]}
{ key:one.get(key,[])+two.get(key,[]) for key in set(list(one.keys())+list(two.keys())) }

输出:

{'a': [1, 2, 2.4, 3.4], 'b': [3, 4], 'c': [5, 6, 5.6, 7.6], 'd': [3.5, 4.5]}

例子2:

x={1:['a','b','c']}
y={1:['d','e','f'],2:['g']}
{ key:x.get(key,[])+y.get(key,[]) for key in set(list(x.keys())+list(y.keys())) }

输出:

{1: ['a', 'b', 'c', 'd', 'e', 'f'], 2: ['g']}

- Shailesh Appukuttan

Answer 5

如果您在字典中有不同的键和不同类型的值，您可以使用以下方法：

from collections import defaultdict, Iterable

dct1 = {'a': [1, 2]}
dct2 = {'a': [3], 'b': [5, 6]}
dct3 = {'a': 4, 'c': 7}

result = defaultdict(list)
for dct in [dct1, dct2, dct3]:
    for k, v in dct.items():
        if isinstance(v, Iterable):
            result[k].extend(v)
        else:
            result[k].append(v)

print(result)
# defaultdict(<class 'list'>, {'a': [1, 2, 3, 4], 'b': [5, 6], 'c': [7]}) 

- Mykola Zotko

Answer 6

看看这个帮助有没有用：

>>> dic={}
>>> k=[]
>>> for i in 'abc':
    k=one[i]+two[i]
    k.append(three[i])
    dic[i]=k


>>> dic
{'c': [5, 6, 5.6, 7.6, 3.4], 'a': [1, 2, 2.4, 3.4, 1.2], 'b': [3, 4, 3.5, 4.5, 2.3]}

- HBasiri