Python 使用其他词典中的特定对创建词典

此列表：

data=[[{'t1':'text1.txt','date1':'class1'}],[{'t2':'text2.txt','date2':'class2'}]]
data

给予

我想把它变成这样： 编辑添加括号

[[{'text1.txt': 'class1'}], [{'text2.txt': 'class2'}]]

这意味着：

要创建一个列表，其中每个子列表将由一个字典组成，键将是第一个子列表中第一个字典的值，而值将是第一个子列表中第二个字典的值，依此类推

我的尝试是：

se=[]
for i in data:
    for j in i:
        jk=j.values()
        se.append(jk)
se

试试这个：

data=[[{'t1':'text1.txt','date1':'class1'}],[{'t2':'text2.txt','date2':'class2'}]]

all_vals = [];

for i in data:
    for j in i:
        for key in j:
            all_vals.append(j[key])

new_list = [];            
for i in range(0,len(all_vals)-1):
    if (i % 2) == 0:
        new_dict = {};
        new_dict = {all_vals[i]:all_vals[i+1]}
        new_list.append(new_dict)
    else:
        continue
        
print(new_list)

输出：

[{'text1.txt': 'class1'}, {'text2.txt': 'class2'}]

无论列表的长度如何，此代码都有效。

请尝试以下操作：

data=[[{'t1':'text1.txt','date1':'class1'}],[{'t2':'text2.txt','date2':'class2'}]]

all_vals = [];

for i in data:
    for j in i:
        for key in j:
            all_vals.append(j[key])

new_list = [];            
for i in range(0,len(all_vals)-1):
    if (i % 2) == 0:
        new_dict = {};
        new_dict = {all_vals[i]:all_vals[i+1]}
        new_list.append(new_dict)
    else:
        continue
        
print(new_list)

输出：

[{'text1.txt': 'class1'}, {'text2.txt': 'class2'}]

---

无论列表的长度如何，此代码都有效。

大部分工作由您的代码完成。您可以添加另一行以获得所需的结果：

In [108]: se
Out[108]: [dict_values(['text1.txt', 'class1']), dict_values(['text2.txt', 'class2'])]

In [109]: [[{list(x)[0]:list(x)[1]} for x in se]]
Out[109]: [[{'text1.txt': 'class1'}, {'text2.txt': 'class2'}]]

---

您的代码完成了大部分工作。您可以添加另一行以获得所需的结果：

In [108]: se
Out[108]: [dict_values(['text1.txt', 'class1']), dict_values(['text2.txt', 'class2'])]

In [109]: [[{list(x)[0]:list(x)[1]} for x in se]]
Out[109]: [[{'text1.txt': 'class1'}, {'text2.txt': 'class2'}]]

---

迭代嵌套列表中的每个字典，并根据

values（）

方法为每个字典创建一个元组，如下所示

tuple（dict.values（））

。转换为元组后，您可以使用

dict（）

从元组创建字典，如下

dict（[tuple（dict.values（））]）

注意：如果你的字典正好有两个键，那么只有它能用

输出：

[[{'text1.txt': 'class1'}], [{'text2.txt': 'class2'}]]

---

迭代嵌套列表中的每个字典，并根据

values（）

方法为每个字典创建一个元组，如下所示

tuple（dict.values（））

。转换为元组后，您可以使用

dict（）

从元组创建字典，如下

dict（[tuple（dict.values（））]）

注意：如果你的字典正好有两个键，那么只有它能用

输出：

[[{'text1.txt': 'class1'}], [{'text2.txt': 'class2'}]]

---

以下功能应将输入转换为您请求的输出

def convert_to_list_of_list_of_dictionaries(input_dictionaries):
  ret_dictionaries = []
  for inp in input_dictionaries:
    k, v = inp[0].values()
    ret_dictionaries.append({k, v})
  return ret_dictionaries

然而，在输入/输出方面有一些事情很少涉及，并且使数据更难处理。 在输入端，数据被包装在一个额外的列表中，该列表在此上下文中不提供任何功能，并强制您索引内部列表的第一个元素以访问dict

k，v=inp[0]。values（）

。在输出端，我们正在做同样的事情，这使得迭代输出变得更加困难。它看起来像：

# psuedocode
for kv in reformatted_outputs:
    unwrapped_dict = kv[0]
    key, value = next(iter(unwrapped_dict.items()))
    # process key and value

def convert_to_single_dictionary(input_dictionaries):
  ret = {}
  for inp in input_dictionaries:
    print(inp)
    # it looks like the input data is being wrapped in an extra list
    k, v = inp[0].values()
    ret[k] = v
  return ret

