Question

我认为我的问题最好以一个例子来说明。

以下是我作为输入的列。

Month       Monthly_Interest    Payment_Shortfall      Amount_In_Arrears
1               0.1             20                     
2               0.1             100                    
3               0.1             105                    
4               0.1             50                     
5               0.1             5                      
6               0.1             30                     
7               0.1             70

这是我需要的输出。

Month       Monthly_Interest    Payment_Shortfall      Amount_In_Arrears
1               0.1             20                     20.00
2               0.1             100                    122.00
3               0.1             105                    239.20
4               0.1             50                     313.12
5               0.1             5                      349.43
6               0.1             30                     414.38
7               0.1             70                     525.81

这是一笔每月由Payment_Shortfall支付不足的贷款。

Payment_Shortfall每月构建一次Amount_In_Arrears。

自上个月Amount_In_Arrears收取利息，并将其添加到当月Amount_In_Arrears。

换句话说：Amount_In_Arrears = Payment_Shortfall + Amount_In_Arrears(previous month) + Amount_In_Arrears(previous month) * Monthly_Interest

例如，对于第2个月：Amount_in_Arrears = 100 + 20 + 20 * 0.1 = 122和第3个月：Amount_in_Arrears = 105 + 122 + 122 * 0.1 = 239.20

我一直试图在熊猫中做到这一点，我似乎无法弄明白。我需要将它应用于相当大的数据帧（大约300万行），因此效率是一个考虑因素。

我的数据有很多像这样的贷款，所以我还需要重置的解决方案（可能使用groupby（）函数），但是，我认为一次处理一个问题是最好的

非常感谢您的任何帮助！

Answer 1

据我所知，在普通的大熊猫中没有有效的方法来计算它（但如果有的话，我非常想知道）。我知道在python中为这种任务获得快速计算的两个选项，cython（特别注释为编译为c的python）和numba（用于普通python的即时编译器）。 / p>

由于我不太了解cython，我会给你一个关于numba的例子。

对于numba，你用numba decorater写一个单独的函数。 Numba与numpy玩得很好，但不知道熊猫，因此我们必须将numpy数组提供给函数：

@numba.jit(nopython=True)
def compute_total_amount(interest, amount):
  n = len(interest)
  total_amount = np.empty(n)
  total_amount[0] = amount[0]
  for i in range(1,n):
    total_amount[i] = total_amount[i-1]*(1+interest[i])+amount[i]
  return total_amount

df['Amount_In_Arrears'] = compute_total_amount(df['Monthly_Interest'].values,\
                                               df['Payment_Shortfall'].values)

   Payment_Shortfall  Monthly_Interest  Amount_In_Arrears
0                 20               0.1           20.00000
1                100               0.1          122.00000
2                105               0.1          239.20000
3                 50               0.1          313.12000
4                  5               0.1          349.43200
5                 30               0.1          414.37520
6                 70               0.1          525.81272

编辑：为numba和普通python（1m行）添加了时间

df= pd.DataFrame({'Payment_Shortfall':np.random.random(10**6)*10}))
df['Monthly_Interest'] = -0.01

def compute_total_amount_python(interest, amount):
  n = len(interest)
  total_amount = np.empty(n)
  total_amount[0] = amount[0]
  for i in range(1,n):
    total_amount[i] = total_amount[i-1]*(1+interest[i])+amount[i]
  return total_amount

%timeit compute_total_amount_python(df['Monthly_Interest'].values, df['Payment_Shortfall'].values)
729 ms ± 36.3 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

%timeit compute_total_amount(df['Monthly_Interest'].values, df['Payment_Shortfall'].values)
2.7 ms ± 62.7 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

通过对列中的先前值求和并相乘，在Pandas中创建一列

1 个答案: