以更有效的方式后续行之间的应用功能与熊猫

Question

我有一个数据帧df是像这样定义：

import numpy as np 
import pandas as pd 
dic = {'A':['1A','1A','3C','3C','3C','7M','7M','7M'],'B':[10,15,49,75,35,33,45,65],'C':[11,56,32,78,45,89,15,14],'D':[111,0,np.nan,np.nan,np.nan,np.nan,np.nan,np.nan],'E':[0,222,np.nan,np.nan,np.nan,np.nan,np.nan,np.nan]} 

df = pd.DataFrame(dic) 

我的目标是具有A列在同一项目行之间进行一些计算。

的函数被定义为是这样的（但可以是任何东西）：

def fun(a,b,c,d): 
    out = a*c + b/2 + d*b 
    return out 

这样的操作的结果将根据以下规则被存储在列d和E：

# Fill column D 
for j in range(0,len(df)-1): 
    if df['A'].iloc[j]==df['A'].iloc[j+1] and pd.isnull(df['D'].iloc[j]): 
     df['D'].iloc[j] = fun(df['B'].iloc[j],df['B'].iloc[j],df['B'].iloc[j+1],df['B'].iloc[j+1]) 

# Fill column E  
for j in reversed(range(1,len(df))): 
    if df['A'].iloc[j-1]==df['A'].iloc[j] and pd.isnull(df['E'].iloc[j]): 
     df['E'].iloc[j] = fun(df['B'].iloc[j],df['B'].iloc[j],df['B'].iloc[j-1],df['B'].iloc[j-1]) 

两个循环非常相似，但第二个循环是从最后一个元素循环到第一个数据帧。 我的代码工作正常，结果应该是这样的：

  # Before #       # After # 
    A B C D E   A B C  D  E 
0 1A 10 11 111 0  0 1A 10 11 111.0  0.0 
1 1A 15 56 0 222  1 1A 15 56  0.0 222.0 
2 3C 49 32 NaN NaN  2 3C 49 32 7374.5  NaN 
3 3C 75 78 NaN NaN  3 3C 75 78 5287.5 7387.5 
4 3C 35 45 NaN NaN  4 3C 35 45  NaN 5267.5 
5 7M 33 89 NaN NaN  5 7M 33 89 2986.5  NaN 
6 7M 45 15 NaN NaN  6 7M 45 15 5872.5 2992.5 
7 7M 65 14 NaN NaN  7 7M 65 14  NaN 5882.5 

你能够改善这样的代码，以便在使用某些功能构建从熊猫库使其更有效率？我想有一些更优雅的方式来实现我的结果。

注意：第一行和第二行已经值（111 0和0 222），因此它们不能被函数来计算！

Answer 1

为了解决我定义的另一个函数，它接受作为输入fun

def fun2(df,s): 
    X= fun(df.B,df.C,df.B.shift(s),df.C.shift(s)) 
    return X 

列D和E可以填充像这样我的问题：

df2['D']=np.where((df2.A.shift(-1)==df2.A) & (df2.D.isnull()==True),fun2(df2,-1),df2.D) 
df2['E']=np.where((df2.A.shift(1)==df2.A) & (df2.E.shift(1).isnull()==True),fun2(df2,+1),df2.E) 

注意：尽管更紧凑，这种方法可能会比较慢

Answer 2

你可以使用np.where和dataframe.shift()

• np.where就像if语句

• datafrmae.shift（） - 换档指数期间所需数量与可选的时间频率

  df['D']=np.where(df.A.shift(-1)==df.A,func(df['B'],df['B'],df.B.shift(-1),df.B.shift(-1)),np.NaN) 
  

Answer 3

您可以先按A的值进行分组，然后应用矢量化函数：

def fun(a,b,c,d): 
    out = a*c + b/2 + d*b 
    return out 

def apply_func(df): 
    mask = pd.isnull(df['D'][:-1]) 
    df['D'][:-1][mask] = fun(df['B'][:-1].values, df['B'][:-1].values, 
          df['B'][1:].values, df['B'][1:].values) 
    mask = pd.isnull(df['E'][1:]) 
    df['E'][1:][mask] = fun(df['B'][1:].values, df['B'][1:].values, 
          df['B'][:-1].values, df['B'][:-1].values) 
    return df 

然后：

df = df.groupby('A').apply(apply_func).reset_index(drop=True) 

    A B C  D  E 
0 1A 10 11 305.0  NaN 
1 1A 15 56  NaN 307.5 
2 3C 49 32 7374.5  NaN 
3 3C 75 78 5287.5 7387.5 
4 3C 35 45  NaN 5267.5 
5 7M 33 89 2986.5  NaN 
6 7M 45 15 5872.5 2992.5 
7 7M 65 14  NaN 5882.5