数据重构(3) -- 数据重构stack unstack

数据重构：stack 与 unstack

小象实战讲义 · Python数据分析实战

在数据分析中，我们常常需要将数据从一种“宽”格式转换为“长”格式，或者反之，以适应不同的分析需求。stack 和 unstack 是 Pandas 中用于实现这种数据重构的两个核心方法，它们专门用于处理具有层级索引（MultiIndex） 的数据结构。本节我们将深入理解这两个操作，掌握如何灵活地重塑数据视图。

💡 核心导读

• 适用对象：stack 和 unstack 专为具有层级索引（MultiIndex）的 Series 或 DataFrame 设计。
• 操作本质：stack 将数据的列旋转为行，而 unstack 将数据的行旋转为列。它们不进行聚合计算，仅改变数据的呈现结构。
• 关键参数 level：用于指定在哪个索引层级上进行旋转。层级从外向内编号为 0, 1, 2...，从内向外则为 -1, -2...，默认值为 -1（最内层）。
• 与透视表的区别：两者都重塑数据，但透视表（pivot_table）通常伴随聚合操作（如求和、求平均），而 stack/unstack 仅重构，不聚合。

理解 stack：将列旋转为行

stack 操作直观上可以理解为“堆叠”，它将列索引的某一层级“压缩”到行索引中，从而将数据从较宽的格式转换为较长的格式。

核心机制：对于一个具有多层列索引的 DataFrame，stack 会选取列索引的指定层级（默认为最内层），将其转换为行索引的新层级。结果通常是一个具有更多行、更少列的 Series 或 DataFrame。

为了更好地演示，我们先构造一个具有多层列索引的示例数据。

import pandas as pd

# 构造一个具有多层列索引的 DataFrame
# 外层列索引：学期（Semester1, Semester2）
# 内层列索引：科目（Maths, Science）
header = pd.MultiIndex.from_product([['Semester1', 'Semester2'], ['Maths', 'Science']])
# 数据：四名学生，两个学期，两门科目的成绩
data = [
    [12, 45, 67, 56],  # Alisa
    [78, 89, 45, 67],  # Bobby
    [45, 67, 89, 90],  # Cathrine
    [67, 44, 56, 55]   # Jack
]
df = pd.DataFrame(data,
                  index=['Alisa', 'Bobby', 'Cathrine', 'Jack'],
                  columns=header)
print("原始 DataFrame (多层列索引):")
print(df)

原始 DataFrame (多层列索引):
         Semester1         Semester2
             Maths Science     Maths Science
Alisa           12      45        67      56
Bobby           78      89        45      67
Cathrine        45      67        89      90
Jack            67      44        56      55

现在，我们对这个 DataFrame 进行 stack 操作。默认情况下 (level=-1)，它会旋转最内层的列索引（即“科目”：Maths 和 Science）。

import pandas as pd

# 重新构造数据，确保代码块自包含
header = pd.MultiIndex.from_product([['Semester1', 'Semester2'], ['Maths', 'Science']])
data = [[12, 45, 67, 56], [78, 89, 45, 67], [45, 67, 89, 90], [67, 44, 56, 55]]
df = pd.DataFrame(data, index=['Alisa', 'Bobby', 'Cathrine', 'Jack'], columns=header)

# 默认 stack 操作 (level=-1，旋转最内层索引)
stacked_df = df.stack()
print("\n默认 stack() 后的结果 (旋转科目到行):")
print(stacked_df)

默认 stack() 后的结果 (旋转科目到行):
                  Semester1  Semester2
Alisa    Maths           12         67
         Science         45         56
Bobby    Maths           78         45
         Science         89         67
Cathrine Maths           45         89
         Science         67         90
Jack     Maths           67         56
         Science         44         55

观察结果：原来的列索引 (Semester1, Maths)、(Semester1, Science) 等被“堆叠”了。科目（Maths, Science） 这一层从列索引中移出，成为了行索引的新一层。现在，行索引变成了两层：学生姓名和科目；列索引则只剩学期（Semester1/Semester2）。数据从 4 行 × 4 列，变成了 8 行 × 2 列。

关键参数：level 指定旋转层级

level 参数决定了具体旋转列索引的哪一层。层级从外向内编号（0, 1, 2…）。

• level=0：旋转最外层列索引（本例中是“学期”：Semester1, Semester2）。
• level=1 或 level=-1：旋转最内层列索引（本例中是“科目”：Maths, Science），这也是默认行为。

import pandas as pd

# 重新构造数据
header = pd.MultiIndex.from_product([['Semester1', 'Semester2'], ['Maths', 'Science']])
data = [[12, 45, 67, 56], [78, 89, 45, 67], [45, 67, 89, 90], [67, 44, 56, 55]]
df = pd.DataFrame(data, index=['Alisa', 'Bobby', 'Cathrine', 'Jack'], columns=header)

# 指定 level=0，旋转最外层索引（学期）
stacked_semester = df.stack(level=0)
print("\nstack(level=0) 后的结果 (旋转学期到行):")
print(stacked_semester)

