Pandas分组生成序列ID技巧

今日不肯埋头，明日何以抬头！每日一句努力自己的话哈哈~哈喽，今天我将给大家带来一篇《Pandas分组生成序列ID的实用方法》，主要内容是讲解等等，感兴趣的朋友可以收藏或者有更好的建议在评论提出，我都会认真看的！大家一起进步，一起学习！

本教程详细介绍了如何在Pandas DataFrame中，根据指定的分组字段（如城市），为每组数据生成一个独立的、从1开始递增的序列ID。通过结合使用GroupBy.cumcount()函数和字符串操作，可以高效地构建出符合业务逻辑的复合ID，确保序列计数在每个分组内自动重置，从而满足复杂的数据标识需求。

引言：理解分组内序列ID的需求

在数据处理和分析中，我们经常需要为数据记录生成唯一的标识符（ID）。这些ID有时是复合型的，由多个字段的信息组合而成。一个常见的需求是，ID的一部分包含某个分组字段的简写（例如，城市名称的前缀），另一部分则是该分组内部的序列号。关键在于，这个序列号必须在每个新分组开始时重新从1开始计数，而不是在整个数据集中全局递增。

例如，我们有一个包含城市（City）和姓名（Name）的DataFrame，期望生成的ID格式为 城市前缀-姓名前缀-分组内序列号。

原始数据示例：

   City       Name
0  Paris       John
1  Paris       Paul
2  Paris     Pierre
3  Paris      Paula
4   Rome   Riccardo
5   Rome  Jean-Paul
6   Rome      Franc

期望的ID生成结果：

   City       Name         Id
0  Paris       John  Par-Joh-1
1  Paris       Paul  Par-Pau-2
2  Paris     Pierre  Par-Pie-3
3  Paris      Paula  Par-Pau-4
4   Rome   Riccardo  Rom-Ric-1
5   Rome  Jean-Paul  Rom-Jea-2
6   Rome      Franc  Rom-Fra-3

如果仅仅使用全局索引或全局计数器，当城市从“Paris”变为“Rome”时，序列号会继续递增（例如“Rom-Ric-5”），这不符合我们的分组内重置计数的预期。

核心工具：GroupBy.cumcount()函数

Pandas库为解决这类问题提供了强大的工具，其中GroupBy.cumcount()函数是实现分组内序列号重置的关键。

GroupBy.cumcount()函数的作用是：对于通过groupby()方法创建的每个分组，它会为该分组内的每一行生成一个从0开始递增的累积计数。这意味着，当一个新分组开始时，计数器会自动重置为0。

这与groupby().size()或groupby().count()等聚合函数不同，后者会返回每个分组的聚合结果（如分组大小），而cumcount()则会为原始DataFrame的每一行返回一个对应其分组内顺序的计数。

实现步骤与示例代码

现在，我们将逐步演示如何利用GroupBy.cumcount()来生成符合要求的复合ID。

1. 准备示例数据

首先，创建一个Pandas DataFrame来模拟我们的场景：

import pandas as pd

data = {
    'City': ['Paris', 'Paris', 'Paris', 'Paris', 'Rome', 'Rome', 'Rome'],
    'Name': ['John', 'Paul', 'Pierre', 'Paula', 'Riccardo', 'Jean-Paul', 'Franc']
}
df = pd.DataFrame(data)
print("原始DataFrame:")
print(df)

输出：

原始DataFrame:
    City       Name
0  Paris       John
1  Paris       Paul
2  Paris     Pierre
3  Paris      Paula
4   Rome   Riccardo
5   Rome  Jean-Paul
6   Rome      Franc

2. 错误示范：使用全局计数

如果直接使用DataFrame的索引作为序列号，或者生成一个全局递增的序列，ID的计数将不会在城市变化时重置：

# 错误示范：使用全局索引
df['id_global'] = df.City.str[:3] + '-' + df.Name.str[:3] + '-' + df.index.astype(str)
print("\n使用全局索引生成的ID (错误示范):")
print(df)

输出：

使用全局索引生成的ID (错误示范):
    City       Name    id_global
0  Paris       John    Par-Joh-0
1  Paris       Paul    Par-Pau-1
2  Paris     Pierre    Par-Pie-2
3  Paris      Paula    Par-Pau-3
4   Rome   Riccardo    Rom-Ric-4
5   Rome  Jean-Paul    Rom-Jea-5
6   Rome      Franc    Rom-Fra-6

