如果可以保证总行数是5的倍数，那么使用numpy将是解决这个问题的最有效方法：

import numpy as np
import pandas as pd

data = np.arange(70).reshape(-1, 7)
df = pd.DataFrame(data, columns=[*'ABCDEFG'])

print(df)
    A   B   C   D   E   F   G
0   0   1   2   3   4   5   6
1   7   8   9  10  11  12  13
2  14  15  16  17  18  19  20
3  21  22  23  24  25  26  27
4  28  29  30  31  32  33  34
5  35  36  37  38  39  40  41
6  42  43  44  45  46  47  48
7  49  50  51  52  53  54  55
8  56  57  58  59  60  61  62
9  63  64  65  66  67  68  69

out = pd.DataFrame(
    df.to_numpy().reshape(-1, df.shape[1] * 5),
    columns=[*df.columns] * 5
)

print(out)
    A   B   C   D   E   F   G   A   B   C   D   E   F  ...   B   C   D   E   F   G   A   B   C   D   E   F   G
0   0   1   2   3   4   5   6   7   8   9  10  11  12  ...  22  23  24  25  26  27  28  29  30  31  32  33  34
1  35  36  37  38  39  40  41  42  43  44  45  46  47  ...  57  58  59  60  61  62  63  64  65  66  67  68  69

[2 rows x 35 columns]

您可以：

cols = [col for v in [df.columns.tolist()]*len(df) for col in v]
dfs = [df[i:min(i+5,len(df))].reset_index(drop=True) for i in range(0,len(df),5)]
df2 = pd.concat([pd.DataFrame(df.stack()).T for df in dfs])
df2.columns = cols
df2.reset_index(drop=True, inplace=True)

看看这是否有助于回答你的问题unstack turns the columns into the rows，并且一旦我们在一个column中有数据，我们只需要它被转置. reset_index makes the resulting series into a dataframe.这原始的columns name被制作成一个索引，所以当我们转置时我们有你在你的columns中陈述的列.

df.unstack().reset_index().set_index('level_0')[[0]].T

level_0 A   A   A   A   A   B   B   B   B   B   ... F   F   F   F   F   G   G   G   G   G
0   10  17  24  31  38  11  18  25  32  39  ... 15  22  29  36  43  16  23  30  37  44

投票和/或如果答案有帮助则接受

最简单的方法是把你的 Dataframe 转换成一个numpy数组，重新整形，然后把它转换回一个新的 Dataframe 。
编辑：

data= # your dataframe
new_dataframe=pd.DataFrame(data.to_numpy().reshape(len(data)//5,-1),columns=np.tile(data.columns,5))

Pandas数据的叠加与解叠加

表格中的数据通常以多种方式呈现。长格式（“整齐数据”）指的是堆叠在两列中的数据。其中一列将包含有关值的分类指示符。相比之下，宽格式（“堆叠数据”）是指每个类别都有自己的列。
在本例中，我们展示了宽格式的数据，并试图将其转换为长格式，pandas.melt、pandas.groupby、pandas.pivot、pandas.stack、pandas.unstack和pandas.reset_index函数可以帮助在这些格式之间进行转换。

从原始 Dataframe 开始：

df = pd.DataFrame({
   'A' : [10, 17, 24, 31, 38],
   'B' : [11, 18, 25, 32, 39],
   'C' : [12, 19, 26, 33, 40],
   'D' : [13, 20, 27, 34, 41],
   'E' : [14, 21, 28, 35, 42],
   'F' : [15, 22, 29, 36, 43],
   'G' : [16, 23, 30, 37, 44]})

    A   B   C   D   E   F   G
0   10  11  12  13  14  15  16
1   17  18  19  20  21  22  23
2   24  25  26  27  28  29  30
3   31  32  33  34  35  36  37
4   38  39  40  41  42  43  44

**使用panda.melt将其转换为长格式，然后排序以获得您所请求的数据：**忽略索引选项帮助我们稍后将其恢复为宽格式。

melted_df = df.melt(ignore_index=False).sort_values(by='value')

variable    value
0   A   10
0   B   11
0   C   12
0   D   13
0   E   14
0   F   15
0   G   16
1   A   17
1   B   18
...

**使用groupby、unstack和reset_index将其转换回宽格式。**这通常是一个困难得多的过程，它依赖于按值堆栈列、其他列、索引和堆栈变量进行分组，然后取消堆栈并重置索引。

(melted_df
    .reset_index() # puts the index values into a column called 'index'
    .groupby(['index','variable']) #groups by the index and the variable
    .value  #selects the value column in each of the groupby objects
    .mean() #since there is only one item per group, it only aggregates one item
    .unstack() #this sets the first item of the multi-index to columns
    .reset_index() #fix the index
    .set_index('index') #set index
)
    A   B   C   D   E   F   G                           
0   10  11  12  13  14  15  16
1   17  18  19  20  21  22  23
2   24  25  26  27  28  29  30
3   31  32  33  34  35  36  37
4   38  39  40  41  42  43  44

这些东西可能相当困难，需要反复试验。我建议你对你的问题做一个小版本，然后把它们弄乱。这样你就可以弄清楚函数是如何工作的。

尝试使用arange()和floordiv每隔5进行分组，然后用这些分组创建一个新的df。即使df不能被5整除，这也应该可以工作。

l = 5
(df.groupby(np.arange(len(df.index))//l)
 .apply(lambda x: pd.DataFrame([x.to_numpy().ravel()]))
 .set_axis(df.columns.tolist() * l,axis=1)
 .reset_index(drop=True))

或

(df.groupby(np.arange(len(df.index))//5)
.apply(lambda x: x.reset_index(drop=True).unstack()).droplevel(1,axis=1))

输出：

A  B  C  D  E  F  G  A  B  C  ...  E  F  G  A  B  C  D  E  F  G
0  9  0  3  2  6  2  9  1  7  5  ...  2  5  9  5  4  9  7  3  8  9
1  9  5  0  8  1  5  8  7  7  7  ...  6  3  5  5  2  3  9  7  5  6