如何遍历Python嵌套字典并实现员工层级信息查询函数？

需求描述 #

实现lookup_info函数，输入员工姓名（字符串）和多层嵌套的组织架构字典org_chart（键为员工姓名，值为None或子组织架构字典），输出该员工的领导类型、直接下属数量、总下属数量（直接+间接）。规则如下：

• 若员工对应的值不为None，则为leader（领导者）；否则为non-leader（非领导者）
• 直接下属：员工对应值字典的第一层键
• 总下属：嵌套字典中所有层级的下属员工总和

示例代码与输出 #

示例组织架构 #

ORG_CHART = {
    "chloe": {
        "mark": {
            "tim": {
                "varun": None,
                "misha": None
            }
        },
        "julie": None
    },
    "annie": {
        "jimmy": {
            "haily": None,
            "alex": None
        },
        "helen": {
            "miley": {
                "stella": {
                    "allie": None
                },
                "tom": None
            }
        }
    },
    "jenny": None
}

函数模板 #

def lookup_info(name, org_chart):
    # TODO
    return leadership_type, num_direct_reports, num_total_reports

预期输出 #

• 输入name="annie" → 输出："leader", 2, 8
• 输入name="tom" → 输出："non-leader", 0, 0
• 输入name="miley" → 输出："leader", 2, 3

问题分析 #

你尝试的递归代码存在两个核心问题：

1. 递归返回值未处理：深层递归找到目标员工后，结果没有向上传递，导致上层函数无法获取，最终返回None
2. 遍历逻辑冗余：不需要额外遍历子字典的items，直接递归传入子字典即可

关于遍历方式的选择：递归（DFS的一种实现）足够简洁，适合组织架构这种层级不会特别深的场景；如果担心递归栈溢出，也可以用BFS（队列实现）来遍历统计。

完整解决方案 #

步骤1：定位目标员工的子结构 #

先实现一个递归函数，遍历整个组织架构，找到目标员工对应的子结构（即字典中的值）：

def find_employee_node(name, org_chart):
    if not org_chart:
        return None
    for emp, sub_org in org_chart.items():
        if emp == name:
            return sub_org
        # 递归查找子组织架构
        result = find_employee_node(name, sub_org)
        if result is not None:
            return result
    return None

步骤2：统计总下属数量 #

用递归实现总下属统计，遍历所有嵌套层级的员工：

def count_total_subordinates(sub_org):
    if sub_org is None:
        return 0
    total = 0
    for emp, sub in sub_org.items():
        total += 1  # 统计当前直接下属
        total += count_total_subordinates(sub)  # 递归统计该下属的所有下属
    return total

步骤3：整合为最终函数 #

将上述辅助函数整合到lookup_info中，完成逻辑判断：

def lookup_info(name, org_chart):
    employee_node = find_employee_node(name, org_chart)
    
    # 处理员工不存在的情况（可选，根据需求调整）
    if employee_node is None:
        return "non-leader", 0, 0
    
    if employee_node is None:
        return "non-leader", 0, 0
    else:
        direct_reports = len(employee_node)
        total_reports = count_total_subordinates(employee_node)
        return "leader", direct_reports, total_reports

验证示例 #

# 测试annie的情况
print(lookup_info("annie", ORG_CHART))  # 输出: ('leader', 2, 8)
# 测试tom的情况
print(lookup_info("tom", ORG_CHART))    # 输出: ('non-leader', 0, 0)
# 测试miley的情况
print(lookup_info("miley", ORG_CHART))  # 输出: ('leader', 2, 3)

替代方案：BFS统计总下属 #

如果偏好迭代式的BFS实现，可将count_total_subordinates替换为：

def count_total_subordinates(sub_org):
    if sub_org is None:
        return 0
    total = 0
    queue = list(sub_org.values())
    total += len(sub_org)  # 先统计直接下属
    while queue:
        current = queue.pop(0)
        if current is not None:
            total += len(current)
            queue.extend(current.values())
    return total

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