Início / coding / Perguntas / 79338219
Accepted
RKIDEV
Asked: 2025-01-08 15:11:11 +0800 CST

Panda itera linhas e multiplica valores de linha n-ésimos para o próximo valor de linha (n+1)

  • 772

Estou tentando iterar várias linhas de colunas e multiplicar a enésima linha por n+1 linha e depois adicionar colunas.

Testei o código abaixo e está funcionando bem.

Existe alguma outra maneira simples de realizar a subtração e a multiplicação juntas?

import pandas as pd

df = pd.DataFrame({'C': ["Spark","PySpark","Python","pandas","Java"],
                    'F' : [2,4,3,5,4],
                    'D':[3,4,6,5,5]})

df1 = pd.DataFrame({'C': ["Spark","PySpark","Python","pandas","Java"],
                    'F': [1,2,1,2,1],
                    'D':[1,2,2,2,1]})

df = pd.merge(df, df1, on="C")

df['F_x-F_y'] = df['F_x'] - df['F_y']
df['D_x-D_y'] = df['D_x'] - df['D_y']

for index, row in df.iterrows():
    df['F_mul'] = df['F_x-F_y'].mul(df['F_x-F_y'].shift())
    df['D_mul'] = df['D_x-D_y'].mul(df['D_x-D_y'].shift())

df['F+D'] = df['F_mul'] + df['D_mul']

Saída -

         C  F_x  D_x  F_y  D_y  F_x-F_y  D_x-D_y  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
python

3 respostas

  1. Best Answer

    Primeiro remova a iteração por iterrows, então é possível simplificar uma solução generalizada por:

    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

    Outra ideia é processar todas as colunas juntas - a vantagem é que não é necessário especificar colunas para processamento:

    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
    • 2

  2. Você pode remover a iteração através de linhas inteiramente. Seu código não faz nada específico de linha dentro do iterrows()loop -- nem valores indexnem rowsão usados. O que acontece é que você acaba recalculando a coluna inteira (F_mul e D_mul) em cada iteração.

    Exemplo

    ...

# 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()
...
    • 1

  3. Você realmente não deve usar loops ou iterrowspandas.

    O que você quer fazer pode ser alcançado vetorialmente. Você não deve ter a chave C como coluna, mas sim como índice para aproveitar o alinhamento automático dos índices:

    # 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()

    Você pode até ter tudo como uma única expressão (exceto 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()
      )

    Saída:

             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

    E se você não precisar das colunas intermediárias _sub, _mulisso é ainda mais fácil:

    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()

    Ou:

    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()
      )

    Saída:

             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
    • 0

relate perguntas