Python实现按多动态键排序字典列表，将None值置于末尾

问题描述 #

需要对包含嵌套字典的字典列表dict_list，按照指定的键列表groups进行排序，字典中的值可能为None，要求排序后所有None值对应的项置于末尾。

示例输入 #

groups = ["key1", "key3.key4"]
dict_list = [
    {
        "key1": "abc",
        "key2": "def",
        "key3": {
            "key4": "ghi"
        },
        "key5": {
            "key6": "uvw"
        }
    }, 
    {
        "key1": "abc",
        "key2": "asd",
        "key3": {
            "key4": "abc"
        },
        "key5": {
            "key6": "uvw"
        }
    },    
    {
        "key1": None,
        "key2": "asd",
        "key3": {
            "key4": "abc"
        },
        "key5": {
            "key6": "uvw"
        }
    },
    {
        "key1": "abc",
        "key2": None,
        "key3": None,
        "key5": {
            "key6": "uvw"
        }
    },
    {
        "key1": "xyz",
        "key2": None,
        "key3": {
            "key4": "jklm"
        },
        "key5": {
            "key6": "uvw"
        }
    },
    {
        "key1": "abc",
        "key2": "dfd",
        "key3": {
            "key4": "ghi"
        },
        "key5": {
            "key6": "ers"
        }
    }
]

期望输出 #

dict_list = [
    {
        "key1": "abc",
        "key2": "asd",
        "key3": {
            "key4": "abc"
        },
        "key5": {
            "key6": "uvw"
        }
    },
    {
        "key1": "abc",
        "key2": "def",
        "key3": {
            "key4": "ghi"
        },
        "key5": {
            "key6": "uvw"
        }
    },
    {
        "key1": "abc",
        "key2": "dfd",
        "key3": {
            "key4": "ghi"
        },
        "key5": {
            "key6": "ers"
        }
    },
    {
        "key1": "abc",
        "key2": None,
        "key3": None,
        "key5": {
            "key6": "uvw"
        }
    },
    {
        "key1": "xyz",
        "key2": None,
        "key3": {
            "key4": "jklm"
        },
        "key5": {
            "key6": "uvw"
        }
    },
    {
        "key1": None,
        "key2": "asd",
        "key3": {
            "key4": "abc"
        },
        "key5": {
            "key6": "uvw"
        }
    }
]

解决方案 #

核心思路分为两步：

1. 实现一个函数，能够从嵌套字典中根据点分隔的键路径（如key3.key4）获取对应的值，遇到不存在的键或None时返回None。
2. 自定义排序的key：对于每个排序键，生成一个元组(值是否为None, 值)，利用布尔值True（对应None）大于False的特性，让None值项自动排在末尾；非None值则按自身大小排序。

代码实现 #

def get_nested_value(data, key_path):
    """从嵌套字典中获取点分隔键路径对应的值"""
    keys = key_path.split('.')
    current = data
    for key in keys:
        if current is None or not isinstance(current, dict) or key not in current:
            return None
        current = current[key]
    return current

def sort_dict_list(dict_list, groups):
    """按指定键列表排序字典列表，None值置于末尾"""
    dict_list.sort(key=lambda x: tuple(
        (val is None, val) for val in (get_nested_value(x, key) for key in groups)
    ))

# 测试示例
groups = ["key1", "key3.key4"]
dict_list = [
    {
        "key1": "abc",
        "key2": "def",
        "key3": {
            "key4": "ghi"
        },
        "key5": {
            "key6": "uvw"
        }
    }, 
    {
        "key1": "abc",
        "key2": "asd",
        "key3": {
            "key4": "abc"
        },
        "key5": {
            "key6": "uvw"
        }
    },    
    {
        "key1": None,
        "key2": "asd",
        "key3": {
            "key4": "abc"
        },
        "key5": {
            "key6": "uvw"
        }
    },
    {
        "key1": "abc",
        "key2": None,
        "key3": None,
        "key5": {
            "key6": "uvw"
        }
    },
    {
        "key1": "xyz",
        "key2": None,
        "key3": {
            "key4": "jklm"
        },
        "key5": {
            "key6": "uvw"
        }
    },
    {
        "key1": "abc",
        "key2": "dfd",
        "key3": {
            "key4": "ghi"
        },
        "key5": {
            "key6": "ers"
        }
    }
]

sort_dict_list(dict_list, groups)

# 打印验证结果
import pprint
pprint.pprint(dict_list)

代码说明 #

• get_nested_value：拆分键路径，逐层遍历字典，处理嵌套结构和中途出现的None或不存在的键，确保最终返回正确值或None。
• sort_dict_list：利用列表的sort方法，自定义key为元组，每个元素是(是否为None, 值)的组合。元组排序会依次比较每个元素，因此先按是否为None排序（False在前，True在后），再按值本身排序，完美满足需求。

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