如何在python中实现这种递归？

假设我有一本这样的字典

dict1 = [{
           'Name': 'Team1',
           'id': '1',
           'Members': [
                      {
                          'type': 'user',
                          'id': '11'
                      },
                      {
                          'type': 'user',
                          'id': '12' 
                      }
                      ]
        },
        {
            'Name': 'Team2',
            'id': '2',
            'Members': [
                         {
                            'type': 'group'
                            'id': '1'
                         },
                         {
                          'type': 'user',
                          'id': '21' 
                      }
                       ]
        },
        {
            'Name': 'Team3',
            'id': '3',
            'Members': [
                         {
                            'type': 'group'
                            'id': '2'
                         }
                       ]
        }]

我想得到一个输出，可以用所有不同的用户替换所有的组和嵌套组。 在这种情况下，输出应如下所示：

dict2 = [{
           'Name': 'Team1',
           'id': '1',
           'Members': [
                      {
                          'type': 'user',
                          'id': '11'
                      },
                      {
                          'type': 'user',
                          'id': '12' 
                      }
                      ]
        },
        {
            'Name': 'Team2',
            'id': '2',
            'Members': [
                         {
                           'type': 'user',
                           'id': '11'
                         },
                         {
                          'type': 'user',
                          'id': '12' 
                         }
                         {
                          'type': 'user',
                          'id': '21' 
                         }
                       ]
        },
        {
            'Name': 'Team3',
            'id': '3',
            'Members': [
                         {
                           'type': 'user',
                           'id: '11'
                         },
                         {
                          'type': 'user',
                          'id': '12' 
                         }
                         {
                          'type': 'user',
                          'id': '21' 
                         }
                       ]
        }]

现在让我们假设我有一个大的数据集来执行这些操作。（约2万个人组）

---

编写此代码的最佳方式是什么？我正在尝试递归，但我不确定如何以这种方式搜索字典和列表，这样它就不会占用太多内存。我认为您不需要递归。循环就足够了

我认为您可以简单地评估每个

成员

s，如果

组

类型为，则获取

用户

s，并使其唯一。然后，您只需将

成员的值替换为
不同的用户

您可能有一本字典用于以下组：

group_dict = { 
    '1': [
        {'type': 'user', 'id': '11'},
        {'type': 'user', 'id': '12'}
    ],  
    '2': [
        {'type': 'user', 'id': '11'},
        {'type': 'user', 'id': '12'},
        {'type': 'user', 'id': '21'}
    ],
    '3': [
        {'type': 'group', 'id': '1'},
        {'type': 'group', 'id': '2'},
        {'type': 'group', 'id': '3'}  # recursive
    ]
    ...   
}

您可以尝试：

def users_in_group(group_id):
    users = []
    groups_to_fetch = []
    for user_or_group in group_dict[group_id]:
        if user_or_group['type'] == 'group':
            groups_to_fetch.append(user_or_group)
        else:  # 'user' type
            users.append(user_or_group)
    
    groups_fetched = set()  # not to loop forever
    while groups_to_fetch:
        group = groups_to_fetch.pop()
        if group['id'] not in groups_fetched:
            groups_fetched.add(group['id'])
            for user_or_group in group_dict[group['id']]:
                if user_or_group['type'] == 'group' and user_or_group['id'] not in groups_fetched:
                    groups_to_fetch.append(user_or_group)
                else:  # 'user' type
                    users.append(user_or_group)

    return users


def distinct_users_in(members):
    distinct_users = []

    def add(user):
        if user['id'] not in user_id_set:
            distinct_users.append(user)
        user_id_set.add(user['id'])

    user_id_set = set()
    for member in members:
        if member['type'] == 'group':
            for user in users_in_group(member['id']):
                add(user)
        else:  # 'user'
            user = member
            add(user)

    return distinct_users


dict2 = dict1  # or `copy.deepcopy`
for element in dict2:
    element['Members'] = distinct_users_in(element['Members'])

每个
成员
由相应函数返回的
不同用户重新分配。
该函数获取
成员
并从每个if
成员
类型中获取用户。如果
用户
类型，
成员
本身就是用户。当（获取的）用户被附加到
distinct\u user
时，您可以使用他们的
id
s表示唯一性

获取组中的
用户时，可以使用两个列表<代码>组提取
和组提取
。前者是递归获取组中所有组的堆栈。后者不会再次获取已获取的组。或者，它可以永远循环

最后，如果您的数据已经在内存中，这种方法可能不会耗尽内存和工作。
这是json数据吗？递归/迭代可以。根据我的计算，即使有20000个组，ram的使用量也将保持在100mb以下。@pavel绝对不是JSON格式<代码>“

和变量。但是Python字典和JSON通常是互为可变的。@TanishqBanyal对Python有点不熟悉，我在尝试使用这些数据进行递归循环时总是遇到问题。我面临的主要问题是如何搜索字典和列表，以及如何创建最终的字典。。我想知道是否有一个链接/另一个qs（无法找到一个类似于我的qs）问我可以参考？@RohitJainani您的数据描述在语法上是错误的。它们是否包装为一个列表，例如，

dict1=[…]

？此实现是否仍适用于嵌套组？例如，在我上面的例子中，组3需要组2，其中包含组1，所以组3应该得到组1和组2的所有成员。@RohitJainani啊，这就是你考虑递归的原因？是的，因为数据集非常大，大约有20k个组，其中一些组有自己的子组，它们都有自己的等等。把它想象成一个活动的模拟directory@RohitJainani我编辑了答案。：）