如何计算复杂Python DataFrame分割代码的时间复杂度？

代码回顾 #

先整理你提供的核心代码（修正了变量名重复和笔误问题）：

import os
import pandas as pd

# 假设data为原始输入DataFrame
S = []
features_S = data.S.unique()
for f_S in features_S:
    data_S = data.loc[data.S == f_S]
    S.append(data_S)

F = []
for s_group in S:
    if s_group.empty:
        pass
    else:
        features_F = s_group.F.unique()
        for f_F in features_F:
            data_F = s_group.loc[s_group.F == f_F]
            F.append(data_F)

D = []
for f_group in F:
    if f_group.empty:
        pass
    else:
        features_D = f_group.D.unique()
        for f_D in features_D:
            data_D = f_group.loc[f_group.D == f_D]
            D.append(data_D)            

M = []
for d_group in D:
    if d_group.empty:
        pass
    else:
        features_M = d_group.M.unique()
        for f_M in features_M:
            data_M = d_group.loc[d_group.M == f_M]
            M.append(data_M)
   
Y = []
for m_group in M:
    if m_group.empty:
        pass
    else:
        features_Y = m_group.Y.unique()
        for f_Y in features_Y:
            data_Y = m_group.loc[m_group.Y == f_Y]
            Y.append(data_Y)

Mo = []
for y_group in Y:
    if y_group.empty:
        pass
    else:
        features_Mo = y_group.Mo.unique()
        for f_Mo in features_Mo:
            data_Mo = y_group.loc[y_group.Mo == f_Mo]
            Mo.append(data_Mo)

Da = []
for mo_group in Mo:
    if mo_group.empty:
        pass
    else:
        features_Da = mo_group.Da.unique()
        for f_Da in features_Da:
            data_Da = mo_group.loc[mo_group.Da == f_Da]
            Da.append(data_Da) 
 

for da_group in Da:
    if da_group.empty:
        pass
    else:
        PATH = 'C:/Users/Desktop/'
        if not os.path.exists(PATH):
            os.makedirs(PATH)
        da_group.to_csv(os.path.join(PATH,'Split.csv'),index=False)

时间复杂度计算 #

假设原始DataFrame的总行数为N，逐段拆解分析：

1. 第一层S列分组：

   • data.S.unique() 需要遍历整列所有行，时间为O(N)
   • 循环每个唯一值时，loc筛选的总行数总和等于原始N（每一行只会被分到一个S分组），这部分总时间也是O(N)
   • 第一层总时间：O(N)

2. 后续所有分组层（F/D/M/Y/Mo/Da）：

   • 每一层都是对上层分组再细分，不管分多少层，所有分组的行数总和始终等于原始N（无数据新增或丢失）
   • 每一层的unique()和loc操作，总处理量都是遍历所有N行一次，每层时间为O(N)
   • 6层的总时间：6*O(N) = O(N)（常数系数不影响时间复杂度）

3. 文件保存阶段：

   • 所有非空分组的行数总和为N，to_csv操作总时间为O(N)

把所有阶段合并，最终总时间复杂度为 O(N)，所有操作的总处理量与原始数据行数成线性关系。

这类代码的时间复杂度通用计算方法 #

不用被多层循环迷惑，按以下步骤拆解：

• 拆分核心模块：把代码分成分组、保存等独立模块，重点看循环内处理的总数据量，而非循环次数
• 分析内置操作成本：pandas的unique()、loc、to_csv等操作，时间都与处理的行数成正比，记为O(k)（k为当前操作的DataFrame行数）
• 统计总操作量：多层分组逻辑中，所有分组的行数总和始终等于原始数据行数N，因此每一层的总操作量都是O(N)
• 简化复杂度结果：忽略常数系数和低阶操作（比如空DataFrame判断的O(1)操作），保留最高阶的线性项O(N)

内容的提问来源于stack exchange，提问作者Akansha