优化Pandas DataFrame层级构建性能：20万条数据提速方案

针对Filter列非空行生成层级路径的需求，原递归方案在大数据量下效率低下，以下是几个实用的提速优化方案：

1. 预构建映射字典+迭代遍历（通用高效） #

递归会带来栈开销和重复查找问题，先把ID与对应的父ID、文本预存为字典，再通过迭代向上追溯路径，避免递归的性能损耗。

import pandas as pd

# 预构建ID到(ParentID, Text)的映射字典，O(n)时间
id_to_parent_text = df.set_index('ID')[['ParentID', 'Text']].to_dict('index')

def build_hierarchy(row):
    path_components = [row['Text']]
    current_parent = row['ParentID']
    # 迭代向上查找直到根节点（ParentID=0）
    while current_parent != 0:
        parent_data = id_to_parent_text[current_parent]
        path_components.append(parent_data['Text'])
        current_parent = parent_data['ParentID']
    # 反转后拼接成路径
    return '/'.join(reversed(path_components))

# 仅对Filter非空的行执行路径生成，减少计算量
df.loc[df['Filter'].notna(), 'Hierarchy'] = df[df['Filter'].notna()].apply(build_hierarchy, axis=1)

这个方案的核心是把每次父节点查找从O(n)降到O(1)，迭代比递归更适合大规模数据，还能避免栈溢出风险。

2. 用NetworkX构建图批量生成路径（适合复杂层级） #

把数据视为树状有向图，利用NetworkX优化后的图遍历算法一次性生成所有节点的路径，尤其适合层级较深、结构复杂的场景。

import networkx as nx

# 构建有向边：ParentID -> ID
hierarchy_graph = nx.DiGraph()
for _, row in df.iterrows():
    if row['ParentID'] != 0:
        hierarchy_graph.add_edge(row['ParentID'], row['ID'])

# 先找到根节点（ParentID=0的节点）
root_id = df[df['ParentID'] == 0]['ID'].iloc[0]

def get_full_path(node_id):
    # 获取从根到当前节点的唯一路径
    node_path = nx.shortest_path(hierarchy_graph, source=root_id, target=node_id)
    # 拼接路径对应的文本
    return '/'.join([id_to_parent_text[pid]['Text'] for pid in node_path])

# 为Filter非空行生成层级路径
df.loc[df['Filter'].notna(), 'Hierarchy'] = df[df['Filter'].notna()]['ID'].apply(get_full_path)

NetworkX的底层实现经过优化，批量处理层级路径的效率比手动迭代更高，尤其是当数据中存在大量重复的父节点时。

3. 矢量化多层Merge（适用于固定层级深度） #

如果你的数据层级深度是固定的（比如最多3层），可以用Pandas的merge操作逐层拼接文本，完全避免循环，达到最快的处理速度。

# 初始：仅保留需要处理的行，初始Hierarchy为自身Text
target_df = df[df['Filter'].notna()].copy()
target_df['Hierarchy'] = target_df['Text']

# 第一层父节点拼接
target_df = target_df.merge(
    df[['ID', 'Text']],
    left_on='ParentID',
    right_on='ID',
    suffixes=('', '_parent'),
    how='left'
)
target_df['Hierarchy'] = target_df['Text_parent'] + '/' + target_df['Hierarchy']
target_df = target_df.drop(columns=['ID_parent', 'Text_parent'])

# 第二层祖父节点拼接（如果有），以此类推直到根节点
# target_df = target_df.merge(...)

矢量化操作是Pandas的性能天花板，没有Python循环的开销，但仅适用于层级深度固定的场景，无法处理动态深度的层级结构。

4. Dask分块处理（内存受限场景） #

如果20万行数据导致内存压力过大，可以用Dask DataFrame分块并行处理，逻辑与Pandas一致，但能利用多进程和分块加载，避免内存溢出。

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