从{'a'：['A'，'B']，'b'：['B'，'C']} --> {'A'：['a']，'B'：['a'，'b']，'C'：['b']}转换Python字典

Question

我从这本字典开始：

lower_to_upper = {"a": ["A", "B"],
                  "b": ["B", "C"]}

然后，我将所有的大写字母放入一个列表中，并打印该列表...

upper_list = [upper for lo_uppers in lower_to_upper.values() for upper in lo_uppers]
print(f"upper_list:     {upper_list}")

..。正如预期的那样，它提供了：

upper_list:     ['A', 'B', 'B', 'C']

接下来，我根据大写字母列表创建两个字典。其中一个值为零(upper_to_count)，另一个值为空列表(upper_to_lower)：

upper_to_count = dict.fromkeys(upper_list, 0)
upper_to_lower = dict.fromkeys(upper_list, [])

接下来，我想让upper_to_count包含大写字母在原始字典中出现的条目数。同样，我想用小写字符串填充upper_to_lower中的空列表，它们是各个大写字母的键。

for i, upper_list in enumerate(lower_to_upper.values()):
    lower = list(lower_to_upper.keys())[i]
    for upper in upper_list:
        upper_to_count[upper] += 1
        upper_to_lower[upper].append(lower)

upper_to_count的结果与预期一致。但upper_to_lower的结果并不像(I)预期的那样。这些声明...

print(f"upper_to_count: {upper_to_count}")
print(f"upper_to_lower: {upper_to_lower}")

..。打印：

upper_to_count: {'A': 1, 'B': 2, 'C': 1}
upper_to_lower: {'A': ['a', 'a', 'b', 'b'], 'B': ['a', 'a', 'b', 'b'], 'C': ['a', 'a', 'b', 'b']}

我的期望是这样的：

print(f"upper_to_lower_exp: {upper_to_lower_exp}")
upper_to_lower_exp: {'A': ['a'], 'B': ['a', 'b'], 'C': ['b']}

这是一本字典，看起来像这样：

upper_to_lower_exp = {'A': ['a'],
                      'B': ['a', 'b'],
                      'C': ['b']}

我不明白为什么我得到的是upper_to_lower而不是upper_to_lower_exp。我不知道是什么在upper_to_lower而不是upper_to_lower_exp中产生输出

我为我问题的标题的奇怪之处道歉。非常感谢您提前给予我们的帮助！

Answer 1

在对键和值进行并行迭代时，最佳实践是使用.items

lower_to_upper = {"a": ["A", "B"],
                  "b": ["B", "C"]}

upper_to_lower_exp = {}
for key, values in lower_to_upper.items():
    
    # iterate over each value
    for value in values:
        
        # if no key has been created so far for the value create one
        if value not in upper_to_lower_exp:
            upper_to_lower_exp[value] = []
        
        # append the key to the list of the corresponding value
        upper_to_lower_exp[value].append(key)

# upper_to_count is just upper_to_lower_exp but with the length of the lists instead
upper_to_count = {k: len(vs) for k, vs in upper_to_lower_exp.items()}
print(upper_to_count)
print(upper_to_lower_exp)

输出

{'A': 1, 'B': 2, 'C': 1}
{'A': ['a'], 'B': ['a', 'b'], 'C': ['b']}

Answer 2

不确定您是如何初始化upper_to_lower字典的，但是如果像这样初始化，您的代码将按原样工作：

# `list(set(upper_list))` being ['A', 'B', 'C']
upper_to_lower = {k: [] for k in list(set(upper_list))}

for i, upper_list in enumerate(lower_to_upper.values()):
    lower = list(lower_to_upper.keys())[i]
    for upper in upper_list:
        upper_to_count[upper] += 1
        upper_to_lower[upper].append(lower)

输出：

{'B': ['a', 'b'], 'A': ['a'], 'C': ['b']}

Answer 3

我找到了答案。在官方文档中，关键的花边新闻是初始化字典的值“只引用单个实例”--可以是那个None，也可以是一个空列表。因此，当我将元素附加到这个列表中时，最终字典中的所有键都将指向相同的列表。

迭代值类方法fromkeys(iterable，值)创建一个新的字典，使用来自

的键并将值设置为value。fromkeys()是一个返回新字典的类方法。值默认为None。所有的值都只引用一个实例，所以值通常是一个可变对象，比如一个空列表。要获得不同的值，请改用字典理解。(enter link description here)

我一点也不知道。非常感谢您提供的答案！