Panda迭代行并将第n行值乘以下一(n+1)行值

首先删除迭代 iterrows ,则可以通过以下方式简化泛化解:

cols = ['F','D']

for col in cols:
    s = df[f'{col}_x'].sub(df[f'{col}_y'])
    df[f'{col}_mul'] = s.mul(s.shift())

df['+'.join(cols)] = df.filter(like='mul').sum(axis=1, min_count=1)
print (df)
         C  F_x  D_x  F_y  D_y  F_mul  D_mul   F+D
0    Spark    2    3    1    1    NaN    NaN   NaN
1  PySpark    4    4    2    2    2.0    4.0   6.0
2   Python    3    6    1    2    4.0    8.0  12.0
3   pandas    5    5    2    2    6.0   12.0  18.0
4     Java    4    5    1    1    9.0   12.0  21.0

另一个想法是一起处理所有列——优点是不需要指定要处理的列:

df1 = (df.filter(like='x').rename(columns=lambda x: x.replace('x','mul'))
         .sub(df.filter(like='y').rename(columns=lambda x: x.replace('y','mul'))))

df2 = df1.mul(df1.shift())
df = df.join(df2)

df['+'.join(x.replace('_mul','') for x in df2.columns)] = df2.sum(axis=1, min_count=1)
print (df)
         C  F_x  D_x  F_y  D_y  F_mul  D_mul   F+D
0    Spark    2    3    1    1    NaN    NaN   NaN
1  PySpark    4    4    2    2    2.0    4.0   6.0
2   Python    3    6    1    2    4.0    8.0  12.0
3   pandas    5    5    2    2    6.0   12.0  18.0
4     Java    4    5    1    1    9.0   12.0  21.0

你真的不应该使用循环或 iterrows 在熊猫。

你想做的事情可以矢量化地实现。你不应该有钥匙 C 作为列,而不是作为 指数 利用索引的自动对齐:

# ensure C is the index
df = df.set_index('C')
df1 = df1.set_index('C')

# compute the difference
sub = df.sub(df1)

# combine df/df1/sub and compute the shifted multiplication
out = (pd.concat([df.add_suffix('_x'),
                  df1.add_suffix('_y'),
                  sub.add_suffix('_sub'),
                  sub.mul(sub.shift()).add_suffix('_mul')
                 ], axis=1)
      )

# compute the total sum
out['+'.join(df)] = out.filter(like='_mul').sum(axis=1, min_count=1)

# reset_index
out = out.reset_index()

你甚至可以将所有内容都作为一个表达式(sub除外):

sub = df.sub(df1)

out = (pd.concat([df.add_suffix('_x'),
                  df1.add_suffix('_y'),
                  sub.add_suffix('_sub'),
                  sub.mul(sub.shift()).add_suffix('_mul')
                 ], axis=1)
         .assign(**{'+'.join(df): lambda x: x.filter(like='_mul')
                                             .sum(axis=1, min_count=1)})
         .reset_index()
      )

输出:

         C  F_x  D_x  F_y  D_y  F_sub  D_sub  F_mul  D_mul   F+D
0    Spark    2    3    1    1      1      2    NaN    NaN   NaN
1  PySpark    4    4    2    2      2      2    2.0    4.0   6.0
2   Python    3    6    1    2      2      4    4.0    8.0  12.0
3   pandas    5    5    2    2      3      3    6.0   12.0  18.0
4     Java    4    5    1    1      3      4    9.0   12.0  21.0

如果你不需要中间体 _sub / _mul 列,这甚至更容易:

sub = df.sub(df1)

out = pd.concat([df.add_suffix('_x'),
                 df1.add_suffix('_y'),
                 sub.mul(sub.shift())
                    .sum(axis=1, min_count=1).rename('+'.join(df))
                ], axis=1).reset_index()

或者:

sub = df.sub(df1)

out = (df.join(df1, lsuffix='_x', rsuffix='_y')
         .assign(**{'+'.join(df): sub.mul(sub.shift())
                                     .sum(axis=1, min_count=1)})
         .reset_index()
      )

输出:

         C  F_x  D_x  F_y  D_y   F+D
0    Spark    2    3    1    1   NaN
1  PySpark    4    4    2    2   6.0
2   Python    3    6    1    2  12.0
3   pandas    5    5    2    2  18.0
4     Java    4    5    1    1  21.0

您可以完全删除迭代槽行。 您的代码在内部不执行任何特定于行的操作 iterrows() 循环--两者都没有 index 也没有 row 使用值。结果是,在每次迭代中,你最终都会重新计算整个列(F_mul和D_mul)。

例子

...

# Multiply with shifted values instead of using iterrows()
df['F_mul'] = df['F_x-F_y'] * df['F_x-F_y'].shift()
df['D_mul'] = df['D_x-D_y'] * df['D_x-D_y'].shift()
...