Question

我正在尝试在count中返回unique个值中的一个pandas df。这是每个row的累积计数。我的目标是合并一个函数，该函数确定在任何时间点当前正在出现多少个值。

import pandas as pd

df = pd.DataFrame({          
    'A' : ['8:06:00','11:00:00','11:30:00','12:00:00','13:00:00','13:30:00','14:00:00','17:00:00'],
    'B' : ['ABC','ABC','DEF','XYZ','ABC','LMN','DEF','ABC'],          
    'C' : [1,2,1,1,3,1,2,4],            
    })

          A    B  C
0   8:06:00  ABC  1
1  11:00:00  ABC  2
2  11:30:00  DEF  1
3  12:00:00  XYZ  1
4  13:00:00  ABC  3
5  13:30:00  LMN  1
6  14:00:00  DEF  2
7  17:00:00  ABC  4

因此unique中有4个col['B']值。我正在通过

进行测量

df1 = df['B'].nunique()

但是我希望通过iterates并入column函数，以识别是否再次出现任何特定值。如果没有，我希望减少计数。如果是第一次出现该值，我想增加计数。如果该值已经出现并再次出现，则计数应保持不变。这将显示在任何时间点出现多少个值。

使用@jpp的代码，我们产生以下内容：

cum_maxer = pd.Series(pd.factorize(df['B'])[0] + 1).cummax()
df['res'] = cum_maxer - df['B'].duplicated().cumsum()

print(df)

出局：

          A    B  C  res
0   8:06:00  ABC  1    1
1  11:00:00  ABC  2    0
2  11:30:00  DEF  1    1
3  12:00:00  XYZ  1    2
4  13:00:00  ABC  3    1
5  13:30:00  LMN  1    2
6  14:00:00  DEF  2    1
7  17:00:00  ABC  4    0

'res'的预期输出

基本上，如果value第一次出现，我想将其添加到cumulative count中。如果该值完成（以后不再显示），则计数应减少。如果值已经出现并再次出现，则计数应保持不变。

每行的概要以及预期的输出：

1st row，ABC首次出现，随后出现。 Count = +1

2nd row，ABC再次出现，因此没有增加。稍后还会出现，因此不会减少。 Count = no change

3rd row，DEF首次出现，随后出现。 Count = +1

4th row，XYZ首次出现，但以后没有出现。但是，在此时间点，正在发生3个值，因此count is 3。计数自动降为XYZ has finished

如上所述，

5th row已完成XYZ，因此目前只有ABC和DEF处于打开状态。 ABC的值也会再次出现，因此count is 2。

6th row，LMN首次出现，因此计数增加。这意味着ABC, DEF, LMN在该时间点是最新的。与row 4类似，LMN不会再出现，因此随着LMN完成，计数将在下一行减少。 Count is 3

第7行DEF和ABC当前处于启用状态，因此count is 2。由于DEF不再出现，因此计数将在下一行减少。

第8行，ABC是当前唯一的count is 1值。

Answer 1

您也可以使用np.unique

u = np.unique(df.B, return_index=True)
df['id'] = df.B.map(dict(zip(*u))) + 1

0    1
1    2
2    3
3    1
4    2
5    1

编辑问题

对于您编辑的问题，这是一个解决方案。首先，在倒置的数据框中使用cumcount 查看未来

df['u'] = df[::-1].groupby('B').B.cumcount()

这样u说出当前B在未来的每个B中出现了多少次。然后，使用您的逻辑，zip B和u，使用S_n = S_{n-1} + new_value + dec，其中new_value一个标志，如果当前True为val是一个新值，如果上一行最后一次出现该值（即当时的dec），则True是u==0。代码就像

ids = [1]
seen = set([df.iloc[0].B])
dec = False
for val, u in zip(df.B[1:], df.u[1:]):
    ids.append(ids[-1] + (val not in seen) - dec)
    seen.add(val)
    dec = u == 0

df['S'] = ids

    A           B   C   u   S   expected
0   8:06:00     ABC 1   3   1          1
1   11:00:00    ABC 2   2   1          1
2   11:30:00    DEF 1   1   2          2
3   12:00:00    XYZ 1   0   3          3
4   13:00:00    ABC 3   1   2          2
5   13:30:00    LMN 1   0   3          3
6   14:00:00    DEF 2   0   2          2
7   17:00:00    ABC 4   0   1          1

其中

>>> (df.S == df.expected).all()
True

时间

df = pd.DataFrame({          
'A' : ['8:06:00','11:00:00','11:30:00','12:00:00','13:00:00','13:30:00','14:00:00','17:00:00'],
'B' : ['ABC','ABC','DEF','XYZ','ABC','LMN','DEF','ABC'],          
'C' : [1,2,1,1,3,1,2,4],            
})

