pandas - 计算 Pandas 数据框中与不同值交错的重复项

Question

这是我的数据的一个非常简化的版本:

    ╔═════════╤═══════════╗
    ║ user_id │ module_id ║
    ╠═════════╪═══════════╣
    ║ 1       │ 1         ║
    ╟─────────┼───────────╢
    ║ 1       │ 1         ║
    ╟─────────┼───────────╢
    ║ 1       │ 2         ║
    ╟─────────┼───────────╢
    ║ 1       │ 1         ║
    ╟─────────┼───────────╢
    ║ 2       │ 2         ║
    ╟─────────┼───────────╢
    ║ 2       │ 1         ║
    ╟─────────┼───────────╢
    ║ 2       │ 2         ║
    ╟─────────┼───────────╢
    ║ 2       │ 2         ║
    ╟─────────┼───────────╢
    ║ 2       │ 1         ║
    ╟─────────┼───────────╢
    ║ 2       │ 2         ║
    ╚═════════╧═══════════╝

这是我想添加的专栏:

    ╔═════════╤═══════════╤════════════════════╗
    ║ user_id │ module_id │ repeated_module_id ║
    ╠═════════╪═══════════╪════════════════════╣
    ║ 1       │ 1         │ NaN                ║
    ╟─────────┼───────────┼────────────────────╢
    ║ 1       │ 1         │ NaN                ║
    ╟─────────┼───────────┼────────────────────╢
    ║ 1       │ 2         │ NaN                ║
    ╟─────────┼───────────┼────────────────────╢
    ║ 1       │ 1         │ 1                  ║
    ╟─────────┼───────────┼────────────────────╢
    ║ 2       │ 2         │ NaN                ║
    ╟─────────┼───────────┼────────────────────╢
    ║ 2       │ 1         │ NaN                ║
    ╟─────────┼───────────┼────────────────────╢
    ║ 2       │ 2         │ 2                  ║
    ╟─────────┼───────────┼────────────────────╢
    ║ 2       │ 2         │ NaN                ║
    ╟─────────┼───────────┼────────────────────╢
    ║ 2       │ 1         │ 1                  ║
    ╟─────────┼───────────┼────────────────────╢
    ║ 2       │ 2         │ 2                  ║
    ╚═════════╧═══════════╧════════════════════╝

即如果用户以前做过某个模块，但不会立即重复该模块。

我想要一个矢量化的 pandas 方法来推导它，但我不知道如何开始。

Answer 1

你可以在整个框架上使用duplicated来检查user_id 和 module_id，你不应该需要一个groupby + apply。然后它就像根据您的初始帧进行 mask 一样简单。

m1 = df['module_id'].ne(df['module_id'].shift())
m2 = df.duplicated(['user_id', 'module_id'])

df['module_id'].where(m1 & m2)

0    NaN
1    NaN
2    NaN
3    1.0
4    NaN
5    NaN
6    2.0
7    NaN
8    1.0
9    2.0
Name: module_id, dtype: float64

---

这应该比apply

快很多

df = pd.DataFrame({
    'user_id': np.random.randint(1, 100, 10_000),
    'module_id': np.random.randint(1, 10, 10_000)
})

In [285]: %%timeit
     ...:     m1 = df['module_id'].ne(df['module_id'].shift())
     ...:     m2 = df.duplicated(['user_id', 'module_id'])
     ...:     df['module_id'].where(m1 & m2)
     ...:
2.56 ms ± 199 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

In [302]: %%timeit
     ...: df.loc[df.groupby('user_id')['module_id'].apply(lambda x:
     ...:         x.ne(x.shift())&x.duplicated()),'module_id']
     ...:
92.6 ms ± 1.29 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)