如何对可迭代对象中的所有嵌套可迭代对象进行递归排序？

要实现对嵌套可迭代对象的全递归排序，我们需要遍历每个层级的结构，分别处理字典（按键排序）和列表（元素递归处理后排序），同时对嵌套的子结构重复这个过程。以下是一个Python实现方案：

实现代码 #

def recursive_sort(item):
    # 处理字典：按键排序，值递归排序
    if isinstance(item, dict):
        # 先对键排序，再递归处理每个值
        sorted_items = sorted(item.items(), key=lambda x: x[0])
        return {k: recursive_sort(v) for k, v in sorted_items}
    # 处理列表：先递归处理每个元素，再对元素排序
    elif isinstance(item, list):
        # 先递归处理所有元素
        processed_items = [recursive_sort(i) for i in item]
        # 定义辅助函数，将嵌套结构转为可比较的元组
        def get_sort_key(element):
            if isinstance(element, dict):
                return tuple(sorted(element.items()))
            elif isinstance(element, list):
                return tuple(get_sort_key(i) for i in element)
            else:
                return element
        # 用辅助函数生成的key来排序列表
        return sorted(processed_items, key=get_sort_key)
    # 基本类型直接返回
    else:
        return item

# 测试示例输入
d = { 'e': [{'y': 'y'}, {'x': [{'2': 2, '1': 1}]}], 'x': ['c', 'b', 'a'], 'z': { 'a': [3, 1, 2], 'd': [{'y': [6,5,1]}, {'w': 1}], 'c': {'2': 2, '3': 3, '4': 4} }, 'w': {1:1, 2:2, 3:3} }
sorted_d = recursive_sort(d)
print(sorted_d)

代码解释 #

• 字典处理：首先提取字典的键值对，按键排序后，对每个值递归调用recursive_sort，最后重新构建有序字典（Python3.7+原生字典保留插入顺序，所以排序后的键会按顺序存储）。
• 列表处理：先对列表中的每个元素递归排序，然后通过get_sort_key函数将嵌套结构（比如字典、子列表）转换为可比较的元组——因为字典本身不能直接比较大小，转成排序后的键值对元组后就能按规则排序了。最后用这个key对处理后的列表进行排序。
• 基本类型：像整数、字符串这类不可迭代的基本类型，直接返回原值即可。

输出验证 #

运行代码后，输出结果和你期望的完全一致：

{'e': [{'x': [{'1': 1, '2': 2}]}, {'y': 'y'}], 'w': {1: 1, 2: 2, 3: 3}, 'x': ['a', 'b', 'c'], 'z': {'a': [1, 2, 3], 'c': {'2': 2, '3': 3, '4': 4}, 'd': [{'w': 1}, {'y': [1, 5, 6]}]}}

需要注意的是，这个实现假设所有列表元素都可以通过get_sort_key转换为可比较的类型，如果你的场景中有更复杂的自定义类型，可能需要扩展get_sort_key的逻辑来适配。

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