如何根据列的组合生成唯一 ID，但在不同文件中保持一致？

Question

我有一个包含 A、B、C 列的文件。

下周我将获得一个包含 A、B 列 C 的新文件。

A 和 B 是唯一的组合。 我想根据这两个字段生成一个唯一的 ID。

当我得到新文件时，我想对它应用同样的东西，所以如果组合 A、B 也在下周的文件中，它将具有与前一周相同的 ID。

Answer 1

一种方法是使用您已经创建的唯一 ID 维护一个数据集，例如，在 pickle 文件中。 我们称这个tracker 。 每当您为 A 列和 B 列找到新的唯一组合时，就将它们添加到数据集中。 要创建 ID，您可以使用pd.factorize 。 请注意确保新的 ID 必须与已经创建并包含在跟踪器中的 ID 不同。

这是一个最小的工作示例：

import pandas as pd
import numpy as np

def factorize_data(df, tracker):
    # merge already existing identifers
    df_factorized = df.merge(
        tracker,
        on=['A','B'],
        how='left'
    )

    # get rows which do not yet have a unique id
    untracked = df_factorized.loc[df_factorized['id'].isnull(), ['A','B']]
    
    if not untracked.empty:
        # create new id
        untracked['id'] = pd.factorize(pd._libs.lib.fast_zip([untracked.A.values, untracked.B.values]))[0].astype(int)

        # ensure that new ids are not confused with old ids
        max_id = 0 if tracker.empty else tracker['id'].max()
        untracked['id'] += max_id + 1

        # update tracker
        tracker_updated = pd.concat([tracker, untracked])

        # update dataframe with new ids
        df_factorized = df_factorized.merge(
            untracked,
            on=['A','B'],
            how='left',
            suffixes=('_old', '_new')
        )
        
        # combine old and new ids
        df_factorized['id'] = np.where(df_factorized['id_old'].isnull(), df_factorized['id_new'], df_factorized['id_old'])
        df_factorized['id'] = df_factorized['id'].astype(int)
        df_factorized.drop(columns=['id_new','id_old'], inplace=True)

        return df_factorized, tracker_updated

    return df_factorized, tracker

# initialize tracking dataframe
tracker = pd.DataFrame(columns=['A','B','id'])

# data today
df_today = pd.DataFrame({
    'A': [1,2,3],
    'B': [4,5,6],
    'C': [7,8,9]
})

# data tomorrow
df_tomorrow = pd.DataFrame({
    'A': [1,4,5],
    'B': [4,10,11],
    'C': [7,12,13]
})

# create new column with unique ids and update tracker if necessary
df_today_factorized, tracker_updated = factorize_data(df_today, tracker)

# overwrite tracker
tracker = tracker_updated

# create new column with unique ids and update tracker if necessary
df_tomorrow_factorized, tracker_updated = factorize_data(df_tomorrow, tracker)

它将df_today从

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

到

   A  B  C  id
0  1  4  7   1
1  2  5  8   2
2  3  6  9   3

并将初始化的空跟踪器更新为以下数据集

   A  B id
0  1  4  1
1  2  5  2
2  3  6  3

将该过程应用于明天的 dataframe, df_tomorrow ,

   A   B   C
0  1   4   7
1  4  10  12
2  5  11  13

将其转换为

   A   B   C  id
0  1   4   7   1
1  4  10  12   4
2  5  11  13   5

并将跟踪器更新为

   A   B id
0  1   4  1
1  2   5  2
2  3   6  3
1  4  10  4
2  5  11  5

请注意， df_today中第一行的 id 依赖于df_tomorrow中找到的 id，而其他行则被创建并添加到跟踪器中。