# 指定 level=1 或 level=-1，效果与默认相同
print("\nstack(level=1) 后的结果:")
print(df.stack(level=1))
print("\nstack(level=-1) 后的结果:")
print(df.stack(level=-1))

stack(level=0) 后的结果 (旋转学期到行):
                    Maths  Science
Alisa    Semester1     12       45
         Semester2     67       56
Bobby    Semester1     78       89
         Semester2     45       67
Cathrine Semester1     45       67
         Semester2     89       90
Jack     Semester1     67       44
         Semester2     56       55

stack(level=1) 后的结果:
                  Semester1  Semester2
Alisa    Maths           12         67
         Science         45         56
Bobby    Maths           78         45
         Science         89         67
Cathrine Maths           45         89
         Science         67         90
Jack     Maths           67         56
         Science         44         55

stack(level=-1) 后的结果:
                  Semester1  Semester2
Alisa    Maths           12         67
         Science         45         56
Bobby    Maths           78         45
         Science         89         67
Cathrine Maths           45         89
         Science         67         90
Jack     Maths           67         56
         Science         44         55

可以看到，stack(level=0) 将“学期”旋转到了行索引，而列只剩下“科目”。stack(level=1) 和 stack(level=-1) 的结果与默认情况完全一致。

理解 unstack：将行旋转为列

unstack 是 stack 的逆操作，可以理解为“展开”或“铺平”。它将行索引的某一层级“展开”到列索引中，从而将数据从较长的格式转换为较宽的格式。

核心机制：对于一个具有多层行索引的 Series 或 DataFrame，unstack 会选取行索引的指定层级（默认为最内层），将其转换为列索引的新层级。

我们使用 stack(level=0) 操作的结果来演示 unstack（此时行索引为「学生姓名＋学期」两层——注意默认 stack 的结果是「姓名＋科目」两层，这里取 level=0 的版本，便于观察 unstack 如何把「学期」展开回列）。

import pandas as pd

# 重新构造 stacked_df 的等价数据
index_tuples = [
    ('Alisa', 'Semester1'), ('Alisa', 'Semester2'),
    ('Bobby', 'Semester1'), ('Bobby', 'Semester2'),
    ('Cathrine', 'Semester1'), ('Cathrine', 'Semester2'),
    ('Jack', 'Semester1'), ('Jack', 'Semester2')
]
index = pd.MultiIndex.from_tuples(index_tuples, names=[None, None])
stacked_df = pd.DataFrame({'Maths': [12, 67, 78, 45, 45, 89, 67, 56],
                            'Science': [45, 56, 89, 67, 67, 90, 44, 55]},
                           index=index)

print("当前 stacked_df (两层行索引):")
print(stacked_df)

# 对上一步 stack 的结果进行 unstack
unstacked_df = stacked_df.unstack()
print("\n对 stacked_df 进行默认 unstack() 后的结果:")
print(unstacked_df)

当前 stacked_df (两层行索引):
                    Maths  Science
Alisa    Semester1     12       45
         Semester2     67       56
Bobby    Semester1     78       89
         Semester2     45       67
Cathrine Semester1     45       67
         Semester2     89       90
Jack     Semester1     67       44
         Semester2     56       55

对 stacked_df 进行默认 unstack() 后的结果:
             Maths             Science
         Semester1 Semester2 Semester1 Semester2
Alisa           12        67        45        56
Bobby           78        45        89        67
Cathrine        45        89        67        90
Jack            67        56        44        55

执行默认的 unstack()（level=-1）后，最内层的行索引（“学期”）被展开到了列索引，数据回到了宽格式。注意一个细节：unstack 后的列层级是「科目在外、学期在内」，与最初宽表「学期在外、科目在内」的层级顺序恰好相反——stack/unstack 只保证数值排布对应，并不严格互逆；若要完全还原最初的列层级顺序，还需再对列轴做一次层级交换（如 swaplevel/reorder_levels）。

同样，我们可以通过 level 参数指定旋转行索引的哪一层。

import pandas as pd

# 重新构造 stacked_df 的等价数据
index_tuples = [
    ('Alisa', 'Semester1'), ('Alisa', 'Semester2'),
    ('Bobby', 'Semester1'), ('Bobby', 'Semester2'),
    ('Cathrine', 'Semester1'), ('Cathrine', 'Semester2'),
    ('Jack', 'Semester1'), ('Jack', 'Semester2')
]
index = pd.MultiIndex.from_tuples(index_tuples, names=[None, None])
stacked_df = pd.DataFrame({'Maths': [12, 67, 78, 45, 45, 89, 67, 56],
                            'Science': [45, 56, 89, 67, 67, 90, 44, 55]},
                           index=index)

# 指定 level=0，旋转最外层行索引（学生姓名）
unstacked_name = stacked_df.unstack(level=0)
print("stacked_df.unstack(level=0) 后的结果 (旋转学生姓名到列):")
print(unstacked_name)

