Question

我是编程和熊猫的新手。因此，请不要做出严格的判断，对不起我的解释。

我基本上有两个列（DM1_ID，DM2_ID），我需要根据这两个列的值创建一个新列（“ NewID”）。基本上，我正在为这两列创建一个新的ID。在这里，首先评估第一列中的值，然后获取该值并将其放入“ NewID”列中。另外，当我们这样做时，需要考虑DM2_ID，并且当该ID出现在DM1_ID中时，我需要在NewID列中提供相同的DM1_ID。

作为0的示例，索引中有DM1_ID 1和DM2_ID 6，我需要将1作为两个ID的NewID。当DM1_ID达到6（索引15）时，无论在DM2_ID中是什么，我都必须给1作为NewID，因为我同时给了DM1_ID 1和DM1_ID6。所以它将是1。此外，我还需要考虑DM2_ID以供以后使用和也将是1。（索引15 DM1_ID 6和DM2_ID 45，因为我已经将1和6的newId都设为1，所以我必须给DM1_ID 6赋予1。同样，对于45，我需要给1作为NewID（索引21）。）

#I have a large table like this
    DM1_ID  DM2_ID
0   1       6
1   1       7
2   1       15
3   2       5
4   2       10
5   3       21
6   3       28
7   3       32
8   3       35
9   4       39
10  5       2
11  5       10
12  6       1
13  6       7
14  6       15
15  6       45
16  6       55
17  7       1
18  7       6
19  7       15
20  10      75
21  45      120
22  45      10
23  10      27
24  10      28
25  2       335

#I need to create this table

    DM1_ID  DM2_ID  abc
0   1       6        1
1   1       7        1
2   1       15       1
3   2       5        2
4   2       10       2
5   3       21       3
6   3       28       3
7   3       32       3
8   3       35       3
9   4       39       4
10  5       2        2
11  5       10       2
12  6       1        1
13  6       7        1
14  6       15       1
15  6       45       1
16  6       55       1
17  7       1        1
18  7       6        1
19  7       15       1
20  10      75       2
21  45      120      1
22  45      10       2
23  10      27       2
24  10      28       2
25  2       335      2

Any help would be appreciated. Thanks.

Answer 1

实现目标的一种方法是先保留您的ID。然后，一旦满足条件，您就可以使用此持久化映射表/字典来分配唯一ID。我在字典中提供了一个示例，如下所示，但您也可以使用数据库或JSON文件来持久存储给定的ID：

df['pairs'] = df.apply(lambda x: [x[0], x[1]], axis=1)
pairs = df['pairs'].tolist()

u = {}
u_ = {}
for p in pairs:
    if u:
        if not u_:
            u_ = u.copy()
        else:
            u = u_.copy()
           
        for k in list(u.keys()):
            if any(x in u[k] for x in p):
                u_.update(
                    {
                        k: list(set(u[k] + p))
                    }
                )
                
            else:
                pass
            
        vals = [j for i in list(u.values()) for j in i]
        if u == u_ and not any(x in vals for x in p):
            n = max(list(u_.keys())) + 1
            u_[n] = p

        else:
            pass
            
    else:
        u[1] = p
        
u_

输出：

{1: [1, 6, 7, 45, 15, 55, 120],
 2: [75, 2, 10, 5],
 3: [32, 35, 3, 21, 28],
 4: [4, 39]}

现在让我们应用一个函数，该函数根据我们在上一步中创建的字典为每行分配新的ID：

f = lambda x: next(k for k,v in u_.items() if any(i in v for i in x))
df['new_ID'] = df['pairs'].apply(f)
df.drop('pairs', axis=1, inplace=True)
df

输出：

DM1_ID  DM2_ID  new_ID
0   1   6   1
1   1   7   1
2   1   15  1
3   2   5   2
4   2   10  2
5   3   21  3
6   3   28  3
7   3   32  3
8   3   35  3
9   4   39  4
10  5   2   2
11  5   10  2
12  6   1   1
13  6   7   1
14  6   15  1
15  6   45  1
16  6   55  1
17  7   1   1
18  7   6   1
19  7   15  1
20  10  75  2
21  45  120 1

熊猫会根据其他列的值来创建新的列ID，

1 个答案: