Azure Function+Python多层嵌套JSON占位符替换方案咨询

问题背景 #

在Azure Function里用Python处理层级3到10层以上的嵌套JSON，核心需求是替换像placeholder_a这类字符串占位符。之前尝试递归遍历JSON，但修改的只是副本，没法同步到原结构；纠结直接字符串替换（怕误改键名）和递归重建JSON两种方案，想要找个靠谱的实现方式。

传入的JSON示例 #

[{
  "node1": {
    "tattr": {
      "usqx": "qhi123"
    },
    "x-child": [{
      "el1": "ast",
      "tattr": {
        "usx": "xht",
        "ust": "cr12"
      },
      "x-child": [{
        "el1": "asx",
        "tattr": {
          "usx": "md0"
        },
        "x-child": [{
          "el1": "ast",
          "tattr": {
            "usx": "mdw"
          },
          "x-child": [{
            "el1": "ast",
            "tattr": {
              "usx": "mdh"
            },
            "x-child": [{
              "el1": "ast",
              "x-child": "placeholder_a"
            }]
          }, {
            "el1": "ast",
            "tattr": {
              "usx": "ssq"
            },
            "x-child": "placeholder_c"
          }, {
            "el1": "div",
            "tattr": {
              "usx": "mdf"
            },
            "x-child": "abc"
          }]
        }]
      }]
    }]
  }
}, {
  "node02": {
    "tattr": {
      "usx": "qhi123"
    }
  }
}]

当前错误代码 #

def lin(json_para,search_para,replace_para):
    json_decoded = json.loads(json_para)
    if isinstance(json_decoded,list):
        for list_element in json_decoded:
            lin(json.dumps(list_element))
    elif isinstance(json_decoded,dict):
        for dict_element in json_decoded:
            if isinstance(json_decoded[dict_element],dict):
                lin(json.dumps(json_decoded[dict_element]))
            elif isinstance(json_decoded[dict_element],str):
                if str(json_decoded[dict_element]) == 'search_para:
                    json_decoded[dict_element] = replace_para

错误代码问题点 #

1. 递归时创建了副本：每次把子元素转成JSON字符串再解析，等于生成了新对象，修改的是副本而非原JSON的引用，所以原结构根本没变。
2. 参数传递遗漏：递归调用lin时没传search_para和replace_para，函数根本没法执行替换逻辑。
3. 语法错误：字符串比较时写成了'search_para:，缺了闭合引号，而且应该用变量search_para，不是硬编码的字符串。
4. 列表处理不到位：遍历列表元素时直接转字符串，没对列表里的字典/子列表做递归处理。

最优实现：递归原地修改 #

利用Python中字典、列表是可变对象的特性，直接操作引用就能修改原结构，不用重建整个JSON，效率高还不会误改。

修正后的递归函数 #

def replace_placeholders(data, search_str, replace_str):
    # 处理列表类型
    if isinstance(data, list):
        for i in range(len(data)):
            item = data[i]
            if isinstance(item, (dict, list)):
                # 递归处理嵌套的列表/字典
                replace_placeholders(item, search_str, replace_str)
            elif isinstance(item, str) and item == search_str:
                # 匹配到占位符就替换
                data[i] = replace_str
    # 处理字典类型
    elif isinstance(data, dict):
        for key, value in data.items():
            if isinstance(value, (dict, list)):
                replace_placeholders(value, search_str, replace_str)
            elif isinstance(value, str) and value == search_str:
                data[key] = replace_str

在Azure Function中的使用示例 #

import json
import azure.functions as func

def main(req: func.HttpRequest) -> func.HttpResponse:
    try:
        # 解析传入的JSON
        req_body = req.get_json()
        # 执行占位符替换
        replace_placeholders(req_body, "placeholder_a", "replaced_value_a")
        replace_placeholders(req_body, "placeholder_c", "replaced_value_c")
        # 返回处理后的JSON
        return func.HttpResponse(
            json.dumps(req_body),
            mimetype="application/json",
            status_code=200
        )
    except Exception as e:
        return func.HttpResponse(f"Error processing JSON: {str(e)}", status_code=400)

方案优势 #

• 高效省内存：原地修改原对象，不用复制整个嵌套结构，深层场景下性能更优。
• 精准安全：只匹配字符串类型的占位符值，不会误改键名或其他非目标内容。
• 覆盖所有层级：递归逻辑能处理任意深度的列表和字典嵌套，不用担心漏处理。

为什么不推荐直接字符串替换 #

• 误改风险高：如果某个键名里包含占位符（比如"placeholder_a_key": "value"），字符串替换会把键名也改掉。
• 兼容性差：如果占位符出现在非字符串值里（比如数字、布尔值），字符串替换会失效甚至破坏JSON结构。
• 性能劣势：大型JSON的字符串替换比操作Python对象慢很多。

内容的提问来源于stack exchange，提问作者Joe Platano