pandas.DataFrame.stack

DataFrame.stack(level=-1, dropna=_NoDefault.no_default, sort=_NoDefault.no_default, future_stack=False)

将指定级别的列堆叠到索引。

返回一个重塑的 DataFrame 或 Series，它具有比当前 DataFrame 多一个或多个新的最内层级别多重索引。新的最内层级别是通过透视当前 DataFrame 的列创建的：

• 如果列有单层，则输出为 Series；

• 如果列有多层，则新的索引级别从指定的级别（们）中获取，输出为 DataFrame。

Parameters:

levelint, str, list, default -1

从列轴堆叠到索引轴的级别。可以是一个索引或标签，或索引或标签的列表。

dropnabool, default True

在堆叠一个列级别到索引轴时，可能会创建原始 DataFrame 中不存在的索引和列值组合。是否删除结果 DataFrame/Series 中具有缺失值的行。请参阅示例部分。

sortbool, default True

是否对resulting MultiIndex 的级别进行排序。

future_stackbool，默认 False

是否使用将在 pandas 3.0 中替换当前实现的`新实现`。当 True 时，dropna 和 sort 对结果没有影响，并且必须保持未指定。请参阅 pandas 2.1.0 Release notes 以获取更多详细信息。

Returns:

DataFrame 或 Series

堆叠后的 DataFrame 或 Series。

参见

DataFrame.unstack

将指定的级别（们）从索引轴“取消堆叠”到列轴。

DataFrame.pivot

将 DataFrame 从长格式重塑为宽格式。

DataFrame.pivot_table

创建电子表格风格的透视表作为 DataFrame。

Notes

该函数的名字来源于一个比喻：一堆书从并排放在水平位置（DataFrame 的列）重新组织成堆叠在彼此上方（在 DataFrame 的索引中）。

有关更多示例，请参阅 the user guide 。

Examples

单层列

>>> df_single_level_cols = pd.DataFrame([[0, 1], [2, 3]],
...                                     index=['cat', 'dog'],
...                                     columns=['weight', 'height'])

堆叠具有单层列轴的 DataFrame 会返回一个 Series：

>>> df_single_level_cols
     weight height
cat       0      1
dog       2      3
>>> df_single_level_cols.stack(future_stack=True)
cat  weight    0
     height    1
dog  weight    2
     height    3
dtype: int64

多层列：简单情况

>>> multicol1 = pd.MultiIndex.from_tuples([('weight', 'kg'),
...                                        ('weight', 'pounds')])
>>> df_multi_level_cols1 = pd.DataFrame([[1, 2], [2, 4]],
...                                     index=['cat', 'dog'],
...                                     columns=multicol1)

堆叠具有多层列轴的 DataFrame：

>>> df_multi_level_cols1
     weight
         kg    pounds
cat       1        2
dog       2        4
>>> df_multi_level_cols1.stack(future_stack=True)
            weight
cat kg           1
    pounds       2
dog kg           2
    pounds       4

缺失值

>>> multicol2 = pd.MultiIndex.from_tuples([('weight', 'kg'),
...                                        ('height', 'm')])
>>> df_multi_level_cols2 = pd.DataFrame([[1.0, 2.0], [3.0, 4.0]],
...                                     index=['cat', 'dog'],
...                                     columns=multicol2)

当堆叠具有多层列的 DataFrame 时，通常会出现缺失值，因为堆叠后的 DataFrame 通常比原始 DataFrame 具有更多的值。缺失值用 NaN 填充：

>>> df_multi_level_cols2
    weight height
        kg      m
cat    1.0    2.0
dog    3.0    4.0
>>> df_multi_level_cols2.stack(future_stack=True)
        weight  height
cat kg     1.0     NaN
    m      NaN     2.0
dog kg     3.0     NaN
    m      NaN     4.0

设置要堆叠的层级

第一个参数控制要堆叠的层级：

>>> df_multi_level_cols2.stack(0, future_stack=True)
             kg    m
cat weight  1.0  NaN
    height  NaN  2.0
dog weight  3.0  NaN
    height  NaN  4.0
>>> df_multi_level_cols2.stack([0, 1], future_stack=True)
cat  weight  kg    1.0
     height  m     2.0
dog  weight  kg    3.0
     height  m     4.0
dtype: float64