基于行总和的Pandas复杂数值取整转换问题求助

需求明确 #

要对 DataFrame 里的季度列（Q开头的列）做两步处理：

• 单个值规则：数值<0.6直接取0；≥0.6时取最近的偶数
• 行总和规则：取整后每行的总和必须等于该行原始总和的最近偶数，要是第一步取整后总和不达标，得调整行内值修正（优先改最后一列，或者原始值最大的列）

你的现有代码没达到预期效果，下面是问题分析和优化后的实现：

现有代码的问题 #

第一部分：单个值取整逻辑错误 #

i = df.iloc[:, 2:].astype(int)
df2 = (i+i.mod(2) 
       
       # round to nearest 2
       # add 2 for values between 0.6-1
       
       +2*(df.iloc[:, 2:].ge(0.6)
           &df.iloc[:, 2:].lt(1))
       )

1. 最近偶数计算逻辑偏差：i+i.mod(2)是把整数转成大于等于它的最小偶数（比如3变4，2不变），但需求是取距离最近的偶数（比如2.7离2更近，应该取2；3.6离4更近，取4），两者逻辑完全不符。
2. 0.6-1区间处理错误：直接加2会让0.7变成2，但0.7的最近偶数是0（0和2的距离分别是0.7和1.3），明显违反规则。

第二部分：总和修正逻辑粗糙 #

# create the delta with difference b/w sum of the two DF
df2['delta']=df2['sum'].sub(df['sum'])

# subtract the delta from the last quarter, obtained
# using filter
# create a placeholder df3
df3=df2.filter(like='Q' ).iloc[:,-1:].sub(df2.iloc[:,-1:].values)

1. Delta计算逻辑错误：应该先算出原始总和的最近偶数，再和第一步取整后的总和求差值，而不是直接用取整后的总和减原始总和。
2. 修正方式不合理：直接把delta减到最后一列，容易出现负数，或者破坏单个值的偶数取整规则。

优化后的完整代码 #

步骤1：实现单个值的正确取整 #

先写个函数处理单个数值，严格贴合规则：

def round_value(x):
    if x < 0.6:
        return 0
    # 计算最近偶数：把x除以2取整再乘2，就是距离最近的偶数
    return round(x / 2) * 2

# 提取所有Q开头的列，应用函数
q_cols = df.filter(like='Q').columns
df_round = df[q_cols].applymap(round_value)

步骤2：计算每行的目标总和 #

先算出原始行总和的最近偶数，再对比取整后的总和，得到需要调整的差值：

# 计算原始行总和
df['original_sum'] = df[q_cols].sum(axis=1)
# 原始总和的最近偶数就是目标总和
df['target_sum'] = df['original_sum'].apply(lambda x: round(x / 2) * 2)
# 计算取整后总和和目标的差值（delta一定是偶数，因为两个都是偶数）
df_round['current_sum'] = df_round.sum(axis=1)
df_round['delta'] = df_round['current_sum'] - df['target_sum']

步骤3：调整行内值满足总和要求 #

优先改最后一列，要是改完会变负数，就改原始值最大的列，确保调整后还是偶数且非负：

for idx, row in df_round.iterrows():
    delta = row['delta']
    if delta == 0:
        continue  # 已经符合要求，跳过
    
    # 先试调整最后一个Q列
    last_col = q_cols[-1]
    new_val = row[last_col] - delta
    if new_val >= 0:
        df_round.loc[idx, last_col] = new_val
    else:
        # 找原始值最大的列来调整，避免出现负数
        max_val_col = df[q_cols].loc[idx].idxmax()
        new_val_max = df_round.loc[idx, max_val_col] - delta
        if new_val_max >= 0:
            df_round.loc[idx, max_val_col] = new_val_max
        else:
            # 极端情况：所有列调整后都可能为负，就从大到小列依次减，直到delta清零
            sorted_cols = df[q_cols].loc[idx].sort_values(ascending=False).index
            remaining_delta = delta
            for col in sorted_cols:
                if remaining_delta == 0:
                    break
                # 最多减到0，不能变负
                adjust_amount = min(remaining_delta, df_round.loc[idx, col])
                df_round.loc[idx, col] -= adjust_amount
                remaining_delta -= adjust_amount
    
    # 更新当前行总和（可选，用来验证）
    df_round.loc[idx, 'current_sum'] = df_round.loc[idx, q_cols].sum()

# 删掉辅助列，合并回原始数据的其他列
df_round = df_round.drop(['current_sum', 'delta'], axis=1)
final_result = df.drop(q_cols, axis=1).join(df_round)

代码说明 #

1. 单个值处理：round_value函数严格按规则执行，<0.6返回0，≥0.6返回最近偶数，逻辑准确。
2. 总和修正：先明确目标总和，再计算差值，调整时优先保证最后一列，不行就找原始值最大的列，避免出现负数，同时保持所有值都是偶数。
3. 最后把处理好的季度列和原始数据的其他列合并，得到完整结果。

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