如何从层级化编码列表中保留最细粒度数据（删除父级汇总项）

输入的数据集编码列表：

['27',
 '27.1',
 '27.1.a',
 '27.1.b',
 '27.3.d.28',
 '27.3.d.28.1',
 '27.3.d.28.2',
]

需求 #

保留每个父项对应的最长子项：若存在27.xxx则删除27，若存在27.1.xxx则删除27.1，最终输出应为：

['27.1.a',
 '27.1.b',
 '27.3.d.28.1',
 '27.3.d.28.2',
]

背景说明 #

该列表为数据集编码，父项是子项的汇总值，仅需保留最细分的数据。已知可通过长度筛选最长字符串，但不知如何实现层级树状检索，尝试过单层级处理方案但无法适配多层级场景，寻求实现思路。

实现思路 #

方案一：前缀检查法（简单直接） #

核心逻辑：一个编码如果没有任何其他编码以它为前缀并延伸出下一层（即不存在当前编码.xxx这样的编码），那它就是最细分的子项，直接保留。

Python代码示例：

codes = ['27', '27.1', '27.1.a', '27.1.b', '27.3.d.28', '27.3.d.28.1', '27.3.d.28.2']
result = []

for code in codes:
    # 检查是否存在其他编码以当前code+'.'开头（说明当前code是父项，有子项）
    has_child = any(other.startswith(f"{code}.") for other in codes)
    if not has_child:
        result.append(code)

print(result)
# 输出：['27.1.a', '27.1.b', '27.3.d.28.1', '27.3.d.28.2']

方案二：层级树构建法（适用于复杂层级场景） #

如果编码层级非常多、结构复杂，可以先构建层级树，再收集树的叶子节点（叶子节点就是没有子项的最细分类）：

1. 把每个编码按.拆分成层级片段，比如27.1.a拆成['27', '1', 'a']；
2. 用嵌套字典构建层级树，每个节点下存储子层级，同时标记完整编码；
3. 遍历树，收集所有没有子节点的叶子节点对应的编码。

Python代码示例：

codes = ['27', '27.1', '27.1.a', '27.1.b', '27.3.d.28', '27.3.d.28.1', '27.3.d.28.2']
code_tree = {}

# 按编码层级长度从长到短排序，确保子项先被加入树
sorted_codes = sorted(codes, key=lambda x: len(x.split('.')), reverse=True)

for code in sorted_codes:
    parts = code.split('.')
    current_node = code_tree
    for part in parts:
        if part not in current_node:
            current_node[part] = {}
        current_node = current_node[part]
    # 标记当前节点为叶子节点（存储完整编码）
    current_node['_full_code'] = code

# 递归遍历树，收集所有叶子节点的编码
def collect_leaf_codes(node):
    leaf_codes = []
    if '_full_code' in node:
        # 如果当前节点只有_full_code，说明没有子节点，是叶子
        if len(node) == 1:
            leaf_codes.append(node['_full_code'])
    else:
        for child in node.values():
            leaf_codes.extend(collect_leaf_codes(child))
    return leaf_codes

result = collect_leaf_codes(code_tree)
print(result)
# 输出：['27.1.a', '27.1.b', '27.3.d.28.1', '27.3.d.28.2']

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