Question

我是python pandas的新手。我想估算一段时间内考虑费用和增长的流入付款的价值。我只使用一次付款（流入）来测试。有时费用2可以适用于期间n-t。即不是整个时期，n。

我是这样做的，只是想知道是否有更好的方法来重新计算值而不循环？

电子表格中的示例：

Python代码：

import pandas as pd
import numpy as np

def getCashFlows():
   term = 2
   growthRate = (1+0.06)**(1/12) - 1
   df = pd.DataFrame(list(range(1,term*12+1)), columns=['t'])
   df['Value_t_1'] = 0
   df['Inflow1']=0
   df['growth']=0
   df['ValuePlusGrowth'] = 0
   df['fee1']=0
   df['fee2']=30
   df['Value_t']=0

   df.set_value(0, 'Inflow1', 10000)

   for i in range(0,term*12):
      df['Value_t_1'] = df['Value_t'].shift()
      df['Value_t_1'].fillna(0,inplace=True)

      df['growth'] = (df['Value_t_1'] + df['Inflow1'])*growthRate
      df['ValuePlusGrowth'] = df['Value_t_1']+df['Inflow1']+df['growth']
      df['fee1']=df['ValuePlusGrowth']*0.5/100
      df['Value_t'] = df['ValuePlusGrowth'] - df['fee1'] - df['fee2']
   return df

Answer 1

唯一真正需要的初始输入是inflow的初始值。其他所有内容都可以简化为基于行索引重复设定次数的操作。数据框中的一些列实际上只是常量。

这是一个解决方案，阐明了计算数据框每一行所需的操作：

import pandas as pd

class GrowthTracker(object):

    def __init__(self, n_iter):

        self.colnames = ['Value_t_1', 'growth', 'ValuePlusGrowth', 'fee1', 'Value_t']
        self.data = None
        self.fee1_mult = 0.5/100
        self.fee2 = (0,0,0,0,30)
        self.growthRate = (1+0.06)**(1/12) - 1
        self.n_iter = n_iter
        self.ops = pd.Series([1, # Value_t_1
                              self.growthRate, # growth
                              (1 + self.growthRate), # ValuePlusGrowth
                              (1 + self.growthRate) * self.fee1_mult, # fee1
                              (1 + self.growthRate) * (1 - self.fee1_mult) # Value_t
                             ])

    def update(self, t, n, df=None):
        row = self.ops.mul(t).subtract(self.fee2)
        tmp = pd.concat([df, row], axis = 1, ignore_index=True)
        if n < self.n_iter: 
            self.data = self.update(row.iloc[-1], n+1, tmp)
            return self.data
        else:
            tmp.iloc[0,0] = 0 # remove the initial 10000 from Value_t_1
            self.data = tmp.T
            self.data.columns = self.colnames
            return self.data

现在只需设置初始值，实例化GrowthTracker对象和update()：

total_iter = 23

tracker = GrowthTracker(n_iter=total_iter)

inflow = 10000
start_index = 0

tracker.update(t=inflow, n=start_index)

tracker.data

      Value_t_1     growth  ValuePlusGrowth       fee1      Value_t
0      0.000000  48.675506     10048.675506  50.243378  9968.432128
1   9968.432128  48.521847     10016.953976  50.084770  9936.869206
2   9936.869206  48.368213      9985.237419  49.926187  9905.311232
3   9905.311232  48.214603      9953.525835  49.767629  9873.758206
4   9873.758206  48.061017      9921.819223  49.609096  9842.210127
5   9842.210127  47.907455      9890.117583  49.450588  9810.666995
6   9810.666995  47.753918      9858.420912  49.292105  9779.128808
7   9779.128808  47.600404      9826.729212  49.133646  9747.595566
8   9747.595566  47.446914      9795.042480  48.975212  9716.067268
9   9716.067268  47.293449      9763.360716  48.816804  9684.543913
10  9684.543913  47.140007      9731.683920  48.658420  9653.025500
11  9653.025500  46.986590      9700.012090  48.500060  9621.512030
12  9621.512030  46.833196      9668.345226  48.341726  9590.003500
13  9590.003500  46.679827      9636.683327  48.183417  9558.499910
14  9558.499910  46.526482      9605.026392  48.025132  9527.001260
15  9527.001260  46.373160      9573.374420  47.866872  9495.507548
16  9495.507548  46.219863      9541.727411  47.708637  9464.018774
17  9464.018774  46.066590      9510.085364  47.550427  9432.534937
18  9432.534937  45.913341      9478.448278  47.392241  9401.056037
19  9401.056037  45.760116      9446.816152  47.234081  9369.582072
20  9369.582072  45.606915      9415.188986  47.075945  9338.113041
21  9338.113041  45.453737      9383.566779  46.917834  9306.648945
22  9306.648945  45.300584      9351.949529  46.759748  9275.189781
23  9275.189781  45.147455      9320.337237  46.601686  9243.735551

我发现将这一切都表达为一个类更容易，但它很简单，只需在类外定义变量，然后运行update()函数即可。

<强>更新
以下是此解决方案背后的更多解释：

初始数据框df基本上是空的。唯一完全非零的列是t，从未使用过，fee2是常量（fee2 = 30）。 df的整个剩余部分以零值开头，Inflow1中第一个单元格除外 - 其第一个值为10000，其余值为零。

这意味着，就我们需要在计算上完成的工作而言，我们可以限制我们感兴趣的矩阵＆＃34;列Value_t_1，growth，ValuePlusGrowth，fee1和Value_t。

我们可以将第一个Inflow1值视为种子 - 其他一切只是对数字10000执行的一系列操作。（事实上，我们实际上并不需要Inflow1作为字段，因为在整个计算过程中其所有其他值都保持为零。）

在循环中，您最初使用其他列的值更新了列。这是有道理的，可能我也会这样做 - 看起来整洁有效。但是，回想一下，每次更新实际上只是一串数学，将其谱系追溯到原始10000。写出每个列更新的实际操作，而不是使用其他列名，显示了如何简化每个更新操作。

首先，一些简写符号：

t = Value_t from previous row (in case of the first row, Value_t = Inflow1 = 10000)
t1 = Value_t_1 
g = growth
inf = Inflow1 
vpg = ValuePlusGrowth
gr = growthRate # gr is a constant: (1+0.06)**(1/12) - 1
f1X = 0.5/100
new_t = Value_t for current row

我们从t = 10000开始。其他一切都是t上的一些操作。

每个值都可以用我们需要乘以t得到的值来表示，以便获得所需的值（我稍后会得到一个例外）。例如：

df['Value_t_1'] = df['Value_t'].shift()
df['Value_t_1'].fillna(0,inplace=True)

# equivalent to:
t1 = 1 * t # recall t is the shifted Value_t from the previous row

请注意，我们只需要将种子值t放入一次，然后只需对种子进行操作即可填充所有df。这意味着循环中的操作可以表示为＆＃34;需要乘以t的术语才能获得正确的列值＆＃34;。因此，虽然我们已经展示了t1 = 1 * t，但对我们来说，t1 = 1更有用 - 最终我们会将其乘以t，但右边是t1。该等式表示t与t1 = 1的关系。

然后：

# Inflow1 is always 0, except for its initial value which we capture in initial t, so:
df['growth'] = (df['Value_t_1'] + df['Inflow1'])*growthRate
# becomes:
g = t1 * gr 
# with t1 = 1
g = gr

# we know t1 = 1, and inf is never used as a multiplier, so:
df['ValuePlusGrowth'] = df['Value_t_1']+df['Inflow1']+df['growth']
# becomes:
vpg = 1 + g = 1 + gr

df['fee1']=df['ValuePlusGrowth']*0.5/100
# becomes:
fee1 = vpg * f1X = (1 + gr) * f1X

# we'll ignore subtracting fee2 for now, see notes below.
df['Value_t'] = df['ValuePlusGrowth'] - df['fee1'] - df['fee2']
# becomes:
new_t = vpg - fee1 = (1 + gr) - ((1 + gr) * f1X) = (1 + gr) * (1 - f1X)

ops = (t1, g, vpg, fee1, new_t)

下一步：

ops

现在，对于每一行，我们为每列提供了一组更新操作t。鉴于我们前一行有new_row = t * ops，我们可以使用以下内容填充每行的值：

fee2

我们仍然需要从new_t中减去fee2 = (0,0,0,0,30)，并且这并不完全适合直到此时为止的一系列乘法运算。但我们可以坚持使用我们的矢量化配方并定义：

new_row

每次fee2后，我们会从new_row向量中减去fee2向量，这实际上只是根据需要从new_t中减去new_row = t * ops - fee2。

t = 10000

此时，我们只需要一个以new_row开头的函数，并继续执行new_row公式，构建在前一行上，直到我们达到所需的迭代次数。我选择了一个递归策略来执行此操作，并在每个递归步骤中将每个t = 10000保存到数据框中。

最后，由于我通过设置Inflow1 = 10000而不是t1来略微滥用您的原始表示法，这意味着第一个10000值在update()处被错误设置。在t1函数的末尾，我们将第一个0值设置回reshape2。

根据其他字段重新计算pandas数据帧字段的更好方法

1 个答案: