Question

我有一个数据框：

df = pd.DataFrame({
    'A': [1,2,3,4],
    'B': [12,23,34,45]
})

看起来像

----------------------------
index         A        B
0             1       12
1             2       23
2             3       34
3             4       45
-----------------------------

我有很多时间，[0,1,2]。我想每次df复制行A和B：

------------------------------------
index         A        B     time
              1       12       0
              1       12       1
              1       12       2
              2       23       0
              2       23       1
              2       23       2
              3       34       0
              3       34       1
              3       34       2
              4       45       0
              4       45       1
              4       45       2
-------------------------------------

我不想使用MultiIndex或Stack（因为我希望它尽可能平整）。合并无济于事。我没有加入，因为我正在尝试进行组合，因此“合并/合并”似乎无济于事。

Answer 1

也许使用pd.concat比reindex快

pd.concat([df]*len([0,1,2])).sort_index().assign(time=[0,1,2]*len(df))
Out[275]: 
   A   B  time
0  1  12     0
0  1  12     1
0  1  12     2
1  2  23     0
1  2  23     1
1  2  23     2
2  3  34     0
2  3  34     1
2  3  34     2
3  4  45     0
3  4  45     1
3  4  45     2

Answer 2

IIUC，使用reindex + repeat

o = df.shape[0]
df = df.reindex(df.index.repeat(len(times))).reset_index(drop=True)
df['time'] = times*o

    A   B   time
0   1   12  0
1   1   12  1
2   1   12  2
3   2   23  0
4   2   23  1
5   2   23  2
6   3   34  0
7   3   34  1
8   3   34  2
9   4   45  0
10  4   45  1
11  4   45  2

性能检查：

%timeit df.reindex(df.index.repeat(len(times))).reset_index(drop=True).assign(time=times*df.shape[0])
675 µs ± 12.6 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

%timeit pd.concat([df]*len([0,1,2])).sort_index().assign(time=[0,1,2]*len(df))
812 µs ± 6 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

对于小型dfs，和

%timeit df.reindex(df.index.repeat(len(times))).reset_index(drop=True).assign(time=times*df.shape[0])
237 ms ± 3.68 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

%timeit pd.concat([df]*len([0,1,2])).sort_index().assign(time=[0,1,2]*len(df))
5.78 ms ± 27 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

用于大型dfs

数据框和系列的熊猫组合

2 个答案: