Python 使用其他列的条件覆盖列上的select数据块

我有一个熊猫的数据框

import pandas as pd
inp = [{'c1':1, 'c2':100}, {'c1':1,'c2':110}, {'c1':1,'c2':120},{'c1':2, 'c2':130}, {'c1':2,'c2':140}, {'c1':2,'c2':150},
       {'c1':3, 'c2':160}, {'c1':3,'c2':170}, {'c1':3,'c2':180} , {'c1':2, 'c2':190}, {'c1':2,'c2':200}, {'c1':2,'c2':210},
       {'c1':4, 'c2':220}, {'c1':4,'c2':230}, {'c1':4,'c2':240}, {'c1':1, 'c2':250}, {'c1':1,'c2':260}, {'c1':1,'c2':270}
      ]
df = pd.DataFrame(inp)
print (df)

输出

    c1   c2
0    1  100
1    1  110
2    1  120
3    2  130
4    2  140
5    2  150
6    3  160
7    3  170
8    3  180
9    2  190
10   2  200
11   2  210
12   4  220
13   4  230
14   4  240
15   1  250
16   1  260
17   1  270

现在我想做几件事：

我想找出c1中的值在哪里变化，这可以通过

diff（）

然后我想平均c2的n值，从c1发生变化的地方开始。例如，如果n=2，我希望

平均值（100110）=105

平均值（130140）=135

平均值（160170）=165

平均值（190200）=195

平均值（220230）=225

平均值（250260）=255

请注意，

groupby（）

对此不起作用，因为c1的值可以向上和向下返回到一个较早的值，我希望跟踪c1中的变化，将该部分分段，而不考虑c1的值，并对该c1值块的下一个n值对c2进行算术运算

有什么建议吗？ 谢谢

尝试使用基于where

c1创建的组来更改：

n = 2
new_df = (
    df.groupby(df['c1'].ne(df['c1'].shift()).cumsum(), as_index=False)
        .agg(lambda g: g.head(n).mean())
)

new_df
：

   c1   c2
0   1  105
1   2  135
2   3  165
3   2  195
4   4  225
5   1  255


解释：

请参见下面的数据框：

explanation_df = pd.DataFrame({
    'c1': df['c1'],
    'c1.shift': df['c1'].shift(),
    'c1.ne.shift': df['c1'].ne(df['c1'].shift()),
    'c1.ne.shift.cumsum (groups)':
        df['c1'].ne(df['c1'].shift()).cumsum()
})

通过
shift
ing
c1
我们可以将每个
c1
与前一行进行比较。在这种情况下，比较为
ne
（不相等）。如果c1不等于前一行的值，则会出现
True
。因为当作为数字处理时，
True
值是
1
，
False
值是
0
，所以我们可以取累积和。每个
True
值都是
1
每个
False
值对累计和没有影响，因为
0
是累加标识

然后，这些值将成为
groupby
with的“组”。然后，使用
lambda
函数对每个组进行聚合，以获取带有
head
的第一个
n
值，然后从过滤后的组帧中获取
平均值。
谢谢，我的数据帧存在的问题是C1可能会上升和下降到相同的值，然而，我想对每个发生变化的部分进行平均运算。我尝试了groupby（），但没有得到我需要的结果，因为它将C1的多个部分分组，如果它们相同的话。数据是传感器数据采集的时间序列，我想从每次数据更改开始执行平均操作，无论以后是否重复not@user4298456检查编辑，看看是否如预期工作。这是相当棒的，谢谢。我需要在熊猫方面做得更好！请参见编辑说明。我认为更难的部分是c1.shift.ne.cumsum位，所以我把它放在一个框架中，这样可以并排看到步骤。太棒了，谢谢你的解释。我现在明白了
c1  c1.shift  c1.ne.shift  c1.ne.shift.cumsum (groups)
 1       NaN         True                            1
 1       1.0        False                            1
 1       1.0        False                            1
 2       1.0         True                            2
 2       2.0        False                            2
 2       2.0        False                            2
 3       2.0         True                            3
 3       3.0        False                            3
 3       3.0        False                            3
 2       3.0         True                            4
 2       2.0        False                            4
 2       2.0        False                            4
 4       2.0         True                            5
 4       4.0        False                            5
 4       4.0        False                            5
 1       4.0         True                            6
 1       1.0        False                            6
 1       1.0        False                            6