查找层级股东关系：重构Python中的嵌套循环与条件判断

问题背景 #

需要查询公司间的层级股东关系，例如：

• 'Person 1'直接持有'Company 1'50%的股份
• 'Company 1'持有'Company 2'50%股份，'Company 2'又持有'Company 3'20%股份，因此'Person 1'间接持有'Company 2'25%、'Company 3'5%的股份
  期望输出完整的层级持股关系，但现有代码采用硬编码的多层嵌套循环，无法适配不确定的层级深度。

现有代码 #

companies = {
    'Company 1': {
        'Person 1': 0.5,
        'Person 2': 0.3,
        'Person 3': 0.2,
    },
    'Company 2': {
        'Person 4': 0.25,
        'Company 1': 0.5,
        'Person 5': 0.25,
    },
    'Company 3': {
        'Person 5': 0.6,
        'Person 6': 0.2,
        'Company 2': 0.2,
    },
}

def is_shareholder_in_company(company, companies, shareholder_name):
    company_shareholders = companies[company]

    for shareholder, ownership_percentage in company_shareholders.items():
        if shareholder_name == shareholder:
            print(company, ':',shareholder, ',', ownership_percentage)
            return True

for i in companies:
    if is_shareholder_in_company(i, companies, 'Person 1'):
        temp_name = i
        for j in companies:
            if is_shareholder_in_company(j, companies, i):
                temp_name = j
                for x in companies:
                    if is_shareholder_in_company(x, companies, j):
                        temp_name = x

重构方案 #

硬编码嵌套的核心问题是无法处理动态层级，我们可以用**递归（深度优先）或广度优先搜索（BFS，迭代方式）**来遍历所有层级，同时计算间接持股比例。

方案1：递归遍历（深度优先） #

通过递归不断查找当前主体（个人/公司）直接持股的公司，累计间接持股比例，直到没有下一层级为止。

companies = {
    'Company 1': {
        'Person 1': 0.5,
        'Person 2': 0.3,
        'Person 3': 0.2,
    },
    'Company 2': {
        'Person 4': 0.25,
        'Company 1': 0.5,
        'Person 5': 0.25,
    },
    'Company 3': {
        'Person 5': 0.6,
        'Person 6': 0.2,
        'Company 2': 0.2,
    },
}

def find_hierarchical_ownership(shareholder, current_percent, path, companies):
    # 输出当前持股路径与比例
    print(" -> ".join(path), f": {current_percent * 100:.1f}%")
    
    # 遍历所有公司，查找当前主体直接持股的对象
    for company, shareholders in companies.items():
        if shareholder in shareholders:
            direct_percent = shareholders[shareholder]
            # 计算间接持股比例：当前比例 × 直接持股比例
            new_percent = current_percent * direct_percent
            new_path = path + [company]
            # 递归查询下一层级
            find_hierarchical_ownership(company, new_percent, new_path, companies)

# 启动查询：Person1的初始持股比例为100%（自身），路径从自身开始
find_hierarchical_ownership('Person 1', 1.0, ['Person 1'], companies)

方案2：广度优先搜索（BFS，迭代方式） #

如果担心递归深度过大（比如层级极多），可以用迭代式的BFS，用队列存储每一层的节点信息，避免栈溢出问题。

from collections import deque

companies = {
    'Company 1': {
        'Person 1': 0.5,
        'Person 2': 0.3,
        'Person 3': 0.2,
    },
    'Company 2': {
        'Person 4': 0.25,
        'Company 1': 0.5,
        'Person 5': 0.25,
    },
    'Company 3': {
        'Person 5': 0.6,
        'Person 6': 0.2,
        'Company 2': 0.2,
    },
}

def find_hierarchical_ownership_bfs(start_shareholder, companies):
    # 队列元素：(当前主体, 累计持股比例, 路径列表)
    queue = deque()
    queue.append((start_shareholder, 1.0, [start_shareholder]))
    
    while queue:
        current_entity, current_percent, path = queue.popleft()
        print(" -> ".join(path), f": {current_percent * 100:.1f}%")
        
        # 查找当前主体直接持股的公司
        for company, shareholders in companies.items():
            if current_entity in shareholders:
                direct_percent = shareholders[current_entity]
                new_percent = current_percent * direct_percent
                new_path = path + [company]
                queue.append((company, new_percent, new_path))

# 启动BFS查询
find_hierarchical_ownership_bfs('Person 1', companies)

输出结果 #

运行上述代码后，会输出完整的层级持股关系：

Person 1 : 100.0%
Person 1 -> Company 1 : 50.0%
Person 1 -> Company 1 -> Company 2 : 25.0%
Person 1 -> Company 1 -> Company 2 -> Company 3 : 5.0%

重构优势 #

• 自动适配任意深度的层级关系，不再依赖硬编码的嵌套层数
• 同步计算并输出间接持股的实际比例，更贴合业务需求
• 代码结构清晰，可维护性与扩展性更强

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