一种确定两系列码之间一致编码的算法

Question

我遇到了一个问题，我试图使用人行横道将数据集中的代码A与代码B进行匹配。例如，这些可能是1990年和1991年的行业代码，人口普查改变了他们对行业的编码方式。如果我可以创建一个协调代码，我可以使用该代码来跟踪相同的行业（或新的行业组，如果必要的话）。它们提供了一条人行横道，如下所示：

import pandas as pd
import numpy as np

df = pd.DataFrame([
[0,0],
[1,2],
[1,3],
[2,4],
[3,4],
[4,5],
[4,6],
[5,5],
[10,11],
[10,13],
[11,11]
], columns=list('AB'))

df
     A   B
0    0   0
1    1   2
2    1   3
3    2   4
4    3   4
5    4   5
6    4   6
7    5   5
8   10  11
9   10  13
10  11  11

因此，我想要的输出将是一个新列，它定义了A和B中的非重叠代码。例如，考虑下面的预期结果：

     A   B    C
0    0   0  0.0
1    1   2  1.0
2    1   3  1.0
3    2   4  2.0
4    3   4  2.0
5    4   5  3.0
6    4   6  3.0
7    5   5  3.0
8   10  11  4.0
9   10  13  4.0
10  11  11  4.0

我已经开始通过先完成简单的部分来回答这个问题。这些是（一对多）1:m和（多对一）m:1匹配，我可以简单地分配一个公共值

sizesA = df.groupby('A').size()
sizesB = df.groupby('B').size()
df['sizeA'] = df['A'].map(sizesA)
df['sizeB'] = df['B'].map(sizesB)

df['C'] = np.nan

next_v = 0

# 1:m matching

for a in df[df.sizeA>=1].A.unique():
    if df[df.A==a]['sizeB'].max()==1:
        df['C'] = np.where(df['A']==a, next_v, df['C'])
        next_v += 1

# m:1 matching

for b in df[df.sizeB>1].B.unique():
    if df[df.B==b]['sizeA'].max()==1:
        df['C'] = np.where(df['B']==b, next_v, df['C'])
        next_v += 1

df
     A   B  sizeA  sizeB    C
0    0   0      1      1  0.0
1    1   2      2      1  1.0
2    1   3      2      1  1.0
3    2   4      1      2  2.0
4    3   4      1      2  2.0
5    4   5      2      2  NaN
6    4   6      2      1  NaN
7    5   5      1      2  NaN
8   10  11      2      2  NaN
9   10  13      2      1  NaN
10  11  11      1      2  NaN

问题在于（多对多）m:m匹配。我似乎想不出一个好办法来解决这个问题，我猜这是一个计算上很难解决的问题。请注意，我可以只在单个代码上分配剩余的值，但这将忽略一个事实，即我可以将它们划分为两个不同的代码，并且仍然保持一致性

另外，如果您对标题有任何建议，请告诉我

Answer 1

我真的想出了一个解决办法。也许没那么优雅

ungrouped = df['A'].unique().tolist()
Anew = pd.Series(index=sorted(df['A'].unique()))
Bnew = pd.Series(index=sorted(df['B'].unique()))

g = 0

Avals = [ungrouped[0]]

while True:
    Bvals = df[df['A'].isin(Avals)].B.unique().tolist()

    Acheck = df[df['B'].isin(Bvals)].A.unique().tolist()

    if set(Acheck) == set(Avals):
        Anew.loc[Avals] = g
        Bnew.loc[Bvals] = g
        g += 1
        ungrouped = [a for a in ungrouped if a not in Avals]
        if len(ungrouped) == 0:
            break
        Avals = [ungrouped[0]]
    else:
        Avals = Acheck

df['C'] = df['A'].map(Anew)
df
     A   B    C
0    0   0  0.0
1    1   2  1.0
2    1   3  1.0
3    2   4  2.0
4    3   4  2.0
5    4   5  3.0
6    4   6  3.0
7    5   5  3.0
8   10  11  4.0
9   10  13  4.0
10  11  11  4.0

Answer 2

C需要从0开始还是可以从1开始？我只是减去1，这样你就可以从0开始。你可以根据自己的需要调整它

使用cumcount和cumsum应该会更容易

df['C'] = ((df.groupby('A').cumcount()==0) & (df.groupby('B').cumcount()==0)).cumsum()-1

print(df)

print(df)

     A   B  C
0    0   0  0
1    1   2  1
2    1   3  1
3    2   4  2
4    3   4  2
5    4   5  3
6    4   6  3
7    5   5  3
8   10  11  4
9   10  13  4
10  11  11  4