现在位置: 首页 > Pandas 教程 > 正文

Pandas df.reset_index() 函数

Pandas 常用函数 Pandas 常用函数

df.reset_index() 是 Pandas 中用于重置 DataFrame 行索引的函数。

在数据处理过程中，索引可能会变得不连续或不符合你的需求。reset_index() 可以将索引重置为默认的整数索引（0, 1, 2, ...），或者将当前的索引转换为列。这在数据清洗、排序、筛选后整理数据时非常有用。

基本语法与参数

reset_index() 是 DataFrame 的成员函数，通过点运算符 . 来调用。

语法格式

DataFrame.reset_index(level=None, drop=False, inplace=False, col_level=0, col_fill='')

参数说明

参数 类型 是否必填 说明 默认值
level int, str, tuple 或 list 可选 指定要重置的索引级别。对于多层索引（MultiIndex），可以选择重置其中某些级别。默认重置所有级别。 None
drop bool 可选 如果为 True，丢弃原来的索引，不将其转换为列；如果为 False，将原索引作为新列保留。 False
inplace bool 可选 如果为 True，直接在原 DataFrame 上修改，不返回新对象；如果为 False，返回一个新的 DataFrame，原数据不变。 False
col_level int 或 str 可选 如果列名是多重索引，指定将索引插入到哪个级别。 0
col_fill str 可选 如果列名是多重索引，当原索引被转换为列时，用于填充其他级别的列名。 ''

返回值说明

  • 返回一个新的 DataFrame（如果 inplace=False），或者 None（如果 inplace=True）。
  • 返回的 DataFrame 中索引已被重置，原索引（如果 drop=False）会作为新列保留。

实例

让我们通过一系列例子，彻底掌握 reset_index() 的用法。

示例 1：基本用法 - 重置索引

最常见的用法是将索引重置为默认的整数索引。

实例

import pandas as pd
import numpy as np

# 创建一个 DataFrame
data = {
    '姓名': ['张三', '李四', '王五'],
    '成绩': [85, 92, 78]
}
df = pd.DataFrame(data)

print("原始数据（默认索引）：")
print(df)
print("=" * 50)

# 对数据进行排序，导致索引不连续
df_sorted = df.sort_values(by='成绩', ascending=False)

print("排序后的数据（索引不连续）：")
print(df_sorted)
print("=" * 50)

# 重置索引
df_reset = df_sorted.reset_index()

print("重置索引后：")
print(df_reset)

运行结果预期:

原始数据（默认索引）：
   姓名  成绩
0  张三   85
1  李四   92
2  王五   78
==================================================
排序后的数据（索引不连续）：
   姓名  成绩
1  李四   92
0  张三   85
2  王五   78
==================================================
重置索引后：
   姓名  成绩  index
0  李四   92       1  # 原来的索引作为新列
1  张三   85       0
2  王五   78       2

代码解析:

  1. 排序后，索引变成了 1、0、2，不再是连续的 0、1、2。
  2. 使用 reset_index() 后，索引重置为 0、1、2。
  3. 原来的索引作为新列 "index" 被保留下来。

示例 2：使用 drop 参数丢弃原索引

如果不需要保留原索引，可以使用 drop=True 参数。

实例

import pandas as pd
import numpy as np

# 创建一个 DataFrame
data = {
    '姓名': ['张三', '李四', '王五'],
    '成绩': [85, 92, 78]
}
df = pd.DataFrame(data)

# 对数据进行排序
df_sorted = df.sort_values(by='成绩', ascending=False)

print("排序后的数据：")
print(df_sorted)
print("=" * 50)

# 重置索引，丢弃原索引
df_reset = df_sorted.reset_index(drop=True)

print("重置索引（丢弃原索引）后：")
print(df_reset)

运行结果预期:

排序后的数据：
   姓名  成绩
1  李四   92
0  张三   85
2  王五   78
==================================================
重置索引（丢弃原索引）后：
   姓名  成绩
0  李四   92
1  张三   85
2  王五   78

代码解析:

  • 使用 drop=True 后，原来的索引被直接丢弃，不会作为新列保留。
  • 这在不需要保留原始索引信息时很有用。

示例 3：筛选数据后重置索引

数据筛选后，索引可能会不连续，使用 reset_index() 可以整理数据。

实例

import pandas as pd
import numpy as np

# 创建一个包含所有学生成绩的 DataFrame
data = {
    '姓名': ['张三', '李四', '王五', '赵六', '钱七'],
    '成绩': [85, 92, 78, 90, 88]
}
df = pd.DataFrame(data)

print("原始数据：")
print(df)
print("=" * 50)

# 筛选成绩大于85的学生
df_filtered = df[df['成绩'] > 85]

print("筛选后的数据（索引不连续）：")
print(df_filtered)
print("=" * 50)

# 重置索引
df_reset = df_filtered.reset_index(drop=True)

print("重置索引后：")
print(df_reset)

运行结果预期:

原始数据：
   姓名  成绩
0  张三   85
1  李四   92
2  王五   78
3  赵六   90
4  钱七   88
==================================================
筛选后的数据（索引不连续）：
   姓名  成绩
1  李四   92
3  赵六   90
4  钱七   88

