如何更新Python DataFrame中互相依赖的列？是否需用循环？

我有一个Python DataFrame，包含Open_Value和Close_Value两个新列，规则如下：

• 当Open_Flag = 1时，Open_Value设为1000；否则，Open_Value取上一行的Close_Value值。
• Close_Value = Open_Value * Daily_Change，两列互相依赖，需要先更新Close_Value，再用它计算下一行的Open_Value。

当前DataFrame结果：

Date ticker  Daily_Change  Open_Flag  Open_Value  Close_Value
0     2022-07-01    AMR      0.982223          1        1000   982.222921
1     2022-07-05    AMR      0.900296          0           1     0.900296
2     2022-07-06    AMR      0.962195          0           1     0.962195
3     2022-07-07    AMR      1.078025          0           1     1.078025
4     2022-07-08    AMR      1.007203          0           1     1.007203

期望得到的结果：

Date ticker  Daily_Change  Open_Flag  Open_Value  Close_Value
0     2022-07-01    AMR      0.982223          1        1000   982.222921
1     2022-07-05    AMR      0.900296          0  982.222921   884.291669
2     2022-07-06    AMR      0.962195          0  884.291669   850.861323
3     2022-07-07    AMR      1.078025          0  850.861323   917.250058
4     2022-07-08    AMR      1.007203          0  917.250058   923.857468

请问如何更新这两个互相依赖的列？是否需要使用循环？

这种依赖前一行计算结果的场景，循环是最直观且容易实现的方式，尤其是存在Open_Flag重置点的情况，用向量化方法反而需要额外处理分组逻辑。

方法1：直接循环遍历行 #

import pandas as pd

# 假设你的DataFrame名为df
for i in range(1, len(df)):
    # 根据Open_Flag设置当前行的Open_Value
    if df.loc[i, 'Open_Flag'] == 1:
        df.loc[i, 'Open_Value'] = 1000
    else:
        df.loc[i, 'Open_Value'] = df.loc[i-1, 'Close_Value']
    # 计算当前行的Close_Value
    df.loc[i, 'Close_Value'] = df.loc[i, 'Open_Value'] * df.loc[i, 'Daily_Change']

这个方法逻辑完全贴合你的规则：从第二行开始，逐行根据上一行的Close_Value更新当前行的Open_Value，再计算当前行的Close_Value，新手也能一眼看懂。

方法2：分组累积计算（无循环） #

如果不想用循环，可以通过标记Open_Flag的重置点，把数据分成多个连续组，每组内计算累积乘积：

# 标记分组：每次Open_Flag=1时开启新组
df['group'] = df['Open_Flag'].cumsum()

# 对每个组，从初始值1000开始计算Daily_Change的累积乘积，得到Close_Value
df['Close_Value'] = df.groupby('group').apply(
    lambda x: 1000 * x['Daily_Change'].cumprod()
).reset_index(drop=True)

# Open_Value取上一行的Close_Value，组内第一行（Open_Flag=1）设为1000
df['Open_Value'] = df['Close_Value'].shift(1)
df.loc[df['Open_Flag'] == 1, 'Open_Value'] = 1000

# 可以删掉临时的group列
df.drop('group', axis=1, inplace=True)

这个方法用向量化操作替代循环，速度更快，适合处理大规模数据，但逻辑稍复杂，需要理解分组和累积乘积的原理。

注意事项 #

• 循环方法简单易懂，但如果DataFrame行数达到百万级，速度会比向量化方法慢，此时优先选分组累积的方式。
• 一定要确保DataFrame是按Date顺序排序的，否则计算结果会完全错误。

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