Python 我如何从中的累计和中获取实际值

假设我有一个数据帧df

>>> DATA = {'id':[1,2,3,4,5], 'salary':[1200,2300,2400,3620,2100] } 
>>> df = DataFrame(DATA)
>>> df
   id  salary
0   1    1200
1   2    2300
2   3    2400
3   4    3620
4   5    2100

从这个数据帧df中，我可以得到一个新的数据帧df1，它具有工资的累计和

>>> df['salary'] = df['salary'].cumsum() 
>>> df
   id  salary
0   1    1200
1   2    3500
2   3    5900
3   4    9520
4   5   11620

这是非常常见的情况

现在，如果给我df1，我必须找到df，那该怎么办

   id  salary            id  salary
0   1    1200             0   1    1200
1   2    3500             1   2    2300
2   3    5900     ==>     2   3    2400
3   4    9520             3   4    3620
4   5   11620             4   5    2100

我所要做的就是从所有id的累计金额中找出实际工资

>>> df
   id  salary
0   1    1200
1   2    3500
2   3    5900
3   4    9520
4   5   11620
>>> df['salary'] = df['salary'].diff().fillna(df['salary'].iloc[0])
>>> df
   id  salary
0   1    1200
1   2    2300
2   3    2400
3   4    3620
4   5    2100

虽然

.fillna

在这里效率不高，因为它只是第一个空值。因此，您只需将第一个值替换为

.iloc[0]

处的累积值

---

虽然

.fillna

在这里效率不高，因为它只是第一个空值。因此，只需将第一个值替换为

.iloc[0]

处的累积值，如果序列/列包含NaN，则需要更加小心

In [11]: df.loc[2, 'salary'] = np.nan

In [12]: df
Out[12]:
   id  salary
0   1    1200
1   2    2300
2   3     NaN
3   4    3620
4   5    2100

In [13]: df['salary'].cumsum()
Out[13]:
0    1200
1    3500
2     NaN
3    7120
4    9220
Name: salary, dtype: float64

In [14]: df['salary'] = df['salary'].cumsum()

我们实际上可以回到原始版本，因为NaN的被跳过了，我们只是跳过了它们：

In [21]: s
Out[21]:
0    1200
1    3500
3    7120
4    9220
Name: salary, dtype: float64

In [22]: d = s.diff()

In [23]: d.iloc[0] = s.iloc[0]

In [24]: d
Out[24]:
0    1200
1    2300
3    3620
4    2100
Name: salary, dtype: float64

现在，我们可以将其分配回“薪资”列（缺少的值变为NaN）：

注意：如果索引不是唯一的，这将不起作用，但您可以使用以下方法来欺骗它：

df.loc[df['salary'].notnull(), "salary"] = s  # or s.values

---

如果序列/列包含NaN，则需要更加小心

In [11]: df.loc[2, 'salary'] = np.nan

In [12]: df
Out[12]:
   id  salary
0   1    1200
1   2    2300
2   3     NaN
3   4    3620
4   5    2100

In [13]: df['salary'].cumsum()
Out[13]:
0    1200
1    3500
2     NaN
3    7120
4    9220
Name: salary, dtype: float64

In [14]: df['salary'] = df['salary'].cumsum()

我们实际上可以回到原始版本，因为NaN的被跳过了，我们只是跳过了它们：

In [21]: s
Out[21]:
0    1200
1    3500
3    7120
4    9220
Name: salary, dtype: float64

In [22]: d = s.diff()

In [23]: d.iloc[0] = s.iloc[0]

In [24]: d
Out[24]:
0    1200
1    2300
3    3620
4    2100
Name: salary, dtype: float64

现在，我们可以将其分配回“薪资”列（缺少的值变为NaN）：

注意：如果索引不是唯一的，这将不起作用，但您可以使用以下方法来欺骗它：

df.loc[df['salary'].notnull(), "salary"] = s  # or s.values

---

如果累计和发生两次呢。。第一次0比2，第二次3比4？哦。。我懂了。我只需要将df int拆分为两个dataframe，我不认为您需要在一行中执行此操作（正如您自己所说）：

s=df['salary'；df['salary']=s.diff（）；df['salary'].iloc[0]=s.iloc[0]

。如果有NaN，则实际发布了另一个答案，也不太坏。如果很多地方有NaN值，此答案就不起作用。您的

fillna（）

也不能正常工作！如果累计和发生两次呢。。第一次0比2，第二次3比4？哦。。我懂了。我只需要将df int拆分为两个dataframe，我不认为您需要在一行中执行此操作（正如您自己所说）：

s=df['salary'；df['salary']=s.diff（）；df['salary'].iloc[0]=s.iloc[0]

。实际上，如果存在NaN，则发布了另一个答案，这并不糟糕。如果在许多地方存在NaN值，则此答案不起作用。您的

fillna（）

也不能正常工作！