Python json的深度排序列表（深度嵌套）-json具有重复的键

我正在尝试对一个json列表进行深度排序，该列表可以递归嵌套，其中json可以有重复的键，并且json中没有特定的键进行排序

输入：

{"payload": [
  {
    "a": {
      "aa": [
        {
          "aa12": {
            "aaa23": 230,
            "aaa21": 210,
            "aaa.something": "yes"
          }
        },
        {
          "aa11": {
            "aaa12": 120,
            "aaa11": 110
          }
        },
        {
          "aa13": {
            "aaa35": 350,
            "aaa32": 320,
            "aaa.someattr": "true"
          }
        }
      ],
      "aa": [
        {
          "aa12": {
            "aaa22": 22,
            "aaa21": 21
          }
        },
        {
          "aa10": {
            "aaa03": 3,
            "aaa01": 1
          }
        },
        {
          "aa13": {
            "aaa33": 33,
            "aaa32": 32
          }
        },
        {
          "aa1": "aab"
        }
      ],
      "ac": [
        "ac3",
        "ac1",
        "ac2"
      ]
    }
  },
  {
    "b": {
      "bb": [
        "bb4",
        "bb2",
        "bb3",
        "bb1"
      ]
    }
  }
]}

{"payload": [
  {
    "a": {
      "aa": [
        {
          "aa1": "aab"
        },
        {
          "aa10": {
            "aaa01": 1,
            "aaa03": 3
          }
        },
        {
          "aa12": {
            "aaa21": 21,
            "aaa22": 22
          }
        },
        {
          "aa13": {
            "aaa32": 32,
            "aaa33": 33
          }
        }
      ],
      "aa": [
        {
          "aa11": {
            "aaa11": 110,
            "aaa12": 120
          }
        },
        {
          "aa12": {
            "aaa.something": "yes"
            "aaa21": 210,
            "aaa23": 230
          }
        },
        {
          "aa13": {
            "aaa.someattr": "true",
            "aaa32": 320,
            "aaa35": 350
          }
        }
      ],
      "ac": [
        "ac1",
        "ac2",
        "ac3"
      ]
    }
  },
  {
    "b": {
      "bb": [
        "bb1",
        "bb2",
        "bb3",
        "bb4"
      ]
    }
  }
]}

预期输出：

{"payload": [
  {
    "a": {
      "aa": [
        {
          "aa12": {
            "aaa23": 230,
            "aaa21": 210,
            "aaa.something": "yes"
          }
        },
        {
          "aa11": {
            "aaa12": 120,
            "aaa11": 110
          }
        },
        {
          "aa13": {
            "aaa35": 350,
            "aaa32": 320,
            "aaa.someattr": "true"
          }
        }
      ],
      "aa": [
        {
          "aa12": {
            "aaa22": 22,
            "aaa21": 21
          }
        },
        {
          "aa10": {
            "aaa03": 3,
            "aaa01": 1
          }
        },
        {
          "aa13": {
            "aaa33": 33,
            "aaa32": 32
          }
        },
        {
          "aa1": "aab"
        }
      ],
      "ac": [
        "ac3",
        "ac1",
        "ac2"
      ]
    }
  },
  {
    "b": {
      "bb": [
        "bb4",
        "bb2",
        "bb3",
        "bb1"
      ]
    }
  }
]}

{"payload": [
  {
    "a": {
      "aa": [
        {
          "aa1": "aab"
        },
        {
          "aa10": {
            "aaa01": 1,
            "aaa03": 3
          }
        },
        {
          "aa12": {
            "aaa21": 21,
            "aaa22": 22
          }
        },
        {
          "aa13": {
            "aaa32": 32,
            "aaa33": 33
          }
        }
      ],
      "aa": [
        {
          "aa11": {
            "aaa11": 110,
            "aaa12": 120
          }
        },
        {
          "aa12": {
            "aaa.something": "yes"
            "aaa21": 210,
            "aaa23": 230
          }
        },
        {
          "aa13": {
            "aaa.someattr": "true",
            "aaa32": 320,
            "aaa35": 350
          }
        }
      ],
      "ac": [
        "ac1",
        "ac2",
        "ac3"
      ]
    }
  },
  {
    "b": {
      "bb": [
        "bb1",
        "bb2",
        "bb3",
        "bb4"
      ]
    }
  }
]}

我已尝试使用以下递归方法：

ls = {'payload': [{'a': {'aa': [{'aa12': {'aaa23': 230, 'aaa21': 210}}, {'aa11': {'aaa12': 120, 'aaa11': 110}}, {'aa13': {'aaa35': 350, 'aaa32': 320}}], 'ac': ['ac3', 'ac1', 'ac2'], 'aa': [{'aa12': {'aaa22': 22, 'aaa21': 21}}, {'aa10': {'aaa03': 3, 'aaa01': 1}}, {'aa13': {'aaa33': 33, 'aaa32': 32}}, {'aa1': 'aab'}]}}, {'b': {'bb': ['bb4', 'bb2', 'bb3', 'bb1']}}]}
output = sorted_deep(ls)
print(output)

def sorted_deep(d):
  if isinstance(d,list):
    return sorted(sorted_deep(v) for v in d)
  if isinstance(d,dict):
    return {k: sorted_deep(d[k]) for k in sorted(d)}
  return d

但这不起作用。排序时，它将用最后找到的值覆盖重复键的值。由于重复键可以是任何字符串，因此不能通过指定键名进行迭代。 我正在寻找一个通用的解决方案，它可以对任何给定的json复杂列表进行排序——使用嵌套列表/json

我的最终目标是对2个这样的JSON进行深度匹配以找出差异。

考虑使用sorted（）

阅读有关排序和lambda的信息

---

使用lambda，您可以访问子元素以进行更深入的操作，您可能需要一个for，另一个带有排序的

JSON

的lambda引用一个字符串。这是一根绳子吗？不管它是什么，它都是无效的：它以

{

开始，以

]

@Booboo结束。我现在已经更正了JSON格式。这并不是回答你的问题，而是你的最终目标。差异查找算法很慢。如果你在生产环境中的成千上万条生产线上运行它，它甚至会更慢（如果你正在计划）。与其重新设计代码，我建议使用此-@MohitRustagi：感谢diff match修补程序库。但是，在比较复杂的JSON之前，它不会进行排序。当存在列表的dict of list（进一步嵌套）时，这将产生不正确的结果@SameerMirji，仅供参考，上一次编辑后，由于括号不匹配，最后一个代码块引发语法错误。我已经在使用

sorted（）

方法。但我不能立即使用lambda函数，因为键名不是固定的。您可以创建一些值，如键ar not fixed change value='eventDate'I[value]由于JSON太大太复杂，添加另一个键值不是可行的解决方案。