# 指定 level=1 或 level=-1，效果与默认相同
print("\nstacked_df.unstack(level=1) 后的结果:")
print(stacked_df.unstack(level=1))
print("\nstacked_df.unstack(level=-1) 后的结果:")
print(stacked_df.unstack(level=-1))

stacked_df.unstack(level=0) 后的结果 (旋转学生姓名到列):
          Maths                     Science
          Alisa Bobby Cathrine Jack   Alisa Bobby Cathrine Jack
Semester1    12    78       45   67      45    89       67   44
Semester2    67    45       89   56      56    67       90   55

stacked_df.unstack(level=1) 后的结果:
             Maths             Science
         Semester1 Semester2 Semester1 Semester2
Alisa           12        67        45        56
Bobby           78        45        89        67
Cathrine        45        89        67        90
Jack            67        56        44        55

stacked_df.unstack(level=-1) 后的结果:
             Maths             Science
         Semester1 Semester2 Semester1 Semester2
Alisa           12        67        45        56
Bobby           78        45        89        67
Cathrine        45        89        67        90
Jack            67        56        44        55

unstack(level=0) 将最外层的行索引（学生姓名）展开到了列，形成了以学期为行、以（学生，科目）组合为列的视图。

与透视表的关联与区别

stack/unstack 的操作结果，在形态上很像我们之前学过的透视表（pivot table）。它们都能将数据在“长格式”和“宽格式”之间转换。

核心区别在于：

• 透视表 (pivot_table)：在重塑数据的同时，通常会对重合的值进行聚合操作（如求和 sum、求平均 mean、计数 count 等）。它用于汇总和聚合数据。
• stack / unstack：仅对数据进行重构，不进行任何聚合计算。原始数据值被重新排列，但每个值本身保持不变。它用于改变数据的视图结构。

简单来说，如果你需要汇总统计，用透视表；如果只是需要换一种方式排列现有数据，用 stack/unstack。

📝 动手练一练

1. 概念辨析：假设你有一个记录每日不同城市销售金额的 DataFrame，列是城市，行是日期。如果你使用 df.stack()，得到的新数据结构中，行索引会是什么？这个操作相当于把数据转换成了哪种更利于时间序列分析或模型输入的格式？

2. 代码实践：使用我们示例中的 stacked_df（学生-学期为行索引，科目为列），编写代码将其转换为一个以“学生”为行、“学期”和“科目”组合为列的 DataFrame（即 unstack(level=1) 的结果），并计算每位学生在Semester1的Maths和Science两科平均分。

import pandas as pd

# 构造 stacked_df
index_tuples = [('Alisa', 'Semester1'), ('Alisa', 'Semester2'),
                ('Bobby', 'Semester1'), ('Bobby', 'Semester2'),
                ('Cathrine', 'Semester1'), ('Cathrine', 'Semester2'),
                ('Jack', 'Semester1'), ('Jack', 'Semester2')]
index = pd.MultiIndex.from_tuples(index_tuples)
stacked_df = pd.DataFrame({'Maths': [12, 67, 78, 45, 45, 89, 67, 56],
                            'Science': [45, 56, 89, 67, 67, 90, 44, 55]},
                           index=index)

# 1. 转换为目标格式
unstacked_semester_subject = stacked_df.unstack(level=1) # 旋转“学期”到列
print("转换后的 DataFrame:")
print(unstacked_semester_subject)

# 2. 计算 Semester1 两科平均分
# 先筛选出 Semester1 的列，然后按行求平均
semester1_avg = unstacked_semester_subject.loc[:, (slice(None), 'Semester1')].mean(axis=1)
print("\n每位学生 Semester1 两科平均分:")
print(semester1_avg)

转换后的 DataFrame:
             Maths             Science
         Semester1 Semester2 Semester1 Semester2
Alisa           12        67        45        56
Bobby           78        45        89        67
Cathrine        45        89        67        90
Jack            67        56        44        55

每位学生 Semester1 两科平均分:
Alisa       28.5
Bobby       83.5
Cathrine    56.0
Jack        55.5
dtype: float64

本章小结

stack 和 unstack 是 Pandas 数据规整工具箱中不可或缺的工具，它们基于层级索引，高效地在数据的长、宽格式间进行无损转换。

• stack()：将指定层级的列索引旋转为行索引，使数据变“长”。
• unstack()：将指定层级的行索引旋转为列索引，使数据变“宽”。
• 参数 level：精确控制操作发生在哪个索引层级，理解层级编号（从外向内 0,1,...，从内向外 -1,-2,...）是关键。
• 与透视表的区别：牢记 stack/unstack 不聚合数据，仅重构；而透视表的核心功能是聚合汇总。

📋 行动清单

• 在 Jupyter Notebook 中亲手运行本节所有示例代码，观察每一步数据形状和索引的变化。
• 尝试对一个三层索引（如：年份-季度-产品类别）的模拟 DataFrame 进行 stack(level=1) 和 unstack(level=0) 操作，并预测结果。
• 思考你手头或之前练习中的一个数据集，是否可以通过 stack/unstack 转换为更利于分析的格式。

—— 小象教研组