将宽格式DataFrame重塑为垂直结构：Pandas与NumPy的实践指南

import pandas as pd
import numpy as np

# 模拟一个宽格式DataFrame
# 实际应用中，你会从CSV文件加载
# df = pd.read_csv("groups.csv")

# 示例数据：3行12列，每6列为一组
np.random.seed(123)
df = pd.DataFrame(np.random.randint(10, size=(3, 12)))
print("原始DataFrame:")
print(df)

原始DataFrame:
   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

# 假设目标是每6列为一组
target_cols_per_group = 6
total_columns = len(df.columns)

print(f"原始DataFrame总列数: {total_columns}")
print(f"总列数 % {target_cols_per_group} = {total_columns % target_cols_per_group}")

if total_columns % target_cols_per_group == 0:
    print("列数是目标组大小的倍数，可以使用NumPy的reshape方法。")
else:
    print("列数不是目标组大小的倍数，需要使用更通用的Pandas方法。")

# 定义新DataFrame的列名
new_columns = ['GroupA', 'GroupB', 'GroupC', 'GroupD', 'GroupE', 'GroupF']

# 将DataFrame转换为NumPy数组，然后重塑
# df.to_numpy().reshape(-1, target_cols_per_group) 会将所有数据展平后按6列重新组织
# 但这里我们希望保持原始行结构，即每行的数据作为一个整体被重新组织
# 正确的做法是先将整个DataFrame展平，再进行重塑
# 错误的理解可能导致：df.to_numpy().reshape(len(df) * (total_columns // target_cols_per_group), target_cols_per_group)
# 实际上，`df.to_numpy()`会返回一个 (rows, cols) 的数组
# 如果我们想把 (3, 12) 变成 (6, 6)，我们需要先展平为 (36,)，再重塑为 (6, 6)
# 或者更直接地，将整个DataFrame的数据视为一个整体进行重塑
df_target_numpy = pd.DataFrame(df.to_numpy().reshape(-1, target_cols_per_group),
                               columns=new_columns)
print("\n使用NumPy reshape重塑后的DataFrame:")
print(df_target_numpy)

使用NumPy reshape重塑后的DataFrame:
   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

# 示例数据：3行10列，每6列为一组，但10不是6的倍数
np.random.seed(123)
df_uneven = pd.DataFrame(np.random.randint(10, size=(3, 10)))
print("\n原始DataFrame (列数非倍数):")
print(df_uneven)

total_columns_uneven = len(df_uneven.columns)
print(f"原始DataFrame总列数: {total_columns_uneven}")
print(f"总列数 % {target_cols_per_group} = {total_columns_uneven % target_cols_per_group}")

# 为列创建多级索引
# level0_index: 0, 0, 0, 0, 0, 0, 1, 1, 1, 1 (表示第几组)
# level1_index: 0, 1, 2, 3, 4, 5, 0, 1, 2, 3 (表示组内第几列)
a = np.arange(total_columns_uneven)
multi_index_level0 = a // target_cols_per_group # 组索引
multi_index_level1 = a % target_cols_per_group  # 组内列索引

# 设置多级列索引
df_multi_indexed = df_uneven.set_axis([multi_index_level1, multi_index_level0], axis=1)
print("\n设置多级索引后的DataFrame:")
print(df_multi_indexed)

# 堆叠数据
# stack()默认会堆叠最内层的列索引（即multi_index_level1）
df_stacked = df_multi_indexed.stack()
print("\n堆叠后的DataFrame:")
print(df_stacked)

# 重命名列并重置索引
df_target_pandas = df_stacked.set_axis(new_columns, axis=1).reset_index(drop=True)
print("\n使用Pandas MultiIndex和stack重塑后的DataFrame:")
print(df_target_pandas)

原始DataFrame (列数非倍数):
   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

设置多级索引后的DataFrame:
   0  1  2  3  4  5  0  1  2  3
   0  0  0  0  0  0  1  1  1  1
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

堆叠后的DataFrame:
      0  1  2  3  4  5
0 0   2  2  6  1  3  9
  1   6  1  0  1  9  0
1 0   0  9  3  4  0  0
  1   4  1  7  3  2  4
2 0   7  3  2  4  7  2
  1   4  8  0  7  NaN  NaN

使用Pandas MultiIndex和stack重塑后的DataFrame:
   GroupA  GroupB  GroupC  GroupD  GroupE  GroupF
0       2       2       6       1     3.0     9.0
1       6       1       0       1     9.0     0.0
2       0       9       3       4     0.0     0.0
3       4       1       7       3     2.0     4.0
4       7       3       2       4     7.0     2.0
5       4       8       0       7     NaN     NaN