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

我试图迭代两个字典

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_列表中

为

my_列表=[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[值]

，否则将其添加到

my_list

中，如

[d2[键]，0，d2[值]

当我在我的列表中选中

'd'时，它会为我的

列表[0][0]中的

'd'提供
False
和
True

因此，为了获得
my_list[0][0]
位置，我使用了另一个
for循环

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

回溯（最近一次呼叫最后一次）：
文件“”，第4行，在
my_list[k][2]=d2[j]
关键错误：2

我错过了什么

谁能告诉我如何添加键及其值而不在列表中重复

谢谢
您可以通过三个步骤形成结果。首先，通过创建键的交叉点，创建一个包含两个DICT上存在的键的列表。然后添加仅存在于第一个dict上的键，最后添加仅存在于第二个dict上的键

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]]

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

您可以通过union来实现这一点，并且：

正如上面提到的@JimDennis只适用于Python3，因为Python2返回的是一个列表。这可以通过从返回值构造一个集合来缓解：

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

您可以通过三个步骤形成结果。首先，通过创建键的交叉点，创建一个包含两个DICT上存在的键的列表。然后添加仅存在于第一个dict上的键，最后添加仅存在于第二个dict上的键

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]]

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

您可以通过union来实现这一点，并且：

正如上面提到的@JimDennis只适用于Python3，因为Python2返回的是一个列表。这可以通过从返回值构造一个集合来缓解：

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

这样就可以了

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

输出：

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

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

这样就可以了

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

输出：

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

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

以下工作：

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)

#驱动程序值

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]]

以下工作：

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)

#驱动程序值

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]]

Python中的字典键是集合（在数学意义上）。在Python3中，它们是类似于对象的集合，可以与Python的集合操作符一起使用

在Python的早期版本中，dictionary.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

我同意“这个”和“那个”。。。“这些”和“那些”不是最受启发的变量名（“左”和“右”可能更为传统。“d”和“d1”更难阅读）

这个例子故意冗长。我最初写的是三行，但我认为这些集合表达式的复杂性更难理解和解释。这样应该是相当清楚的。交叉点是共同的关键点，每个方向上不同的集合给出的关键点只有一个或另一个；我们只需使用这些密钥集构建一个列表列表

一般来说，程序员忘记集合和集合运算符是太常见了；然后，他们重新实现代码来执行这些操作，创建了更多要维护的代码，为自己的错误提供了更多的机会，并且错过了使用内置于他们语言中的功能可能带来的性能好处。
Python中的字典键是集合（从数学意义上讲）。在Python3中，它们是类似于对象的集合，可以与Python的集合操作符一起使用

在Python的早期版本中，dictionary.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

我同意“这个”和“那个”。。。“这些”和“那些”不是最受启发的变量名（“左”和“右”可能更为传统。“d”和“d1”更难阅读）

这个例子故意冗长。我最初写的是三行，但我认为这些集合表达式的复杂性更难理解和解释。这样应该是相当清楚的。交叉点是共同的关键点，每个方向上不同的集合给出的关键点只有一个或另一个；我们只需使用这些密钥集构建一个列表列表

一般来说，程序员忘记集合和集合运算符是太常见了；然后，他们重新实现代码来执行这些操作，创建更多要维护的代码，为自己的错误提供更多的机会，并且错过了使用内置于他们语言中的功能可能带来的性能优势。
您能提供所需的输出吗？应该像[[key1，value1，value2]，[key1，value1，value2]，[key2，value1，value2]…]您使用了一个正确的输入示例。提供所需的输出。与您想要的内容几乎没有混淆。查看输出将清除这些混淆。您使用的Python版本是什么？@Kaushik d={'d'：2，'c'：6，'a'：1，'b'：3}d2={'d'：9，'b'：5，'a'：2，'k'：10}输出：[[d，2,9]，[c，6,0]，[a，1,2]，[b，3,5]，[k，0，10]]您能提供所需的输出吗？它应该像[[key1，value1，value2]，[key1，value1，value2]，[key2，value1，value2]…]您正确地使用了一个输入示例。提供所需的输出。与您想要的完全一致。看到输出将清除这些。您使用的是哪一版本的Python？@Kaushik d={'d'：2，'c'：6，'a'：1，'b'：3}d2={'d'：9，'b'：5，'a'：2，'k'：10}输出：[[d，2,9]，[c，6,0]，[a，1,2]，[b，3,5]，[k，0,10]]哇！