替换嵌套列表和字典的字典中的项目

Question

是否有任何解决方案，在一个特定的值来代替项目dict嵌套列表，而在python类型的字典？

例如：

输入：

item_to_be_replaced =  'a'

replaced_with = 'z'

di = {"a": "A", "b": "B", "c": [2, 4, 6, {"a": "A", "b": "B"}], "d": {"a": [2, 4, 6], "b": [5, 2, 1]}}

输出：

{"z": "A", "b": "B", "c": [2, 4, 6, {"z": "A", "b": "B"}], "d": {"z": [2, 4, 6], "b": [5, 2, 1]}}

哪个是解决这个问题的最佳方法？

Answer 1

我不认为它是最好的选择，但是当我看到这个时，我想到了这个答案：

import json
json.loads(json.dumps(di).replace(f'"{item_to_be_replaced}"', f'"{replaced_with}"'))

简单转换成字符串，替换我需要替换的东西，然后回到dict

Answer 2

一个递归函数，它创建一个新的嵌套字典，用不同的值替换一个键值

def replace_key(elem, old_key, new_key):
    if isinstance(elem, dict):
        # nested dictionary
        new_dic = {}
        for k, v in elem.items():
            if isinstance(v,dict) or isinstance(v, list):
                new_dic[replace_key(k, old_key, new_key)] = replace_key(v, old_key, new_key)
            else:
                new_dic[replace_key(k, old_key, new_key)] = v

        return new_dic

    elif isinstance(elem, list):
        # nested list
        return [replace_key(t, old_key, new_key) for t in elem]

    else:
        return elem


di = {"a": "A", "b": "B", "c": [2, 4, 6, {"a": "A", "b": "B"}], "d": {"a": [2, 4, 6], "b": [5, 2, 1]}}

print(replace_key(di, 'a', 'z'))

输出

{'z': 'A', 'c': [2, 4, 6, {'z': 'A', 'b': 'B'}], 'd': {'z': [2, 4, 6], 'b': [5, 2, 1]}, 'b': 'B'}

**性能比较（使用 Jupyter Notebook）**

结果：ComplicatedPhenomenon post 的最快时间是其他两种方法的 10 倍。

1. Reznik Post--JSON 加载替换

   %timeit json.loads(json.dumps(di).replace('a', 'z'))

每个循环 23.6 µs ± 2.05 µs（7 次运行的平均值 ± 标准偏差，每次 10000 次循环）

2. DarrylG--递归函数

%timeit replace_key(di, 'a', 'z')

每个循环 20.1 µs ± 424 ns（7 次运行的平均值 ± 标准偏差，每次 100000 次循环）

3. ComplicatedPhenomenon Post--专门针对特定结构

%%timeit
d = {"a": "A", "b": "B", "c": [2, 4, 6, {"a": "A", "b": "B"}], "d": {"a": [2, 4, 6], "b": [5, 2, 1]}}
d['z'] = d.pop('a')           
d['d']['z'] = d['d'].pop('a')      
d['c'][3]['z'] = d['c'][3].pop('a') 

每个循环 2.03 µs ± 211 ns（7 次运行的平均值 ± 标准偏差，每次 100000 次循环）