相反，如果您的输出格式为“`{'text1.txt'：'class1'，'text2.txt'：'class2'}”，则可以处理如下数据：

key, value in reformatted_outputs.items():
    # process key and value

如果你有能力修改你正在进行的工作的输入和输出，这可以为你和你正在处理的任何人节省一些麻烦

如果要修改输出格式，您的函数可以如下所示：

# psuedocode
for kv in reformatted_outputs:
    unwrapped_dict = kv[0]
    key, value = next(iter(unwrapped_dict.items()))
    # process key and value

def convert_to_single_dictionary(input_dictionaries):
  ret = {}
  for inp in input_dictionaries:
    print(inp)
    # it looks like the input data is being wrapped in an extra list
    k, v = inp[0].values()
    ret[k] = v
  return ret

---

希望这是有帮助的，谢谢你的提问

以下功能应将输入转换为您请求的输出

def convert_to_list_of_list_of_dictionaries(input_dictionaries):
  ret_dictionaries = []
  for inp in input_dictionaries:
    k, v = inp[0].values()
    ret_dictionaries.append({k, v})
  return ret_dictionaries

然而，在输入/输出方面有一些事情很少涉及，并且使数据更难处理。 在输入端，数据被包装在一个额外的列表中，该列表在此上下文中不提供任何功能，并强制您索引内部列表的第一个元素以访问dict

k，v=inp[0]。values（）

。在输出端，我们正在做同样的事情，这使得迭代输出变得更加困难。它看起来像：

# psuedocode
for kv in reformatted_outputs:
    unwrapped_dict = kv[0]
    key, value = next(iter(unwrapped_dict.items()))
    # process key and value

def convert_to_single_dictionary(input_dictionaries):
  ret = {}
  for inp in input_dictionaries:
    print(inp)
    # it looks like the input data is being wrapped in an extra list
    k, v = inp[0].values()
    ret[k] = v
  return ret

相反，如果您的输出格式为“`{'text1.txt'：'class1'，'text2.txt'：'class2'}”，则可以处理如下数据：

key, value in reformatted_outputs.items():
    # process key and value

如果你有能力修改你正在进行的工作的输入和输出，这可以为你和你正在处理的任何人节省一些麻烦

如果要修改输出格式，您的函数可以如下所示：

# psuedocode
for kv in reformatted_outputs:
    unwrapped_dict = kv[0]
    key, value = next(iter(unwrapped_dict.items()))
    # process key and value

def convert_to_single_dictionary(input_dictionaries):
  ret = {}
  for inp in input_dictionaries:
    print(inp)
    # it looks like the input data is being wrapped in an extra list
    k, v = inp[0].values()
    ret[k] = v
  return ret

---

希望这是有帮助的，谢谢你的提问

为了澄清，您想创建一个字典，每个输入字典包含一个

键

：

值

对？每个输入字典将有两个键：值对？是的，如示例所示。为了澄清，您想创建一个包含每个输入字典一个键的字典：

value

对吗？每个输入字典都将有两个键：值对？是的，如示例所示。很抱歉出错。我忘了括号。这是所需的结果：

[[{'text1.txt'：'class1'}]，{'text2.txt'：'class2'}]

您能修改您的答案以给出上述结果吗？谢谢你的错误。我忘了括号。这是所需的结果：

[[{'text1.txt'：'class1'}]，{'text2.txt'：'class2'}]

您能修改您的答案以给出上述结果吗？谢谢你的错误。我忘了括号。这是所需的结果：[{'text1.txt'：'class1'}]，{'text2.txt'：'class2'}]这应该可以完成工作：

In[128]：[[{list（x）[0]：list（x）[1]}]for x In se]Out[128]：[{'text1.txt'：'class1'}]，{'text2.txt'：'class2'}]]

抱歉这个错误。我忘了括号。这是所需的结果：[{'text1.txt'：'class1'}]，{'text2.txt'：'class2'}]这应该可以完成工作：

In[128]：[[{list（x）[0]：list（x）[1]}]for x In se]Out[128]：[{'text1.txt'：'class1'}]，{'text2.txt'：'class2'}]]

抱歉这个错误。我忘了括号。这是所需的结果：[[{'text1.txt'：'class1'}]，{'text2.txt'：'class2'}]]抱歉这个错误。我忘了括号。这是所需的结果：[[{'text1.txt'：'class1'}]，{'text2.txt'：'class2'}]