如何在python中對深度嵌套的字典中的所有列表進行排序？

Question

我想對深度嵌套的字典中的所有列表進行排序。 它基本上是一個 JSON 對象，它在列表中深度嵌套字典，然后在字典中列出。 我想要做的就是解析所有字典鍵到所有葉節點，並對我在途中遇到的所有列表進行排序。 基本上，任何直接可用或在該給定字典對象內部深處的列表都應該被排序，並且應該返回具有所有排序列表的相同字典。

我嘗試對 dict 對象進行遞歸，以將遇到的任何 dict 對象傳遞給遞歸方法，並在遇到時對列表進行排序。 但是當列表中有一個 dict 並且該 dict 對象中有另一個列表時，它們無法產生結果。

下面的示例 JSON：

my_json = {
  a: {
    b: {
      c: [
        {
          d: [
            { f: 'some_string' }
          ]
        },
        {
          e: {
            g: [
              h: 'another string'
            ]
          }
        }
      ]
    }
  }
  z: [
    b: {
      c: [
        {
          d: [
            { f: 'some_string1' }
          ]
        },
        {
          e: {
            g: [
              h: 'another string1'
            ]
          }
        }
      ]
    },
    x: {
      c: [
        {
          d: [
            { f: 'some_string2' }
          ]
        },
        {
          e: {
            g: [
              h: 'another string2'
            ]
          }
        }
      ]
    }
  ]
}

def gen_dict_extract(input_dict):
  result_obj = input_dict;
  if hasattr(var, 'iteritems'):
    for k, v in var.iteritems():
      if isinstance(v, dict):
        for result in gen_dict_extract(v):
          yield result
      elif isinstance(v, list):
        v.sort();
        for d in v:
          for result in gen_dict_extract(d):
            yield result

輸出期望只是對所有列表進行排序，而不管它們位於何處。 我什至可以對字典中的每個項目進行排序，但我需要列表排序。

這里以一個較小的例子來解釋輸出：

old_json = {
    'x': [
        {
            'z': {
                'y': ['agsd', 'xef', 'sdsd', 'erer']
            }
        },
        {
            's': {
                'f': 'ererer',
                'd': [5, 6, 2, 3, 1]
            }
        }
    ]
}

new_json = {
    'x': [
        {
            's': {
                'f': 'ererer',
                'd': [1, 2, 3, 5, 6]
            }
        },
        {
            'z': {
                'y': ['agsd', 'erer', 'sdsd','xef']
            }
        }
    ]
}

Something like above.

Answer 1

如果您希望輸出是不同的字典（即不對原始字典進行排序），則該函數應如下編寫：

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

通過這種方式，您可以像使用內置 sorted() 函數一樣使用 sortedDeep()：

new_json = sortedDeep(old_json)

[編輯] 改進的版本，它還可以根據嵌入對象的最小鍵/值對字典列表（或列表列表）進行排序：

def sortedDeep(d):
    def makeTuple(v): return (*v,) if isinstance(v,(list,dict)) else (v,)
    if isinstance(d,list):
        return sorted( map(sortedDeep,d) ,key=makeTuple )
    if isinstance(d,dict):
        return { k: sortedDeep(d[k]) for k in sorted(d)}
    return d

Answer 2

我相信這里的代碼片段可以完成對嵌套字典進行排序的工作。

def nested_sort(d:dict):
    for v in d.values():
        if isinstance(v,dict):
            nested_sort(v)
        elif isinstance(v,list):
            v.sort()

但是，我無法測試代碼，因為您提供的示例不是合法的 JSON 格式或合法的 Python 字典。