代码解析:

  • 筛选后保留的是原始索引 1、3、4，不是连续的 0、1、2。
  • 使用 reset_index(drop=True) 可以得到连续的索引，更便于后续处理。

    • 示例 4：删除重复行后重置索引

    删除重复数据后，也可以使用 reset_index() 整理索引。

    实例

    import pandas as pd
    import numpy as np

    # 创建一个包含重复行的 DataFrame
    data = {
        '姓名': ['张三', '李四', '张三', '王五'],
        '城市': ['北京', '上海', '北京', '广州']
    }
    df = pd.DataFrame(data)

    print("原始数据（包含重复行）：")
    print(df)
    print("=" * 50)

    # 删除重复行
    df_unique = df.drop_duplicates()

    print("删除重复行后（索引不连续）：")
    print(df_unique)
    print("=" * 50)

    # 重置索引
    df_reset = df_unique.reset_index(drop=True)

    print("重置索引后：")
    print(df_reset)

    运行结果预期:

    原始数据（包含重复行）：
   姓名  城市
0  张三  北京
1  李四  上海
2  张三  北京  # 重复
3  王五  广州
==================================================
删除重复行后（索引不连续）：
   姓名  城市
0  张三  北京
1  李四  上海
3  王五  广州

    代码解析:

    • 删除重复行后，保留的索引是 0、1、3，不是连续的 0、1、2。
    • 重置索引后，数据更加整洁。

      • 示例 5：处理缺失值后重置索引

      删除包含缺失值的行后，也可以重置索引。

      实例

      import pandas as pd
      import numpy as np

      # 创建一个包含缺失值的 DataFrame
      data = {
          '姓名': ['张三', '李四', '王五', '赵六'],
          '成绩': [85, np.nan, 92, 78]
      }
      df = pd.DataFrame(data)

      print("原始数据：")
      print(df)
      print("=" * 50)

      # 删除包含缺失值的行
      df_cleaned = df.dropna()

      print("删除缺失值后（索引不连续）：")
      print(df_cleaned)
      print("=" * 50)

      # 重置索引
      df_reset = df_cleaned.reset_index(drop=True)

      print("重置索引后：")
      print(df_reset)

      运行结果预期:

      原始数据：
   姓名   成绩
0  张三  85.0
1  李四   NaN  # 缺失值
2  王五  92.0
3  赵六  78.0
==================================================
删除缺失值后（索引不连续）：
   姓名   成绩
0  张三  85.0
2  王五  92.0
3  赵六  78.0

      代码解析:

      • 删除第1行（李四的成绩为 NaN）后，保留的索引是 0、2、3。
      • 使用 reset_index() 可以得到 0、1、2 的连续索引。

        • 示例 6：使用 inplace 参数原地修改

        使用 inplace=True 可以直接在原 DataFrame 上修改。

        实例

        import pandas as pd
        import numpy as np

        # 创建一个 DataFrame
        data = {
            '姓名': ['张三', '李四', '王五'],
            '成绩': [85, 92, 78]
        }
        df = pd.DataFrame(data)

        # 筛选数据
        df_filtered = df[df['成绩'] > 80]

        print("筛选后的数据（未重置）：")
        print(df_filtered)
        print(f"数据 id: {id(df_filtered)}")
        print("=" * 50)

        # 使用 inplace=True 原地重置索引
        df_filtered.reset_index(drop=True, inplace=True)

        print("使用 inplace=True 重置后：")
        print(df_filtered)
        print(f"数据 id: {id(df_filtered)}")

        运行结果预期:

        筛选后的数据（未重置）：
   姓名  成绩
1  李四   92
0  张三   85
数据 id: 140234567890
==================================================
使用 inplace=True 重置后：
   姓名  成绩
0  李四   92
1  张三   85
数据 id: 140234567890  # 同一个对象

        代码解析:

        • 使用 inplace=True 后，DataFrame 的内存地址（id）不变。
        • 这种方法可以节省内存。

          • 示例 7：多层索引的重置

          对于多层索引（MultiIndex），可以重置特定级别或全部级别。

          实例

          import pandas as pd
          import numpy as np

          # 创建一个多层索引的 DataFrame
          df = pd.DataFrame({
              '成绩': [85, 92, 78, 88, 90, 95]
          }, index=pd.MultiIndex.from_tuples([
              ('一班', '张三'), ('一班', '李四'), ('一班', '王五'),
              ('二班', '赵六'), ('二班', '钱七'), ('二班', '孙八')
          ], names=['班级', '姓名']))

          print("原始数据（多层索引）：")
          print(df)
          print("=" * 50)

          # 重置所有索引级别
          df_reset_all = df.reset_index()

          print("重置所有索引级别：")
          print(df_reset_all)
          print("=" * 50)

          # 只重置第一个索引级别（班级）
          df_reset_first = df.reset_index(level=0)

          print("只重置班级索引：")
          print(df_reset_first)

          运行结果预期:

          原始数据（多层索引）：
           成绩
班级  姓名
一班  张三     85
     李四     92
     王五     78
二班  赵六     88
     钱七     90
     孙八     95
==================================================
重置所有索引级别：
   班级  姓名  成绩
0  一班  张三   85
1  一班  李四   92
2  一班  王五   78
3  二班  赵六   88
4  二班  钱七   90
5  二班  钱七   95

          代码解析:

          • 多层索引的 DataFrame 可以使用 reset_index() 将索引转换为列。
          • 使用 level 参数可以选择重置哪个级别的索引。

            • 注意事项

            • reset_index() 默认不会修改原始 DataFrame，如果想原地修改，使用 inplace=True 参数。
            • 默认情况下（drop=False），原索引会作为新列保留。如果不需要保留，使用 drop=True。
            • 在使用 reset_index() 前，确保没有重要的索引信息需要保留。
            • 对于时间序列数据，重置索引后可能需要重新设置时间索引。
            • 在链式操作中（如筛选后排序），每次操作后索引都可能变化，适时使用 reset_index() 可以保持代码的可预测性。

            Pandas 常用函数 Pandas 常用函数

            返回顶部
© 2026 菜鸟教程
备案号：闽ICP备15012807号-1

∧