可以看到，当城市从Paris变为Rome时，序列号从4开始，而不是我们期望的1。

3. 应用GroupBy.cumcount()生成分组内序列号

现在，我们使用groupby('City').cumcount()来生成分组内序列号。

# 生成分组内累积计数
df['city_sequence'] = df.groupby('City').cumcount()
print("\n应用groupby('City').cumcount()后的DataFrame:")
print(df)

输出：

应用groupby('City').cumcount()后的DataFrame:
    City       Name  city_sequence
0  Paris       John              0
1  Paris       Paul              1
2  Paris     Pierre              2
3  Paris      Paula              3
4   Rome   Riccardo              0
5   Rome  Jean-Paul              1
6   Rome      Franc              2

可以看到，city_sequence列在“Paris”分组内从0递增到3，然后在“Rome”分组开始时重置为0，并再次递增。

4. 调整计数并转换为字符串

cumcount()默认从0开始计数。为了使其从1开始，我们需要对结果加上1。同时，为了将这个数字与字符串拼接，需要将其转换为字符串类型。

df['city_sequence_adjusted'] = df.groupby('City').cumcount().add(1).astype(str)
print("\n调整并转换为字符串后的分组内序列号:")
print(df)

输出：

调整并转换为字符串后的分组内序列号:
    City       Name  city_sequence  city_sequence_adjusted
0  Paris       John              0                      1
1  Paris       Paul              1                      2
2  Paris     Pierre              2                      3
3  Paris      Paula              3                      4
4   Rome   Riccardo              0                      1
5   Rome  Jean-Paul              1                      2
6   Rome      Franc              2                      3

5. 构建最终的复合ID

最后，我们将城市前缀、姓名前缀和调整后的分组内序列号拼接起来，生成最终的ID。

df['Id'] = (df.City.str[:3] + '-' + 
            df.Name.str[:3] + '-' + 
            df.groupby('City').cumcount().add(1).astype(str))

# 清理辅助列以展示最终结果
df = df[['City', 'Name', 'Id']]
print("\n最终生成的ID:")
print(df)

输出：

最终生成的ID:
    City       Name         Id
0  Paris       John  Par-Joh-1
1  Paris       Paul  Par-Pau-2
2  Paris     Pierre  Par-Pie-3
4   Rome   Riccardo  Rom-Ric-1
5   Rome  Jean-Paul  Rom-Jea-2
6   Rome      Franc  Rom-Fra-3

现在，Id列已经完全符合我们的预期，序列号在每个城市分组内都从1开始重置。

注意事项与扩展

1. 多字段分组： 如果需要根据多个字段进行分组并重置序列，只需在groupby()中传入一个列名列表即可。例如：df.groupby(['City', 'Country']).cumcount()。

2. 序列号格式化（零填充）： 如果希望序列号具有固定长度，例如“01”、“02”而不是“1”、“2”，可以使用字符串的zfill()方法。

   df['Id_padded'] = (df.City.str[:3] + '-' + 
                      df.Name.str[:3] + '-' + 
                      df.groupby('City').cumcount().add(1).astype(str).str.zfill(2))
   print("\n带零填充的ID:")
   print(df[['City', 'Name', 'Id_padded']])

   输出示例：

   带零填充的ID:
       City       Name  Id_padded
   0  Paris       John  Par-Joh-01
   1  Paris       Paul  Par-Pau-02
   2  Paris     Pierre  Par-Pie-03
   3  Paris      Paula  Par-Pau-04
   4   Rome   Riccardo  Rom-Ric-01
   5   Rome  Jean-Paul  Rom-Jea-02
   6   Rome      Franc  Rom-Fra-03

3. 性能考量： 对于大型数据集，Pandas的groupby()操作通常是高度优化的，因此这种方法在处理性能方面表现良好。

总结

通过本教程，我们学习了如何利用Pandas的groupby().cumcount()函数来解决在DataFrame中生成分组内重置序列ID的问题。这个方法简洁高效，能够灵活应对各种需要根据特定分组逻辑生成唯一标识符的场景。掌握这一技巧，将有助于更有效地进行数据清洗、数据标识和特征工程。

到这里，我们也就讲完了《Pandas分组生成序列ID技巧》的内容了。个人认为，基础知识的学习和巩固，是为了更好的将其运用到项目中，欢迎关注golang学习网公众号，带你了解更多关于的知识点！