Question

我正在与requests合作，并且有一些端点/服务，其标头和其主体。主体是字典。

我需要做的是将一个请求的响应中的键值分配给另一个请求的主体，因为它取决于从另一个请求返回的某个值。

我们假设以下两个字典：

d1 = {    # Dictionary that has to be updated
    "a": 1,
    "b": {
        "c": 2,
        "d": {
            "e": 3,
            "f": 4
        }
    }
    }

d2 = {    # Dictionary from which we need a certain value to assign to the other dict
    "a": 1,
    "b": {
        "c": 2,
        "d": {
            "e": 3,
            "f": 4
        },
        "x": 100
    }
    }

在此示例中，我需要将"f"中的d2的值分配给"c"中的键d1。

当然，这可以通过如下方式手动重新分配值来轻松实现：

d1["b"]["c"] = d2["b"]["d"]["f"]

但是，我想要的是能够更灵活地执行此操作，而无需使用上面的表达式，因为每个字典的深度并不总是相同，并且对于不同的请求，我需要的键可能位于不同的级别。 / p>

我希望能够将两个字典都需要的元素的键层次结构作为字符串传递，并让函数动态地处理其余部分。

类似这样的东西：

def depends_on(to_change, to_retrieve):
    # the logic

depends_on("b, c", "b, d, f") # This should assign the value of "f" to the value of "c"

有可能实现这一目标吗？我找不到一种动态生成数量众多的字典选择器的方法。

Answer 1

我对这个问题的看法（递归）：

d1 = {    
    "a": 1,
    "b": {
        "c": 2,
        "d": {
            "e": 3,
            "f": 4
        }
    }
    }

d2 = {    
    "a": 1,
    "b": {
        "c": 2,
        "d": {
            "e": 3,
            "f": 4
        },
        "x": 100
    }
}

def find_key(key, d, to_change=None):
    current_key = key[0]

    if current_key in d:
        if not key[1:]:
            if to_change:
                d[current_key] = to_change
            return d[current_key]

        return find_key(key[1:], d[current_key], to_change=to_change)

def depends_on(v1, v2, d1, d2):
    k1 = find_key(v1, d1)
    find_key(v2, d2, to_change=k1)

depends_on(('b', 'c'), ('b', 'd', 'f'), d1, d2)
print(d2)

打印：

{'a': 1, 'b': {'c': 2, 'd': {'e': 3, 'f': 2}, 'x': 100}}

功能depends_on(v1, v2, d1, d2)：

v1 => key from dict d1 
v2 => key from dict d2 
d1 => dict that the value is from 
d2 => dict that needs to be updated

动态将具有特定深度的字典值分配给具有不同深度的另一字典的键

1 个答案: