Python 有没有一种简单的方法把一本字典映射到另一本字典？

我有两本字典：

source={'a'：10，'b'：20，'c'：30} 目的地={'x'：无，'y'：无，'z'：无，'qq'：'Some value'} 我想根据一些预设映射将源词典映射到目标词典，例如：

a -> y
b -> z
c -> x

我可以创建一个函数，在目标字典上循环，并根据嵌套的条件指定适当的值，如果：

对于目的地项目中的k、v： 如果k='x'： 目的地[k]=源['c'] elif k==“y”： 目的地[k]=源['a'] elif k==“z”： 目的地[k]=源['b'] 这似乎不是很容易扩展。 此外，我可能在源和目标中都嵌套了键，这使得循环更加复杂。 嵌套源/目标词典的一个示例可能是：

源_嵌套= { a:{ f:{ k:4， l:猫 } }, b:{ s:击中 } } 目的地\u嵌套= { x:没有， y:{ 问：没有， r:100 }, z:没有 } 使用以下映射示例：

a/f/k -> y/q
a/f/l -> x
b/s -> z

进行这种重新映射的更有效方法是什么

---

如果重要的话，这些字典是JSON文件的表示。

将映射定义为键和值反转的另一个字典，然后使用三元If/else的字典理解来获得结果：

source = {'a': 10, 'b': 20, 'c': 30}
destination = {'x': None, 'y': None, 'z': None, 'qq': 'Some value'}

mapping = {"y": "a", "z": "b", "x": "c"}  # note: key/values inversed
result = {k: source[mapping[k]] if k in mapping else v
          for k, v in destination.items()}
# {'x': 30, 'y': 10, 'z': 20, 'qq': 'Some value'}

或先将源键映射到目标键，然后使用默认的get：

mapping = {"a": "y", "b": "z", "c": "x"}  # note: original order
source_mapped = {mapping.get(k, k): v for k, v in source.items()}
result = {k: source_mapped.get(k, v) for k, v in destination.items()}

对于嵌套的情况，您可能首先必须定义两个递归函数，让我们使用多部分键在嵌套字典中将它们称为deep_set和deep_get set和get value

def deep_set(d, keys, val):
    first, *rest = keys
    if rest:
        deep_set(d[first], rest, val)
    else:
        d[first] = val

def deep_get(d, keys):
    first, *rest = keys
    if rest:
        return deep_get(d[first], rest)
    else:
        return d[first]

然后，您可以再次定义映射，迭代这些对，并在目标目录中替换它们。对于dict理解来说，这不起作用，所以我只修改目标目录；如果仍然需要，请确保先创建深度副本

mapping = [("a/f/k", "y/q"), ("a/f/l", "x"), ("b/s", "z")]
for s, t in mapping:
    val = deep_get(source_nest, s.split("/"))
    deep_set(destination_nest, t.split("/"), val)
# {'x': 'cat', 'y': {'q': 4, 'r': 100}, 'z': 'hit'}

---

将映射定义为键和值反转的另一个字典，然后使用三元if/else的字典理解来获得结果：

source = {'a': 10, 'b': 20, 'c': 30}
destination = {'x': None, 'y': None, 'z': None, 'qq': 'Some value'}

mapping = {"y": "a", "z": "b", "x": "c"}  # note: key/values inversed
result = {k: source[mapping[k]] if k in mapping else v
          for k, v in destination.items()}
# {'x': 30, 'y': 10, 'z': 20, 'qq': 'Some value'}

或先将源键映射到目标键，然后使用默认的get：

mapping = {"a": "y", "b": "z", "c": "x"}  # note: original order
source_mapped = {mapping.get(k, k): v for k, v in source.items()}
result = {k: source_mapped.get(k, v) for k, v in destination.items()}

对于嵌套的情况，您可能首先必须定义两个递归函数，让我们使用多部分键在嵌套字典中将它们称为deep_set和deep_get set和get value

def deep_set(d, keys, val):
    first, *rest = keys
    if rest:
        deep_set(d[first], rest, val)
    else:
        d[first] = val

def deep_get(d, keys):
    first, *rest = keys
    if rest:
        return deep_get(d[first], rest)
    else:
        return d[first]

然后，您可以再次定义映射，迭代这些对，并在目标目录中替换它们。对于dict理解来说，这不起作用，所以我只修改目标目录；如果仍然需要，请确保先创建深度副本

mapping = [("a/f/k", "y/q"), ("a/f/l", "x"), ("b/s", "z")]
for s, t in mapping:
    val = deep_get(source_nest, s.split("/"))
    deep_set(destination_nest, t.split("/"), val)
# {'x': 'cat', 'y': {'q': 4, 'r': 100}, 'z': 'hit'}

---

我使用映射的值作为源代码的键，并创建了一个名为result的键/值对字典

source = {'a': 10, 'b': 20, 'c': 30}
destination = {'x': None, 'y': None, 'z': None, 'qq': 'Some value'}
mapping = {"y": "a", "z": "b", "x": "c"}
result={k:source.get(v) for (k,v) in mapping.items()}

print(result)

输出：

{'y': 10, 'z': 20, 'x': 30}

---

我使用映射的值作为源代码的键，并创建了一个名为result的键/值对字典

source = {'a': 10, 'b': 20, 'c': 30}
destination = {'x': None, 'y': None, 'z': None, 'qq': 'Some value'}
mapping = {"y": "a", "z": "b", "x": "c"}
result={k:source.get(v) for (k,v) in mapping.items()}

print(result)

输出：

{'y': 10, 'z': 20, 'x': 30}

---

使用第三本字典：{'x'：'c'，'y'：'a'，'z'：'b'}。使用第三本字典：{'x'：'c'，'y'：'a'，'z'：'b'}。谢谢你为我指明了正确的方向。如果我有嵌套的键，映射会是什么样子？我添加了一个嵌套的示例谢谢你给我指明了正确的方向。如果我有嵌套键，映射会是什么样子？我添加了一个嵌套示例