def matt(df):
    valsets = df['B'].apply(lambda x: {x})
    union_sets = np.frompyfunc(lambda x, y: x | y, 2, 1)
    intersect_count = np.frompyfunc(lambda x, y: len(x & y), 2, 1)

    seen = union_sets.accumulate(valsets, dtype=np.object)
    to_be_seen = union_sets.accumulate(valsets[::-1], dtype=np.object)[::-1]
    df['res'] = intersect_count(seen, to_be_seen)
    return df

def raf(df):
    ids = [1]
    seen = set([df.iloc[0].B])
    dec = False
    df['u'] = df[::-1].groupby('B').B.cumcount()
    for val, u in zip(df.B[1:], df.u[1:]):
        ids.append(ids[-1] + (val not in seen) - dec)
        seen.add(val)
        dec = u == 0

    df['S'] = ids
    return df

df = pd.concat([df]*10000).reset_index()

结果

%timeit matt(df)
168 ms ± 12.9 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
%timeit raf(df)
64.2 ms ± 2.04 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

Answer 2

更新速度更快

我希望在我给出以下答案之前，我已经注意到@RafaelC的groupby.cumcount()技术。这给了我一个更快的方法的想法。正如@RafaelC所注意到的那样，当您在行中进行工作时，无需使用完整的观察值列表。只需知道当前符号早晚出现几次即可。实际上，正如您在更新中所指出的那样，您真正需要知道的是当前行中的符号是否是第一次出现（将1加到计数中）以及上一行中的符号是否刚刚出现了。最后一次（从计数中减去1）。考虑到这一点，您可以使用以下相当简单且精简的代码：

将numpy导入为np，将熊猫导入为pd

import numpy as np, pandas as pd

df = pd.DataFrame({          
    'A' : ['8:06:00','11:00:00','11:30:00','12:00:00','13:00:00','13:30:00','14:00:00','17:00:00'],
    'B' : ['ABC','ABC','DEF','XYZ','ABC','LMN','DEF','ABC'],          
    'C' : [1,2,1,1,3,1,2,4],            
})

groups = df.groupby('B')['B']
# flag the first and last appearance of each symbol
first_appearance = (groups.cumcount() == 0).astype(int)
last_appearance = (groups.cumcount(False) == 0).astype(int)
# delay effect of last_appearance by one step
last_appearance = pd.np.concatenate(([0], last_appearance.values[:-1]))
df['res'] = (first_appearance - last_appearance).cumsum()
print df
#           A    B  C  res
# 0   8:06:00  ABC  1    1
# 1  11:00:00  ABC  2    1
# 2  11:30:00  DEF  1    2
# 3  12:00:00  XYZ  1    3
# 4  13:00:00  ABC  3    2
# 5  13:30:00  LMN  1    3
# 6  14:00:00  DEF  2    2
# 7  17:00:00  ABC  4    1

调用此matthias2并重新运行@RafaelC的基准测试将得到以下结果：

%timeit matthias1(df)
10 loops, best of 3: 109 ms per loop
%timeit raf(df)
1 loops, best of 3: 230 ms per loop
%timeit matthias2(df)
100 loops, best of 3: 7 ms per loop

原始答案，相对较慢

下面的代码怎么样？这样的想法是使用两个累积集：一个显示从列表开始到现在的所有项目，另一个显示列表中尚未看到的所有项目。可以通过与第一个集合相同的方式来创建后一个集合，只需反转列表，构建累积集合，然后再次反转列表即可。

Pandas没有通用的accumulate函数来执行此操作。您可能可以使用pd.Series.expanding到达那里，但是这会在每一步重新积累系列的大部分，这会产生较慢的n ^ 2时间依赖性。因此，我使用了numpy的{{1}}函数来构建集合，如下所示。这样应该可以非常有效地运行，并且应该很清楚。

accumulate

请注意，我将中间向量存储在数据帧中，以便您了解算法的工作原理。但是没有必要在生产代码中这样做。

Answer 3

您可以使用pd.factorize为每个唯一值分配一个整数标识符，然后在结果上使用cummax进行滚动计数。

drop_duplicates()

更新

对于所需的输出，您可以像以前一样计算inplace=True并减去重复的累积计数：

df['id'] = pd.factorize(df['B'])[0] + 1
df['count'] = df['id'].cummax()

print(df)

          A    B  C  id  count
0   8:06:00  ABC  1   1      1
1  11:00:00  DEF  1   2      2
2  12:00:00  XYZ  1   3      3
3  13:00:00  ABC  2   1      3
4  13:30:00  LMN  1   4      4
5  14:00:00  DEF  2   2      4
6  17:00:00  ABC  3   1      4

熊猫df

3 个答案:

编辑问题

时间

结果