Question

我正在尝试迭代两个词典d = {'d': 2, 'c': 6, 'a': 1, 'b': 3}和d2 = {'j': 9, 'b': 5, 'a': 2, 'k': 10}。它应该存储像 [[key1, value1 value2], [key1, value1, value2], [key2, value1, value2]...] 首先，尝试将d值存储在my_list my_list = [d[keys], d[values], 0]中。

我的代码如下，

my_list = []
for i, j in d.items():
if i in my_list:
    print(i, "is in list")
else:
    my_list.append([i,j,0])

output: my_list = [['d', 2, 0], ['c', 6, 0], ['a', 1, 0], ['b', 3, 0]]

然后，迭代d2，如果d2中存在my_list的密钥，则将0替换为d2[values]，否则将其添加到my_list比如[d2[keys], 0, d2[values]]。

当我检查'd' in my_list时，它会为False提供True和'd' in my_list[0][0]。

所以，为了获得my_list[0][0]位置，我使用了另一个for loop之类的东西，

for k in range(len(d2)):
    for i, j in d2.items():
        if i in my_list[k][0]:
            my_list[k][2] = d2[j]
        else:
            my_list.append([i,0,j])

给了我错误，

    Traceback (most recent call last):
  File "<pyshell#505>", line 4, in <module>
    my_list[k][2] = d2[j]
KeyError: 2

我在这里缺少什么？

任何人都可以告诉我如何在不重复列表的情况下添加密钥及其值吗？

谢谢

Answer 1

您可以分三步形成结果。首先通过创建键的交集来创建包含两个dicts上存在的键的列表。然后添加仅存在于第一个键中的键，最后添加仅在第二个词典中的键。

d = {'d': 2, 'c': 6, 'a': 1, 'b': 3}
d2 = {'d': 9, 'b': 5, 'a': 2, 'k': 10}

result = [[k, d[k], d2[k]] for k in d.keys() & d2.keys()]
result.extend([k, d[k], 0] for k in d if k not in d2)
result.extend([k, 0, d2[k]] for k in d2 if k not in d)

print(result)

输出：

[['b', 3, 5], ['d', 2, 9], ['a', 1, 2], ['c', 6, 0], ['k', 0, 10]]

您可以使用union和dict.get执行此操作：

>>> d = {'d': 2, 'c': 6, 'a': 1, 'b': 3}
>>> d2 = {'d': 9, 'b': 5, 'a': 2, 'k': 10}
>>> [[k, d.get(k, 0), d2.get(k, 0)] for k in d.keys() | d2.keys()]
[['k', 0, 10], ['c', 6, 0], ['d', 2, 9], ['a', 1, 2], ['b', 3, 5]]

正如上面提到的@JimDennis只适用于Python 3，因为在Python 2上keys会返回一个列表。这可以通过从返回值构造一个集来缓解：

[[k, d.get(k, 0), d2.get(k, 0)] for k in set(d.iterkeys()) | set(d2.iterkeys())]

Answer 2

这样做

d = {'d': 2, 'c': 6, 'a': 1, 'b': 3} 
d2 = {'j': 9, 'b': 5, 'a': 2, 'k': 10}

list=[]
for key,value in d.iteritems():
  if key in d2:
    list.append([key,d[key],d2[key]])
  else:
    list.append([key,d[key],0])

for key,value in d2.iteritems():
  if key not in d:
    list.append([key,0,d2[key]])

print list

输出：

[['a', 1, 2], ['c', 6, 0], ['b', 3, 5], ['d', 2, 0], ['k', 0, 10], ['j', 0, 9]]

Answer 3

以下作品：

l=[]                                           #store desired output
#go through elements of First dictionary (d1)
for key,val in d1.items(): 
   try: 
     #create the list and pop the element in d2 that matched with key of d1 
     temp = [key,val,d2.pop(key)] 
   except: 
     temp = [key,val,0] 
   l.append(temp) 

#print(l)
#[['d', 2, 9], ['c', 6, 0], ['a', 1, 2], ['b', 3, 5]]

#d2 may have elements left, go through them
for key,val in d2.items():
  temp=[key,0,val]
  l.append(temp)

print(l)

#driver values

IN : d1= {'d': 2, 'c': 6, 'a': 1, 'b': 3}
IN : d2 = {'d': 9, 'b': 5, 'a': 2, 'k': 10}
OUT: [['d', 2, 9], ['c', 6, 0], ['a', 1, 2], ['b', 3, 5], ['k', 0, 10]]

Answer 4

Python中的字典键是集合（在数学意义上）。在Python3中，它们像对象一样设置，可以与Python的集合运算符一起使用。

在早期版本的Python中，字典 .keys（）方法返回一个列表，必须将其显式转换为 set（）才能使用set运算符/方法。

因此，对您所述要求的简单功能就像：

def merge_dicts_to_list(this, that):
    common = set(this.keys()) & set(that.keys())
    these  = set(this.keys()) - set(that.keys())
    those  = set(that.keys()) - set(this.keys())
    results = [[k, this[k], that[k]] for k in common]
    results.extend([[k, this[k]] for k in these])
    results.extend([[k, that[k]] for k in those])
    return results

我会批准＆＃34;这个＆＃34;和＃34;那＆＃34; ......＆＃34;这些＆＃34;和那些＆＃34;那些＆＃34;不是最灵感的变量名称（＆＃34;左＆＃34;和＆＃34;右＆＃34;可能更传统。＆＃34; d＆＃34;＆＃34; d1＆＃34;更难读取）。

这个例子故意冗长。我最初把它写成三行，但我认为这些表达式的复杂性更难阅读和推理。这种方式应该相当清楚。交集是共同的关键，每个方式的集合不同，只能在一个或另一个中找到那些密钥;我们只是使用这些密钥集构建一个列表列表。

一般来说，程序员忘记集合和设置运算符是很常见的;然后，他们最终重新实现代码来执行这些操作，创建更多代码来维护，为自己的错误提供更多机会，并且缺少使用其语言内置功能可能带来的性能优势。

如何迭代两个字典并将它们保存在python的列表中

4 个答案: