Pandas DataFrame宽表重塑：按固定列数分组并堆叠为长表

import pandas as pd
import numpy as np

# 模拟一个宽格式的DataFrame
np.random.seed(123)
df_wide = pd.DataFrame(np.random.randint(10, size=(3, 12)))
print("原始宽格式DataFrame:")
print(df_wide)
# 输出:
#    0  1  2  3  4  5  6  7  8  9  10  11
# 0  2  2  6  1  3  9  6  1  0  1   9   0
# 1  0  9  3  4  0  0  4  1  7  3   2   4
# 2  7  2  4  8  0  7  9  3  4  6   1   5

# 检查列数是否是目标列数N的倍数
N = 6
if len(df_wide.columns) % N != 0:
    print(f"警告：原始列数 {len(df_wide.columns)} 不是 {N} 的整数倍，此方法可能不适用或需调整。")
else:
    print(f"\n原始DataFrame列数: {len(df_wide.columns)}")
    print(f"列数 {len(df_wide.columns)} 是 {N} 的整数倍: {len(df_wide.columns) % N == 0}")

    # 定义目标DataFrame的列名
    target_columns = ['GroupA', 'GroupB', 'GroupC', 'GroupD', 'GroupE', 'GroupF']

    # 使用numpy.reshape进行重塑
    df_target = pd.DataFrame(df_wide.to_numpy().reshape(-1, N),
                             columns=target_columns)

    print("\n重塑后的目标DataFrame:")
    print(df_target)
    # 输出:
    #    GroupA  GroupB  GroupC  GroupD  GroupE  GroupF
    # 0       2       2       6       1       3       9
    # 1       6       1       0       1       9       0
    # 2       0       9       3       4       0       0
    # 3       4       1       7       3       2       4
    # 4       7       2       4       8       0       7
    # 5       9       3       4       6       1       5

import pandas as pd
import numpy as np

# 模拟一个宽格式的DataFrame，列数不是6的倍数
np.random.seed(123)
df_wide_uneven = pd.DataFrame(np.random.randint(10, size=(3, 10)))
print("原始宽格式DataFrame (列数非倍数):")
print(df_wide_uneven)
# 输出:
#    0  1  2  3  4  5  6  7  8  9
# 0  2  2  6  1  3  9  6  1  0  1
# 1  9  0  0  9  3  4  0  0  4  1
# 2  7  3  2  4  7  2  4  8  0  7

N = 6
print(f"\n原始DataFrame列数: {len(df_wide_uneven.columns)}")
print(f"列数 {len(df_wide_uneven.columns)} 是 {N} 的整数倍: {len(df_wide_uneven.columns) % N == 0}")

# 定义目标DataFrame的列名
target_columns = ['GroupA', 'GroupB', 'GroupC', 'GroupD', 'GroupE', 'GroupF']

# 创建列索引数组
a = np.arange(len(df_wide_uneven.columns))

# 构建MultiIndex并堆叠
df_target_uneven = (df_wide_uneven.set_axis([a % N, a // N], axis=1) # 创建MultiIndex: (列内序号, 组号)
                                  .stack()                             # 堆叠最内层索引 (组号)
                                  .set_axis(target_columns, axis=1)  # 重命名列
                                  .reset_index(drop=True))           # 重置索引

print("\n重塑后的目标DataFrame (处理非倍数列数):")
print(df_target_uneven)
# 输出:
#    GroupA  GroupB  GroupC  GroupD  GroupE  GroupF
# 0       2       2       6       1     3.0     9.0
# 1       6       1       0       1     NaN     NaN
# 2       9       0       0       9     3.0     4.0
# 3       0       0       4       1     NaN     NaN
# 4       7       3       2       4     7.0     2.0
# 5       4       8       0       7     NaN     NaN